1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/generic/graphicc.cpp
3 // Purpose: cairo device context class
4 // Author: Stefan Csomor
8 // Copyright: (c) 2006 Stefan Csomor
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 #include "wx/wxprec.h"
18 #if wxUSE_GRAPHICS_CONTEXT
24 #include "wx/window.h"
27 #include "wx/dialog.h"
29 #include "wx/bitmap.h"
30 #include "wx/dcmemory.h"
33 #include "wx/dcprint.h"
34 #include "wx/module.h"
37 #include "wx/graphics.h"
38 #include "wx/rawbmp.h"
44 //-----------------------------------------------------------------------------
46 //-----------------------------------------------------------------------------
48 const double RAD2DEG
= 180.0 / M_PI
;
50 //-----------------------------------------------------------------------------
52 //-----------------------------------------------------------------------------
54 static inline double dmin(double a
, double b
)
58 static inline double dmax(double a
, double b
)
63 static inline double DegToRad(double deg
)
65 return (deg
* M_PI
) / 180.0;
67 static inline double RadToDeg(double deg
)
69 return (deg
* 180.0) / M_PI
;
72 //-----------------------------------------------------------------------------
73 // device context implementation
75 // more and more of the dc functionality should be implemented by calling
76 // the appropricate wxCairoContext, but we will have to do that step by step
77 // also coordinate conversions should be moved to native matrix ops
78 //-----------------------------------------------------------------------------
80 // we always stock two context states, one at entry, to be able to preserve the
81 // state we were called with, the other one after changing to HI Graphics orientation
82 // (this one is used for getting back clippings etc)
84 //-----------------------------------------------------------------------------
85 // wxGraphicsPath implementation
86 //-----------------------------------------------------------------------------
88 // TODO remove this dependency (gdiplus needs the macros)
91 #define max(a,b) (((a) > (b)) ? (a) : (b))
95 #define min(a,b) (((a) < (b)) ? (a) : (b))
101 #include "wx/fontutil.h"
105 #include <cairo-win32.h>
109 #include "wx/mac/private.h"
110 #include <cairo-quartz.h>
111 #include <cairo-atsui.h>
114 class WXDLLIMPEXP_CORE wxCairoPathData
: public wxGraphicsPathData
117 wxCairoPathData(wxGraphicsRenderer
* renderer
, cairo_t
* path
= NULL
);
120 virtual wxGraphicsObjectRefData
*Clone() const;
123 // These are the path primitives from which everything else can be constructed
126 // begins a new subpath at (x,y)
127 virtual void MoveToPoint( wxDouble x
, wxDouble y
);
129 // adds a straight line from the current point to (x,y)
130 virtual void AddLineToPoint( wxDouble x
, wxDouble y
);
132 // adds a cubic Bezier curve from the current point, using two control points and an end point
133 virtual void AddCurveToPoint( wxDouble cx1
, wxDouble cy1
, wxDouble cx2
, wxDouble cy2
, wxDouble x
, wxDouble y
);
136 // adds an arc of a circle centering at (x,y) with radius (r) from startAngle to endAngle
137 virtual void AddArc( wxDouble x
, wxDouble y
, wxDouble r
, wxDouble startAngle
, wxDouble endAngle
, bool clockwise
) ;
139 // gets the last point of the current path, (0,0) if not yet set
140 virtual void GetCurrentPoint( wxDouble
* x
, wxDouble
* y
) const;
143 virtual void AddPath( const wxGraphicsPathData
* path
);
145 // closes the current sub-path
146 virtual void CloseSubpath();
149 // These are convenience functions which - if not available natively will be assembled
150 // using the primitives from above
155 // appends a rectangle as a new closed subpath
156 virtual void AddRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h ) ;
157 // appends an ellipsis as a new closed subpath fitting the passed rectangle
158 virtual void AddEllipsis( wxDouble x, wxDouble y, wxDouble w , wxDouble h ) ;
160 // 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)
161 virtual void AddArcToPoint( wxDouble x1, wxDouble y1 , wxDouble x2, wxDouble y2, wxDouble r ) ;
164 // returns the native path
165 virtual void * GetNativePath() const ;
167 // give the native path returned by GetNativePath() back (there might be some deallocations necessary)
168 virtual void UnGetNativePath(void *p
) const;
170 // transforms each point of this path by the matrix
171 virtual void Transform( const wxGraphicsMatrixData
* matrix
) ;
173 // gets the bounding box enclosing all points (possibly including control points)
174 virtual void GetBox(wxDouble
*x
, wxDouble
*y
, wxDouble
*w
, wxDouble
*h
) const;
176 virtual bool Contains( wxDouble x
, wxDouble y
, int fillStyle
= wxWINDING_RULE
) const;
179 cairo_t
* m_pathContext
;
182 class WXDLLIMPEXP_CORE wxCairoMatrixData
: public wxGraphicsMatrixData
185 wxCairoMatrixData(wxGraphicsRenderer
* renderer
, const cairo_matrix_t
* matrix
= NULL
) ;
186 virtual ~wxCairoMatrixData() ;
188 virtual wxGraphicsObjectRefData
*Clone() const ;
190 // concatenates the matrix
191 virtual void Concat( const wxGraphicsMatrixData
*t
);
193 // sets the matrix to the respective values
194 virtual void Set(wxDouble a
=1.0, wxDouble b
=0.0, wxDouble c
=0.0, wxDouble d
=1.0,
195 wxDouble tx
=0.0, wxDouble ty
=0.0);
197 // gets the component valuess of the matrix
198 virtual void Get(wxDouble
* a
=NULL
, wxDouble
* b
=NULL
, wxDouble
* c
=NULL
,
199 wxDouble
* d
=NULL
, wxDouble
* tx
=NULL
, wxDouble
* ty
=NULL
) const;
201 // makes this the inverse matrix
202 virtual void Invert();
204 // returns true if the elements of the transformation matrix are equal ?
205 virtual bool IsEqual( const wxGraphicsMatrixData
* t
) const ;
207 // return true if this is the identity matrix
208 virtual bool IsIdentity() const;
214 // add the translation to this matrix
215 virtual void Translate( wxDouble dx
, wxDouble dy
);
217 // add the scale to this matrix
218 virtual void Scale( wxDouble xScale
, wxDouble yScale
);
220 // add the rotation to this matrix (radians)
221 virtual void Rotate( wxDouble angle
);
224 // apply the transforms
227 // applies that matrix to the point
228 virtual void TransformPoint( wxDouble
*x
, wxDouble
*y
) const;
230 // applies the matrix except for translations
231 virtual void TransformDistance( wxDouble
*dx
, wxDouble
*dy
) const;
233 // returns the native representation
234 virtual void * GetNativeMatrix() const;
236 cairo_matrix_t m_matrix
;
239 class WXDLLIMPEXP_CORE wxCairoPenData
: public wxGraphicsObjectRefData
242 wxCairoPenData( wxGraphicsRenderer
* renderer
, const wxPen
&pen
);
247 virtual void Apply( wxGraphicsContext
* context
);
248 virtual wxDouble
GetWidth() { return m_width
; }
258 cairo_line_cap_t m_cap
;
259 cairo_line_join_t m_join
;
262 const double *m_lengths
;
263 double *m_userLengths
;
268 class WXDLLIMPEXP_CORE wxCairoBrushData
: public wxGraphicsObjectRefData
271 wxCairoBrushData( wxGraphicsRenderer
* renderer
);
272 wxCairoBrushData( wxGraphicsRenderer
* renderer
, const wxBrush
&brush
);
273 ~wxCairoBrushData ();
275 virtual void Apply( wxGraphicsContext
* context
);
276 void CreateLinearGradientBrush( wxDouble x1
, wxDouble y1
, wxDouble x2
, wxDouble y2
,
277 const wxColour
&c1
, const wxColour
&c2
);
278 void CreateRadialGradientBrush( wxDouble xo
, wxDouble yo
, wxDouble xc
, wxDouble yc
, wxDouble radius
,
279 const wxColour
&oColor
, const wxColour
&cColor
);
290 cairo_pattern_t
* m_brushPattern
;
293 class wxCairoFontData
: public wxGraphicsObjectRefData
296 wxCairoFontData( wxGraphicsRenderer
* renderer
, const wxFont
&font
, const wxColour
& col
);
299 virtual void Apply( wxGraphicsContext
* context
);
301 const PangoFontDescription
* GetFont() const { return m_font
; }
310 cairo_font_face_t
*m_font
;
311 #elif defined(__WXGTK__)
312 PangoFontDescription
* m_font
;
314 wxCharBuffer m_fontName
;
315 cairo_font_slant_t m_slant
;
316 cairo_font_weight_t m_weight
;
320 class WXDLLIMPEXP_CORE wxCairoContext
: public wxGraphicsContext
322 DECLARE_NO_COPY_CLASS(wxCairoContext
)
325 wxCairoContext( wxGraphicsRenderer
* renderer
, const wxWindowDC
& dc
);
327 wxCairoContext( wxGraphicsRenderer
* renderer
, GdkDrawable
*drawable
);
329 wxCairoContext( wxGraphicsRenderer
* renderer
, cairo_t
*context
);
330 wxCairoContext( wxGraphicsRenderer
* renderer
, wxWindow
*window
);
332 virtual ~wxCairoContext();
334 virtual bool ShouldOffset() const
337 if ( !m_pen
.IsNull() )
339 penwidth
= (int)((wxCairoPenData
*)m_pen
.GetRefData())->GetWidth();
343 return ( penwidth
% 2 ) == 1;
346 virtual void Clip( const wxRegion
®ion
);
348 // clips drawings to the rect
349 virtual void Clip( wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
);
351 // resets the clipping to original extent
352 virtual void ResetClip();
354 virtual void * GetNativeContext();
356 virtual void StrokePath( const wxGraphicsPath
& p
);
357 virtual void FillPath( const wxGraphicsPath
& p
, int fillStyle
= wxWINDING_RULE
);
359 virtual void Translate( wxDouble dx
, wxDouble dy
);
360 virtual void Scale( wxDouble xScale
, wxDouble yScale
);
361 virtual void Rotate( wxDouble angle
);
363 // concatenates this transform with the current transform of this context
364 virtual void ConcatTransform( const wxGraphicsMatrix
& matrix
);
366 // sets the transform of this context
367 virtual void SetTransform( const wxGraphicsMatrix
& matrix
);
369 // gets the matrix of this context
370 virtual wxGraphicsMatrix
GetTransform() const;
372 virtual void DrawBitmap( const wxBitmap
&bmp
, wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
);
373 virtual void DrawIcon( const wxIcon
&icon
, wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
);
374 virtual void PushState();
375 virtual void PopState();
377 virtual void DrawText( const wxString
&str
, wxDouble x
, wxDouble y
);
378 virtual void GetTextExtent( const wxString
&str
, wxDouble
*width
, wxDouble
*height
,
379 wxDouble
*descent
, wxDouble
*externalLeading
) const;
380 virtual void GetPartialTextExtents(const wxString
& text
, wxArrayDouble
& widths
) const;
383 void Init(cairo_t
*context
);
388 //-----------------------------------------------------------------------------
389 // wxCairoPenData implementation
390 //-----------------------------------------------------------------------------
392 wxCairoPenData
::~wxCairoPenData()
394 delete[] m_userLengths
;
397 void wxCairoPenData
::Init()
400 m_userLengths
= NULL
;
405 wxCairoPenData
::wxCairoPenData( wxGraphicsRenderer
* renderer
, const wxPen
&pen
)
406 : wxGraphicsObjectRefData(renderer
)
410 m_width
= m_pen
.GetWidth();
414 m_red
= m_pen
.GetColour().Red()/255.0;
415 m_green
= m_pen
.GetColour().Green()/255.0;
416 m_blue
= m_pen
.GetColour().Blue()/255.0;
417 m_alpha
= m_pen
.GetColour().Alpha()/255.0;
419 switch ( m_pen
.GetCap() )
422 m_cap
= CAIRO_LINE_CAP_ROUND
;
425 case wxCAP_PROJECTING
:
426 m_cap
= CAIRO_LINE_CAP_SQUARE
;
430 m_cap
= CAIRO_LINE_CAP_BUTT
;
434 m_cap
= CAIRO_LINE_CAP_BUTT
;
438 switch ( m_pen
.GetJoin() )
441 m_join
= CAIRO_LINE_JOIN_BEVEL
;
445 m_join
= CAIRO_LINE_JOIN_MITER
;
449 m_join
= CAIRO_LINE_JOIN_ROUND
;
453 m_join
= CAIRO_LINE_JOIN_MITER
;
457 const double dashUnit
= m_width
< 1.0 ?
1.0 : m_width
;
458 const double dotted
[] =
460 dashUnit
, dashUnit
+ 2.0
462 static const double short_dashed
[] =
466 static const double dashed
[] =
470 static const double dotted_dashed
[] =
472 9.0 , 6.0 , 3.0 , 3.0
475 switch ( m_pen
.GetStyle() )
481 m_count
= WXSIZEOF(dotted
);
482 m_userLengths
= new double[ m_count
] ;
483 memcpy( m_userLengths
, dotted
, sizeof(dotted
) );
484 m_lengths
= m_userLengths
;
489 m_count
= WXSIZEOF(dashed
);
493 m_lengths
= short_dashed
;
494 m_count
= WXSIZEOF(short_dashed
);
498 m_lengths
= dotted_dashed
;
499 m_count
= WXSIZEOF(dotted_dashed
);
505 m_count
= m_pen
.GetDashes( &wxdashes
) ;
506 if ((wxdashes
!= NULL
) && (m_count
> 0))
508 m_userLengths
= new double[m_count
] ;
509 for ( int i
= 0 ; i
< m_count
; ++i
)
511 m_userLengths
[i
] = wxdashes
[i
] * dashUnit
;
513 if ( i
% 2 == 1 && m_userLengths
[i
] < dashUnit
+ 2.0 )
514 m_userLengths
[i
] = dashUnit
+ 2.0 ;
515 else if ( i
% 2 == 0 && m_userLengths
[i
] < dashUnit
)
516 m_userLengths
[i
] = dashUnit
;
519 m_lengths
= m_userLengths
;
525 wxBitmap* bmp = pen.GetStipple();
526 if ( bmp && bmp->Ok() )
528 wxDELETE( m_penImage );
529 wxDELETE( m_penBrush );
530 m_penImage = Bitmap::FromHBITMAP((HBITMAP)bmp->GetHBITMAP(),(HPALETTE)bmp->GetPalette()->GetHPALETTE());
531 m_penBrush = new TextureBrush(m_penImage);
532 m_pen->SetBrush( m_penBrush );
538 if ( m_pen
.GetStyle() >= wxFIRST_HATCH
&& m_pen
.GetStyle() <= wxLAST_HATCH
)
541 wxDELETE( m_penBrush );
542 HatchStyle style = HatchStyleHorizontal;
543 switch( pen.GetStyle() )
545 case wxBDIAGONAL_HATCH :
546 style = HatchStyleBackwardDiagonal;
548 case wxCROSSDIAG_HATCH :
549 style = HatchStyleDiagonalCross;
551 case wxFDIAGONAL_HATCH :
552 style = HatchStyleForwardDiagonal;
555 style = HatchStyleCross;
557 case wxHORIZONTAL_HATCH :
558 style = HatchStyleHorizontal;
560 case wxVERTICAL_HATCH :
561 style = HatchStyleVertical;
565 m_penBrush = new HatchBrush(style,Color( pen.GetColour().Alpha() , pen.GetColour().Red() ,
566 pen.GetColour().Green() , pen.GetColour().Blue() ), Color.Transparent );
567 m_pen->SetBrush( m_penBrush )
574 void wxCairoPenData
::Apply( wxGraphicsContext
* context
)
576 cairo_t
* ctext
= (cairo_t
*) context
->GetNativeContext();
577 cairo_set_line_width(ctext
,m_width
);
578 cairo_set_source_rgba(ctext
,m_red
,m_green
, m_blue
,m_alpha
);
579 cairo_set_line_cap(ctext
,m_cap
);
580 cairo_set_line_join(ctext
,m_join
);
581 cairo_set_dash(ctext
,(double*)m_lengths
,m_count
,0.0);
584 //-----------------------------------------------------------------------------
585 // wxCairoBrushData implementation
586 //-----------------------------------------------------------------------------
588 wxCairoBrushData
::wxCairoBrushData( wxGraphicsRenderer
* renderer
)
589 : wxGraphicsObjectRefData( renderer
)
594 wxCairoBrushData
::wxCairoBrushData( wxGraphicsRenderer
* renderer
, const wxBrush
&brush
)
595 : wxGraphicsObjectRefData(renderer
)
599 m_red
= brush
.GetColour().Red()/255.0;
600 m_green
= brush
.GetColour().Green()/255.0;
601 m_blue
= brush
.GetColour().Blue()/255.0;
602 m_alpha
= brush
.GetColour().Alpha()/255.0;
604 if ( brush.GetStyle() == wxSOLID)
606 m_brush = new SolidBrush( Color( brush.GetColour().Alpha() , brush.GetColour().Red() ,
607 brush.GetColour().Green() , brush.GetColour().Blue() ) );
609 else if ( brush.IsHatch() )
611 HatchStyle style = HatchStyleHorizontal;
612 switch( brush.GetStyle() )
614 case wxBDIAGONAL_HATCH :
615 style = HatchStyleBackwardDiagonal;
617 case wxCROSSDIAG_HATCH :
618 style = HatchStyleDiagonalCross;
620 case wxFDIAGONAL_HATCH :
621 style = HatchStyleForwardDiagonal;
624 style = HatchStyleCross;
626 case wxHORIZONTAL_HATCH :
627 style = HatchStyleHorizontal;
629 case wxVERTICAL_HATCH :
630 style = HatchStyleVertical;
634 m_brush = new HatchBrush(style,Color( brush.GetColour().Alpha() , brush.GetColour().Red() ,
635 brush.GetColour().Green() , brush.GetColour().Blue() ), Color.Transparent );
639 wxBitmap* bmp = brush.GetStipple();
640 if ( bmp && bmp->Ok() )
642 wxDELETE( m_brushImage );
643 m_brushImage = Bitmap::FromHBITMAP((HBITMAP)bmp->GetHBITMAP(),(HPALETTE)bmp->GetPalette()->GetHPALETTE());
644 m_brush = new TextureBrush(m_brushImage);
650 wxCairoBrushData
::~wxCairoBrushData ()
653 cairo_pattern_destroy(m_brushPattern
);
656 void wxCairoBrushData
::Apply( wxGraphicsContext
* context
)
658 cairo_t
* ctext
= (cairo_t
*) context
->GetNativeContext();
659 if ( m_brushPattern
)
661 cairo_set_source(ctext
,m_brushPattern
);
665 cairo_set_source_rgba(ctext
,m_red
,m_green
, m_blue
,m_alpha
);
669 void wxCairoBrushData
::CreateLinearGradientBrush( wxDouble x1
, wxDouble y1
, wxDouble x2
, wxDouble y2
,
670 const wxColour
&c1
, const wxColour
&c2
)
672 m_brushPattern
= cairo_pattern_create_linear(x1
,y1
,x2
,y2
);
673 cairo_pattern_add_color_stop_rgba(m_brushPattern
,0.0,c1
.Red()/255.0,
674 c1
.Green()/255.0, c1
.Blue()/255.0,c1
.Alpha()/255.0);
675 cairo_pattern_add_color_stop_rgba(m_brushPattern
,1.0,c2
.Red()/255.0,
676 c2
.Green()/255.0, c2
.Blue()/255.0,c2
.Alpha()/255.0);
677 wxASSERT_MSG(cairo_pattern_status(m_brushPattern
) == CAIRO_STATUS_SUCCESS
, wxT("Couldn't create cairo pattern"));
680 void wxCairoBrushData
::CreateRadialGradientBrush( wxDouble xo
, wxDouble yo
, wxDouble xc
, wxDouble yc
, wxDouble radius
,
681 const wxColour
&oColor
, const wxColour
&cColor
)
683 m_brushPattern
= cairo_pattern_create_radial(xo
,yo
,0.0,xc
,yc
,radius
);
684 cairo_pattern_add_color_stop_rgba(m_brushPattern
,0.0,oColor
.Red()/255.0,
685 oColor
.Green()/255.0, oColor
.Blue()/255.0,oColor
.Alpha()/255.0);
686 cairo_pattern_add_color_stop_rgba(m_brushPattern
,1.0,cColor
.Red()/255.0,
687 cColor
.Green()/255.0, cColor
.Blue()/255.0,cColor
.Alpha()/255.0);
688 wxASSERT_MSG(cairo_pattern_status(m_brushPattern
) == CAIRO_STATUS_SUCCESS
, wxT("Couldn't create cairo pattern"));
691 void wxCairoBrushData
::Init()
693 m_brushPattern
= NULL
;
696 //-----------------------------------------------------------------------------
697 // wxCairoFontData implementation
698 //-----------------------------------------------------------------------------
700 wxCairoFontData
::wxCairoFontData( wxGraphicsRenderer
* renderer
, const wxFont
&font
,
701 const wxColour
& col
) : wxGraphicsObjectRefData(renderer
)
703 m_red
= col
.Red()/255.0;
704 m_green
= col
.Green()/255.0;
705 m_blue
= col
.Blue()/255.0;
706 m_alpha
= col
.Alpha()/255.0;
707 m_size
= font
.GetPointSize();
710 m_font
= cairo_atsui_font_face_create_for_atsu_font_id( font
.MacGetATSUFontID() );
711 #elif defined(__WXGTK__)
712 m_font
= pango_font_description_copy( font
.GetNativeFontInfo()->description
);
714 m_fontName
= font
.GetFaceName().mb_str(wxConvUTF8
);
715 m_slant
= font
.GetStyle() == wxFONTSTYLE_ITALIC ? CAIRO_FONT_SLANT_ITALIC
:CAIRO_FONT_SLANT_NORMAL
;
716 m_weight
= font
.GetWeight() == wxFONTWEIGHT_BOLD ? CAIRO_FONT_WEIGHT_BOLD
:CAIRO_FONT_WEIGHT_NORMAL
;
720 wxCairoFontData
::~wxCairoFontData()
723 cairo_font_face_destroy( m_font
);
724 #elif defined(__WXGTK__)
725 pango_font_description_free( m_font
);
730 void wxCairoFontData
::Apply( wxGraphicsContext
* context
)
732 cairo_t
* ctext
= (cairo_t
*) context
->GetNativeContext();
733 cairo_set_source_rgba(ctext
,m_red
,m_green
, m_blue
,m_alpha
);
735 // the rest is done using Pango layouts
736 #elif defined(__WXMAC__)
737 cairo_set_font_face(ctext
, m_font
);
739 cairo_select_font_face(ctext
, m_fontName
, m_slant
, m_weights
);
740 cairo_set_font_size(ctext
, m_size
);
744 //-----------------------------------------------------------------------------
745 // wxCairoPathData implementation
746 //-----------------------------------------------------------------------------
748 wxCairoPathData
::wxCairoPathData( wxGraphicsRenderer
* renderer
, cairo_t
* pathcontext
)
749 : wxGraphicsPathData(renderer
)
753 m_pathContext
= pathcontext
;
757 cairo_surface_t
* surface
= cairo_image_surface_create(CAIRO_FORMAT_ARGB32
,1,1);
758 m_pathContext
= cairo_create(surface
);
759 cairo_surface_destroy (surface
);
763 wxCairoPathData
::~wxCairoPathData()
765 cairo_destroy(m_pathContext
);
768 wxGraphicsObjectRefData
*wxCairoPathData
::Clone() const
770 cairo_surface_t
* surface
= cairo_image_surface_create(CAIRO_FORMAT_ARGB32
,1,1);
771 cairo_t
* pathcontext
= cairo_create(surface
);
772 cairo_surface_destroy (surface
);
774 cairo_path_t
* path
= cairo_copy_path(m_pathContext
);
775 cairo_append_path(pathcontext
, path
);
776 cairo_path_destroy(path
);
777 return new wxCairoPathData( GetRenderer() ,pathcontext
);
781 void* wxCairoPathData
::GetNativePath() const
783 return cairo_copy_path(m_pathContext
) ;
786 void wxCairoPathData
::UnGetNativePath(void *p
) const
788 cairo_path_destroy((cairo_path_t
*)p
);
795 void wxCairoPathData
::MoveToPoint( wxDouble x
, wxDouble y
)
797 cairo_move_to(m_pathContext
,x
,y
);
800 void wxCairoPathData
::AddLineToPoint( wxDouble x
, wxDouble y
)
802 cairo_line_to(m_pathContext
,x
,y
);
805 void wxCairoPathData
::AddPath( const wxGraphicsPathData
* path
)
807 cairo_path_t
* p
= (cairo_path_t
*)path
->GetNativePath();
808 cairo_append_path(m_pathContext
, p
);
812 void wxCairoPathData
::CloseSubpath()
814 cairo_close_path(m_pathContext
);
817 void wxCairoPathData
::AddCurveToPoint( wxDouble cx1
, wxDouble cy1
, wxDouble cx2
, wxDouble cy2
, wxDouble x
, wxDouble y
)
819 cairo_curve_to(m_pathContext
,cx1
,cy1
,cx2
,cy2
,x
,y
);
822 // gets the last point of the current path, (0,0) if not yet set
823 void wxCairoPathData
::GetCurrentPoint( wxDouble
* x
, wxDouble
* y
) const
826 cairo_get_current_point(m_pathContext
,&dx
,&dy
);
833 void wxCairoPathData
::AddArc( wxDouble x
, wxDouble y
, wxDouble r
, double startAngle
, double endAngle
, bool clockwise
)
835 // as clockwise means positive in our system (y pointing downwards)
836 // TODO make this interpretation dependent of the
838 if ( clockwise
||(endAngle
-startAngle
)>=2*M_PI
)
839 cairo_arc(m_pathContext
,x
,y
,r
,startAngle
,endAngle
);
841 cairo_arc_negative(m_pathContext
,x
,y
,r
,startAngle
,endAngle
);
844 // transforms each point of this path by the matrix
845 void wxCairoPathData
::Transform( const wxGraphicsMatrixData
* matrix
)
847 // as we don't have a true path object, we have to apply the inverse
848 // matrix to the context
849 cairo_matrix_t m
= *((cairo_matrix_t
*) matrix
->GetNativeMatrix());
850 cairo_matrix_invert( &m
);
851 cairo_transform(m_pathContext
,&m
);
854 // gets the bounding box enclosing all points (possibly including control points)
855 void wxCairoPathData
::GetBox(wxDouble
*x
, wxDouble
*y
, wxDouble
*w
, wxDouble
*h
) const
859 cairo_stroke_extents( m_pathContext
, &x1
, &y1
, &x2
, &y2
);
883 bool wxCairoPathData
::Contains( wxDouble x
, wxDouble y
, int WXUNUSED(fillStyle
) ) const
885 return cairo_in_stroke( m_pathContext
, x
, y
) != 0;
888 //-----------------------------------------------------------------------------
889 // wxCairoMatrixData implementation
890 //-----------------------------------------------------------------------------
892 wxCairoMatrixData
::wxCairoMatrixData(wxGraphicsRenderer
* renderer
, const cairo_matrix_t
* matrix
)
893 : wxGraphicsMatrixData(renderer
)
899 wxCairoMatrixData
::~wxCairoMatrixData()
904 wxGraphicsObjectRefData
*wxCairoMatrixData
::Clone() const
906 return new wxCairoMatrixData(GetRenderer(),&m_matrix
);
909 // concatenates the matrix
910 void wxCairoMatrixData
::Concat( const wxGraphicsMatrixData
*t
)
912 cairo_matrix_multiply( &m_matrix
, &m_matrix
, (cairo_matrix_t
*) t
->GetNativeMatrix());
915 // sets the matrix to the respective values
916 void wxCairoMatrixData
::Set(wxDouble a
, wxDouble b
, wxDouble c
, wxDouble d
,
917 wxDouble tx
, wxDouble ty
)
919 cairo_matrix_init( &m_matrix
, a
, b
, c
, d
, tx
, ty
);
922 // gets the component valuess of the matrix
923 void wxCairoMatrixData
::Get(wxDouble
* a
, wxDouble
* b
, wxDouble
* c
,
924 wxDouble
* d
, wxDouble
* tx
, wxDouble
* ty
) const
926 if (a
) *a
= m_matrix
.xx
;
927 if (b
) *b
= m_matrix
.yx
;
928 if (c
) *c
= m_matrix
.xy
;
929 if (d
) *d
= m_matrix
.yy
;
930 if (tx
) *tx
= m_matrix
.x0
;
931 if (ty
) *ty
= m_matrix
.y0
;
934 // makes this the inverse matrix
935 void wxCairoMatrixData
::Invert()
937 cairo_matrix_invert( &m_matrix
);
940 // returns true if the elements of the transformation matrix are equal ?
941 bool wxCairoMatrixData
::IsEqual( const wxGraphicsMatrixData
* t
) const
943 const cairo_matrix_t
* tm
= (cairo_matrix_t
*) t
->GetNativeMatrix();
945 m_matrix
.xx
== tm
->xx
&&
946 m_matrix
.yx
== tm
->yx
&&
947 m_matrix
.xy
== tm
->xy
&&
948 m_matrix
.yy
== tm
->yy
&&
949 m_matrix
.x0
== tm
->x0
&&
950 m_matrix
.y0
== tm
->y0
) ;
953 // return true if this is the identity matrix
954 bool wxCairoMatrixData
::IsIdentity() const
956 return ( m_matrix
.xx
== 1 && m_matrix
.yy
== 1 &&
957 m_matrix
.yx
== 0 && m_matrix
.xy
== 0 && m_matrix
.x0
== 0 && m_matrix
.y0
== 0);
964 // add the translation to this matrix
965 void wxCairoMatrixData
::Translate( wxDouble dx
, wxDouble dy
)
967 cairo_matrix_translate( &m_matrix
, dx
, dy
) ;
970 // add the scale to this matrix
971 void wxCairoMatrixData
::Scale( wxDouble xScale
, wxDouble yScale
)
973 cairo_matrix_scale( &m_matrix
, xScale
, yScale
) ;
976 // add the rotation to this matrix (radians)
977 void wxCairoMatrixData
::Rotate( wxDouble angle
)
979 cairo_matrix_rotate( &m_matrix
, angle
) ;
983 // apply the transforms
986 // applies that matrix to the point
987 void wxCairoMatrixData
::TransformPoint( wxDouble
*x
, wxDouble
*y
) const
989 double lx
= *x
, ly
= *y
;
990 cairo_matrix_transform_point( &m_matrix
, &lx
, &ly
);
995 // applies the matrix except for translations
996 void wxCairoMatrixData
::TransformDistance( wxDouble
*dx
, wxDouble
*dy
) const
998 double lx
= *dx
, ly
= *dy
;
999 cairo_matrix_transform_distance( &m_matrix
, &lx
, &ly
);
1004 // returns the native representation
1005 void * wxCairoMatrixData
::GetNativeMatrix() const
1007 return (void*) &m_matrix
;
1010 //-----------------------------------------------------------------------------
1011 // wxCairoContext implementation
1012 //-----------------------------------------------------------------------------
1014 class wxCairoOffsetHelper
1017 wxCairoOffsetHelper( cairo_t
* ctx
, bool offset
)
1022 cairo_translate( m_ctx
, 0.5, 0.5 );
1024 ~wxCairoOffsetHelper( )
1027 cairo_translate( m_ctx
, -0.5, -0.5 );
1034 wxCairoContext
::wxCairoContext( wxGraphicsRenderer
* renderer
, const wxWindowDC
& dc
)
1035 : wxGraphicsContext(renderer
)
1038 Init( gdk_cairo_create( dc
.m_window
) );
1042 dc
.GetSize( &width
, &height
);
1043 CGContextRef cgcontext
= (CGContextRef
)dc
.GetWindow()->MacGetCGContextRef();
1044 cairo_surface_t
* surface
= cairo_quartz_surface_create_for_cg_context(cgcontext
, width
, height
);
1045 Init( cairo_create( surface
) );
1046 cairo_surface_destroy( surface
);
1051 wxCairoContext
::wxCairoContext( wxGraphicsRenderer
* renderer
, GdkDrawable
*drawable
)
1052 : wxGraphicsContext(renderer
)
1054 Init( gdk_cairo_create( drawable
) );
1058 wxCairoContext
::wxCairoContext( wxGraphicsRenderer
* renderer
, cairo_t
*context
)
1059 : wxGraphicsContext(renderer
)
1064 wxCairoContext
::wxCairoContext( wxGraphicsRenderer
* renderer
, wxWindow
*window
)
1065 : wxGraphicsContext(renderer
)
1068 // something along these lines (copied from dcclient)
1070 // Some controls don't have m_wxwindow - like wxStaticBox, but the user
1071 // code should still be able to create wxClientDCs for them, so we will
1072 // use the parent window here then.
1073 if (window
->m_wxwindow
== NULL
)
1075 window
= window
->GetParent();
1078 wxASSERT_MSG( window
->m_wxwindow
, wxT("wxCairoContext needs a widget") );
1080 Init(gdk_cairo_create(window
->GTKGetDrawingWindow()));
1084 wxCairoContext
::~wxCairoContext()
1090 cairo_destroy(m_context
);
1094 void wxCairoContext
::Init(cairo_t
*context
)
1096 m_context
= context
;
1102 void wxCairoContext
::Clip( const wxRegion
& region
)
1104 // Create a path with all the rectangles in the region
1105 wxGraphicsPath path
= GetRenderer()->CreatePath();
1106 wxRegionIterator
ri(region
);
1109 path
.AddRectangle(ri
.GetX(), ri
.GetY(), ri
.GetW(), ri
.GetH());
1113 // Put it in the context
1114 cairo_path_t
* cp
= (cairo_path_t
*) path
.GetNativePath() ;
1115 cairo_append_path(m_context
, cp
);
1117 // clip to that path
1118 cairo_clip(m_context
);
1119 path
.UnGetNativePath(cp
);
1122 void wxCairoContext
::Clip( wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
)
1124 // Create a path with this rectangle
1125 wxGraphicsPath path
= GetRenderer()->CreatePath();
1126 path
.AddRectangle(x
,y
,w
,h
);
1128 // Put it in the context
1129 cairo_path_t
* cp
= (cairo_path_t
*) path
.GetNativePath() ;
1130 cairo_append_path(m_context
, cp
);
1132 // clip to that path
1133 cairo_clip(m_context
);
1134 path
.UnGetNativePath(cp
);
1137 void wxCairoContext
::ResetClip()
1139 cairo_reset_clip(m_context
);
1143 void wxCairoContext
::StrokePath( const wxGraphicsPath
& path
)
1145 if ( !m_pen
.IsNull() )
1147 wxCairoOffsetHelper
helper( m_context
, ShouldOffset() ) ;
1148 cairo_path_t
* cp
= (cairo_path_t
*) path
.GetNativePath() ;
1149 cairo_append_path(m_context
,cp
);
1150 ((wxCairoPenData
*)m_pen
.GetRefData())->Apply(this);
1151 cairo_stroke(m_context
);
1152 path
.UnGetNativePath(cp
);
1156 void wxCairoContext
::FillPath( const wxGraphicsPath
& path
, int fillStyle
)
1158 if ( !m_brush
.IsNull() )
1160 wxCairoOffsetHelper
helper( m_context
, ShouldOffset() ) ;
1161 cairo_path_t
* cp
= (cairo_path_t
*) path
.GetNativePath() ;
1162 cairo_append_path(m_context
,cp
);
1163 ((wxCairoBrushData
*)m_brush
.GetRefData())->Apply(this);
1164 cairo_set_fill_rule(m_context
,fillStyle
==wxODDEVEN_RULE ? CAIRO_FILL_RULE_EVEN_ODD
: CAIRO_FILL_RULE_WINDING
);
1165 cairo_fill(m_context
);
1166 path
.UnGetNativePath(cp
);
1170 void wxCairoContext
::Rotate( wxDouble angle
)
1172 cairo_rotate(m_context
,angle
);
1175 void wxCairoContext
::Translate( wxDouble dx
, wxDouble dy
)
1177 cairo_translate(m_context
,dx
,dy
);
1180 void wxCairoContext
::Scale( wxDouble xScale
, wxDouble yScale
)
1182 cairo_scale(m_context
,xScale
,yScale
);
1185 // concatenates this transform with the current transform of this context
1186 void wxCairoContext
::ConcatTransform( const wxGraphicsMatrix
& matrix
)
1188 cairo_transform(m_context
,(const cairo_matrix_t
*) matrix
.GetNativeMatrix());
1191 // sets the transform of this context
1192 void wxCairoContext
::SetTransform( const wxGraphicsMatrix
& matrix
)
1194 cairo_set_matrix(m_context
,(const cairo_matrix_t
*) matrix
.GetNativeMatrix());
1197 // gets the matrix of this context
1198 wxGraphicsMatrix wxCairoContext
::GetTransform() const
1200 wxGraphicsMatrix matrix
= CreateMatrix();
1201 cairo_get_matrix(m_context
,(cairo_matrix_t
*) matrix
.GetNativeMatrix());
1207 void wxCairoContext
::PushState()
1209 cairo_save(m_context
);
1212 void wxCairoContext
::PopState()
1214 cairo_restore(m_context
);
1217 void wxCairoContext
::DrawBitmap( const wxBitmap
&bmp
, wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
)
1219 wxCHECK_RET( bmp
.IsOk(), wxT("Invalid bitmap in wxCairoContext::DrawBitmap"));
1221 cairo_surface_t
* surface
;
1222 int bw
= bmp
.GetWidth();
1223 int bh
= bmp
.GetHeight();
1224 wxBitmap bmpSource
= bmp
; // we need a non-const instance
1225 unsigned char* buffer
= new unsigned char[bw
*bh
*4];
1226 wxUint32
* data
= (wxUint32
*)buffer
;
1228 // Create a surface object and copy the bitmap pixel data to it. if the
1229 // image has alpha (or a mask represented as alpha) then we'll use a
1230 // different format and iterator than if it doesn't...
1231 if (bmpSource
.HasAlpha() || bmpSource
.GetMask())
1233 surface
= cairo_image_surface_create_for_data(
1234 buffer
, CAIRO_FORMAT_ARGB32
, bw
, bh
, bw
*4);
1235 wxAlphaPixelData
pixData(bmpSource
, wxPoint(0,0), wxSize(bw
, bh
));
1236 wxCHECK_RET( pixData
, wxT("Failed to gain raw access to bitmap data."));
1238 wxAlphaPixelData
::Iterator
p(pixData
);
1239 for (int y
=0; y
<bh
; y
++)
1241 wxAlphaPixelData
::Iterator rowStart
= p
;
1242 for (int x
=0; x
<bw
; x
++)
1244 // Each pixel in CAIRO_FORMAT_ARGB32 is a 32-bit quantity,
1245 // with alpha in the upper 8 bits, then red, then green, then
1246 // blue. The 32-bit quantities are stored native-endian.
1247 // Pre-multiplied alpha is used.
1248 unsigned char alpha
= p
.Alpha();
1252 *data
= ( alpha
<< 24
1253 | (p
.Red() * alpha
/255) << 16
1254 | (p
.Green() * alpha
/255) << 8
1255 | (p
.Blue() * alpha
/255) );
1260 p
.OffsetY(pixData
, 1);
1265 surface
= cairo_image_surface_create_for_data(
1266 buffer
, CAIRO_FORMAT_RGB24
, bw
, bh
, bw
*4);
1267 wxNativePixelData
pixData(bmpSource
, wxPoint(0,0), wxSize(bw
, bh
));
1268 wxCHECK_RET( pixData
, wxT("Failed to gain raw access to bitmap data."));
1270 wxNativePixelData
::Iterator
p(pixData
);
1271 for (int y
=0; y
<bh
; y
++)
1273 wxNativePixelData
::Iterator rowStart
= p
;
1274 for (int x
=0; x
<bw
; x
++)
1276 // Each pixel in CAIRO_FORMAT_RGB24 is a 32-bit quantity, with
1277 // the upper 8 bits unused. Red, Green, and Blue are stored in
1278 // the remaining 24 bits in that order. The 32-bit quantities
1279 // are stored native-endian.
1280 *data
= ( p
.Red() << 16 | p
.Green() << 8 | p
.Blue() );
1285 p
.OffsetY(pixData
, 1);
1292 // In case we're scaling the image by using a width and height different
1293 // than the bitmap's size create a pattern transformation on the surface and
1294 // draw the transformed pattern.
1295 cairo_pattern_t
* pattern
= cairo_pattern_create_for_surface(surface
);
1296 wxDouble scaleX
= w
/ bw
;
1297 wxDouble scaleY
= h
/ bh
;
1298 cairo_scale(m_context
, scaleX
, scaleY
);
1300 // prepare to draw the image
1301 cairo_translate(m_context
, x
, y
);
1302 cairo_set_source(m_context
, pattern
);
1303 // use the original size here since the context is scaled already...
1304 cairo_rectangle(m_context
, 0, 0, bw
, bh
);
1305 // fill the rectangle using the pattern
1306 cairo_fill(m_context
);
1309 cairo_pattern_destroy(pattern
);
1310 cairo_surface_destroy(surface
);
1315 void wxCairoContext
::DrawIcon( const wxIcon
&icon
, wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
)
1317 // An icon is a bitmap on wxGTK, so do this the easy way. When we want to
1318 // start using the Cairo backend on other platforms then we may need to
1319 // fiddle with this...
1320 DrawBitmap(icon
, x
, y
, w
, h
);
1324 void wxCairoContext
::DrawText( const wxString
&str
, wxDouble x
, wxDouble y
)
1326 if ( m_font
.IsNull() || str
.empty())
1330 const wxCharBuffer data
= wxConvUTF8
.cWC2MB( str
);
1333 size_t datalen
= strlen(data
);
1334 ((wxCairoFontData
*)m_font
.GetRefData())->Apply(this);
1336 PangoLayout
*layout
= pango_cairo_create_layout (m_context
);
1337 pango_layout_set_font_description( layout
, ((wxCairoFontData
*)m_font
.GetRefData())->GetFont());
1338 pango_layout_set_text(layout
, data
, datalen
);
1339 cairo_move_to(m_context
, x
, y
);
1340 pango_cairo_show_layout (m_context
, layout
);
1342 g_object_unref (layout
);
1344 ((wxCairoFontData
*)m_font
.GetRefData())->Apply(this);
1345 // Cairo's x,y for drawing text is at the baseline, so we need to adjust
1346 // the position we move to by the ascent.
1347 cairo_font_extents_t fe
;
1348 cairo_font_extents(m_context
, &fe
);
1349 cairo_move_to(m_context
, x
, y
+fe
.ascent
);
1351 const wxWX2MBbuf
buf(str
.mb_str(wxConvUTF8
));
1352 cairo_show_text(m_context
,buf
);
1356 void wxCairoContext
::GetTextExtent( const wxString
&str
, wxDouble
*width
, wxDouble
*height
,
1357 wxDouble
*descent
, wxDouble
*externalLeading
) const
1365 if ( externalLeading
)
1366 *externalLeading
= 0;
1368 if ( m_font
.IsNull() || str
.empty())
1374 PangoLayout
*layout
= pango_cairo_create_layout (m_context
);
1375 pango_layout_set_font_description( layout
, ((wxCairoFontData
*)m_font
.GetRefData())->GetFont());
1376 const wxCharBuffer data
= wxConvUTF8
.cWC2MB( str
);
1381 pango_layout_set_text( layout
, data
, strlen(data
) );
1382 pango_layout_get_pixel_size (layout
, &w
, &h
);
1389 PangoLayoutIter
*iter
= pango_layout_get_iter(layout
);
1390 int baseline
= pango_layout_iter_get_baseline(iter
);
1391 pango_layout_iter_free(iter
);
1392 *descent
= h
- PANGO_PIXELS(baseline
);
1394 g_object_unref (layout
);
1396 ((wxCairoFontData
*)m_font
.GetRefData())->Apply((wxCairoContext
*)this);
1400 const wxWX2MBbuf
buf(str
.mb_str(wxConvUTF8
));
1401 cairo_text_extents_t te
;
1402 cairo_text_extents(m_context
, buf
, &te
);
1406 if (height
|| descent
|| externalLeading
)
1408 cairo_font_extents_t fe
;
1409 cairo_font_extents(m_context
, &fe
);
1412 *height
= fe
.height
;
1414 *descent
= fe
.descent
;
1415 if ( externalLeading
)
1416 *externalLeading
= wxMax(0, fe
.height
- (fe
.ascent
+ fe
.descent
));
1421 void wxCairoContext
::GetPartialTextExtents(const wxString
& text
, wxArrayDouble
& widths
) const
1424 widths
.Add(0, text
.length());
1432 void * wxCairoContext
::GetNativeContext()
1437 //-----------------------------------------------------------------------------
1438 // wxCairoRenderer declaration
1439 //-----------------------------------------------------------------------------
1441 class WXDLLIMPEXP_CORE wxCairoRenderer
: public wxGraphicsRenderer
1444 wxCairoRenderer() {}
1446 virtual ~wxCairoRenderer() {}
1450 virtual wxGraphicsContext
* CreateContext( const wxWindowDC
& dc
);
1453 virtual wxGraphicsContext
* CreateContext( const wxMemoryDC
& dc
);
1456 virtual wxGraphicsContext
* CreateContextFromNativeContext( void * context
);
1458 virtual wxGraphicsContext
* CreateContextFromNativeWindow( void * window
);
1460 virtual wxGraphicsContext
* CreateContext( wxWindow
* window
);
1462 virtual wxGraphicsContext
* CreateMeasuringContext();
1466 virtual wxGraphicsPath
CreatePath();
1470 virtual wxGraphicsMatrix
CreateMatrix( wxDouble a
=1.0, wxDouble b
=0.0, wxDouble c
=0.0, wxDouble d
=1.0,
1471 wxDouble tx
=0.0, wxDouble ty
=0.0);
1474 virtual wxGraphicsPen
CreatePen(const wxPen
& pen
) ;
1476 virtual wxGraphicsBrush
CreateBrush(const wxBrush
& brush
) ;
1478 // sets the brush to a linear gradient, starting at (x1,y1) with color c1 to (x2,y2) with color c2
1479 virtual wxGraphicsBrush
CreateLinearGradientBrush( wxDouble x1
, wxDouble y1
, wxDouble x2
, wxDouble y2
,
1480 const wxColour
&c1
, const wxColour
&c2
) ;
1482 // sets the brush to a radial gradient originating at (xo,yc) with color oColor and ends on a circle around (xc,yc)
1483 // with radius r and color cColor
1484 virtual wxGraphicsBrush
CreateRadialGradientBrush( wxDouble xo
, wxDouble yo
, wxDouble xc
, wxDouble yc
, wxDouble radius
,
1485 const wxColour
&oColor
, const wxColour
&cColor
) ;
1488 virtual wxGraphicsFont
CreateFont( const wxFont
&font
, const wxColour
&col
= *wxBLACK
) ;
1491 DECLARE_DYNAMIC_CLASS_NO_COPY(wxCairoRenderer
)
1494 //-----------------------------------------------------------------------------
1495 // wxCairoRenderer implementation
1496 //-----------------------------------------------------------------------------
1498 IMPLEMENT_DYNAMIC_CLASS(wxCairoRenderer
,wxGraphicsRenderer
)
1500 static wxCairoRenderer gs_cairoGraphicsRenderer
;
1503 wxGraphicsRenderer
* wxGraphicsRenderer
::GetDefaultRenderer()
1505 return &gs_cairoGraphicsRenderer
;
1509 wxGraphicsContext
* wxCairoRenderer
::CreateContext( const wxWindowDC
& dc
)
1511 return new wxCairoContext(this,dc
);
1515 wxGraphicsContext
* wxCairoRenderer
::CreateContext( const wxMemoryDC
& dc
)
1521 wxGraphicsContext
* wxCairoRenderer
::CreateContextFromNativeContext( void * context
)
1523 return new wxCairoContext(this,(cairo_t
*)context
);
1527 wxGraphicsContext
* wxCairoRenderer
::CreateContextFromNativeWindow( void * window
)
1530 return new wxCairoContext(this,(GdkDrawable
*)window
);
1536 wxGraphicsContext
* wxCairoRenderer
::CreateMeasuringContext()
1542 wxGraphicsContext
* wxCairoRenderer
::CreateContext( wxWindow
* window
)
1544 return new wxCairoContext(this, window
);
1549 wxGraphicsPath wxCairoRenderer
::CreatePath()
1551 wxGraphicsPath path
;
1552 path
.SetRefData( new wxCairoPathData(this) );
1559 wxGraphicsMatrix wxCairoRenderer
::CreateMatrix( wxDouble a
, wxDouble b
, wxDouble c
, wxDouble d
,
1560 wxDouble tx
, wxDouble ty
)
1564 wxCairoMatrixData
* data
= new wxCairoMatrixData( this );
1565 data
->Set( a
,b
,c
,d
,tx
,ty
) ;
1570 wxGraphicsPen wxCairoRenderer
::CreatePen(const wxPen
& pen
)
1572 if ( !pen
.Ok() || pen
.GetStyle() == wxTRANSPARENT
)
1573 return wxNullGraphicsPen
;
1577 p
.SetRefData(new wxCairoPenData( this, pen
));
1582 wxGraphicsBrush wxCairoRenderer
::CreateBrush(const wxBrush
& brush
)
1584 if ( !brush
.Ok() || brush
.GetStyle() == wxTRANSPARENT
)
1585 return wxNullGraphicsBrush
;
1589 p
.SetRefData(new wxCairoBrushData( this, brush
));
1594 // sets the brush to a linear gradient, starting at (x1,y1) with color c1 to (x2,y2) with color c2
1595 wxGraphicsBrush wxCairoRenderer
::CreateLinearGradientBrush( wxDouble x1
, wxDouble y1
, wxDouble x2
, wxDouble y2
,
1596 const wxColour
&c1
, const wxColour
&c2
)
1599 wxCairoBrushData
* d
= new wxCairoBrushData( this );
1600 d
->CreateLinearGradientBrush(x1
, y1
, x2
, y2
, c1
, c2
);
1605 // sets the brush to a radial gradient originating at (xo,yc) with color oColor and ends on a circle around (xc,yc)
1606 // with radius r and color cColor
1607 wxGraphicsBrush wxCairoRenderer
::CreateRadialGradientBrush( wxDouble xo
, wxDouble yo
, wxDouble xc
, wxDouble yc
, wxDouble radius
,
1608 const wxColour
&oColor
, const wxColour
&cColor
)
1611 wxCairoBrushData
* d
= new wxCairoBrushData( this );
1612 d
->CreateRadialGradientBrush(xo
,yo
,xc
,yc
,radius
,oColor
,cColor
);
1618 wxGraphicsFont wxCairoRenderer
::CreateFont( const wxFont
&font
, const wxColour
&col
)
1623 p
.SetRefData(new wxCairoFontData( this , font
, col
));
1627 return wxNullGraphicsFont
;
1630 #endif // wxUSE_GRAPHICS_CONTEXT