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
20 #include "wx/graphics.h"
24 // keep cairo.h from defining dllimport as we're defining the symbols inside
25 // the wx dll in order to load them dynamically.
31 #include "wx/bitmap.h"
33 #include "wx/dcclient.h"
34 #include "wx/dcmemory.h"
35 #include "wx/dcprint.h"
37 #include "wx/window.h"
41 #include "wx/private/graphics.h"
42 #include "wx/rawbmp.h"
43 #include "wx/vector.h"
47 //-----------------------------------------------------------------------------
48 // device context implementation
50 // more and more of the dc functionality should be implemented by calling
51 // the appropricate wxCairoContext, but we will have to do that step by step
52 // also coordinate conversions should be moved to native matrix ops
53 //-----------------------------------------------------------------------------
55 // we always stock two context states, one at entry, to be able to preserve the
56 // state we were called with, the other one after changing to HI Graphics orientation
57 // (this one is used for getting back clippings etc)
59 //-----------------------------------------------------------------------------
60 // wxGraphicsPath implementation
61 //-----------------------------------------------------------------------------
63 // TODO remove this dependency (gdiplus needs the macros)
66 #define max(a,b) (((a) > (b)) ? (a) : (b))
70 #define min(a,b) (((a) < (b)) ? (a) : (b))
75 #include <cairo-win32.h>
80 #include "wx/fontutil.h"
81 #include "wx/gtk/dc.h"
85 #include <cairo-win32.h>
89 #include "wx/osx/private.h"
90 #include <cairo-quartz.h>
91 #include <cairo-atsui.h>
94 class WXDLLIMPEXP_CORE wxCairoPathData
: public wxGraphicsPathData
97 wxCairoPathData(wxGraphicsRenderer
* renderer
, cairo_t
* path
= NULL
);
100 virtual wxGraphicsObjectRefData
*Clone() const;
103 // These are the path primitives from which everything else can be constructed
106 // begins a new subpath at (x,y)
107 virtual void MoveToPoint( wxDouble x
, wxDouble y
);
109 // adds a straight line from the current point to (x,y)
110 virtual void AddLineToPoint( wxDouble x
, wxDouble y
);
112 // adds a cubic Bezier curve from the current point, using two control points and an end point
113 virtual void AddCurveToPoint( wxDouble cx1
, wxDouble cy1
, wxDouble cx2
, wxDouble cy2
, wxDouble x
, wxDouble y
);
116 // adds an arc of a circle centering at (x,y) with radius (r) from startAngle to endAngle
117 virtual void AddArc( wxDouble x
, wxDouble y
, wxDouble r
, wxDouble startAngle
, wxDouble endAngle
, bool clockwise
) ;
119 // gets the last point of the current path, (0,0) if not yet set
120 virtual void GetCurrentPoint( wxDouble
* x
, wxDouble
* y
) const;
123 virtual void AddPath( const wxGraphicsPathData
* path
);
125 // closes the current sub-path
126 virtual void CloseSubpath();
129 // These are convenience functions which - if not available natively will be assembled
130 // using the primitives from above
135 // appends a rectangle as a new closed subpath
136 virtual void AddRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h ) ;
137 // appends an ellipsis as a new closed subpath fitting the passed rectangle
138 virtual void AddEllipsis( wxDouble x, wxDouble y, wxDouble w , wxDouble h ) ;
140 // 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)
141 virtual void AddArcToPoint( wxDouble x1, wxDouble y1 , wxDouble x2, wxDouble y2, wxDouble r ) ;
144 // returns the native path
145 virtual void * GetNativePath() const ;
147 // give the native path returned by GetNativePath() back (there might be some deallocations necessary)
148 virtual void UnGetNativePath(void *p
) const;
150 // transforms each point of this path by the matrix
151 virtual void Transform( const wxGraphicsMatrixData
* matrix
) ;
153 // gets the bounding box enclosing all points (possibly including control points)
154 virtual void GetBox(wxDouble
*x
, wxDouble
*y
, wxDouble
*w
, wxDouble
*h
) const;
156 virtual bool Contains( wxDouble x
, wxDouble y
, wxPolygonFillMode fillStyle
= wxWINDING_RULE
) const;
159 cairo_t
* m_pathContext
;
162 class WXDLLIMPEXP_CORE wxCairoMatrixData
: public wxGraphicsMatrixData
165 wxCairoMatrixData(wxGraphicsRenderer
* renderer
, const cairo_matrix_t
* matrix
= NULL
) ;
166 virtual ~wxCairoMatrixData() ;
168 virtual wxGraphicsObjectRefData
*Clone() const ;
170 // concatenates the matrix
171 virtual void Concat( const wxGraphicsMatrixData
*t
);
173 // sets the matrix to the respective values
174 virtual void Set(wxDouble a
=1.0, wxDouble b
=0.0, wxDouble c
=0.0, wxDouble d
=1.0,
175 wxDouble tx
=0.0, wxDouble ty
=0.0);
177 // gets the component valuess of the matrix
178 virtual void Get(wxDouble
* a
=NULL
, wxDouble
* b
=NULL
, wxDouble
* c
=NULL
,
179 wxDouble
* d
=NULL
, wxDouble
* tx
=NULL
, wxDouble
* ty
=NULL
) const;
181 // makes this the inverse matrix
182 virtual void Invert();
184 // returns true if the elements of the transformation matrix are equal ?
185 virtual bool IsEqual( const wxGraphicsMatrixData
* t
) const ;
187 // return true if this is the identity matrix
188 virtual bool IsIdentity() const;
194 // add the translation to this matrix
195 virtual void Translate( wxDouble dx
, wxDouble dy
);
197 // add the scale to this matrix
198 virtual void Scale( wxDouble xScale
, wxDouble yScale
);
200 // add the rotation to this matrix (radians)
201 virtual void Rotate( wxDouble angle
);
204 // apply the transforms
207 // applies that matrix to the point
208 virtual void TransformPoint( wxDouble
*x
, wxDouble
*y
) const;
210 // applies the matrix except for translations
211 virtual void TransformDistance( wxDouble
*dx
, wxDouble
*dy
) const;
213 // returns the native representation
214 virtual void * GetNativeMatrix() const;
216 cairo_matrix_t m_matrix
;
219 class WXDLLIMPEXP_CORE wxCairoPenData
: public wxGraphicsObjectRefData
222 wxCairoPenData( wxGraphicsRenderer
* renderer
, const wxPen
&pen
);
227 virtual void Apply( wxGraphicsContext
* context
);
228 virtual wxDouble
GetWidth() { return m_width
; }
238 cairo_line_cap_t m_cap
;
239 cairo_line_join_t m_join
;
242 const double *m_lengths
;
243 double *m_userLengths
;
247 wxDECLARE_NO_COPY_CLASS(wxCairoPenData
);
250 class WXDLLIMPEXP_CORE wxCairoBrushData
: public wxGraphicsObjectRefData
253 wxCairoBrushData( wxGraphicsRenderer
* renderer
);
254 wxCairoBrushData( wxGraphicsRenderer
* renderer
, const wxBrush
&brush
);
255 ~wxCairoBrushData ();
257 virtual void Apply( wxGraphicsContext
* context
);
259 void CreateLinearGradientBrush(wxDouble x1
, wxDouble y1
,
260 wxDouble x2
, wxDouble y2
,
261 const wxGraphicsGradientStops
& stops
);
262 void CreateRadialGradientBrush(wxDouble xo
, wxDouble yo
,
263 wxDouble xc
, wxDouble yc
, wxDouble radius
,
264 const wxGraphicsGradientStops
& stops
);
269 // common part of Create{Linear,Radial}GradientBrush()
270 void AddGradientStops(const wxGraphicsGradientStops
& stops
);
278 cairo_pattern_t
* m_brushPattern
;
281 class wxCairoFontData
: public wxGraphicsObjectRefData
284 wxCairoFontData( wxGraphicsRenderer
* renderer
, const wxFont
&font
, const wxColour
& col
);
287 virtual void Apply( wxGraphicsContext
* context
);
289 const PangoFontDescription
* GetFont() const { return m_font
; }
290 bool GetUnderlined() const { return m_underlined
; }
300 cairo_font_face_t
*m_font
;
301 #elif defined(__WXGTK__)
302 PangoFontDescription
* m_font
;
304 wxCharBuffer m_fontName
;
305 cairo_font_slant_t m_slant
;
306 cairo_font_weight_t m_weight
;
310 class wxCairoBitmapData
: public wxGraphicsObjectRefData
313 wxCairoBitmapData( wxGraphicsRenderer
* renderer
, const wxBitmap
& bmp
);
314 wxCairoBitmapData( wxGraphicsRenderer
* renderer
, cairo_surface_t
* bitmap
);
315 ~wxCairoBitmapData();
317 virtual cairo_surface_t
* GetCairoSurface() { return m_surface
; }
318 virtual cairo_pattern_t
* GetCairoPattern() { return m_pattern
; }
319 virtual wxSize
GetSize() { return wxSize(m_width
, m_height
); }
321 // Allocate m_buffer for the bitmap of the given size in the given format.
323 // Returns the stride used for the buffer.
324 int InitBuffer(int width
, int height
, cairo_format_t format
);
326 // Really create the surface using the buffer (which was supposed to be
327 // filled since InitBuffer() call).
328 void InitSurface(cairo_format_t format
, int stride
);
331 cairo_surface_t
* m_surface
;
332 cairo_pattern_t
* m_pattern
;
335 unsigned char* m_buffer
;
338 class WXDLLIMPEXP_CORE wxCairoContext
: public wxGraphicsContext
341 wxCairoContext( wxGraphicsRenderer
* renderer
, const wxWindowDC
& dc
);
342 wxCairoContext( wxGraphicsRenderer
* renderer
, const wxMemoryDC
& dc
);
343 wxCairoContext( wxGraphicsRenderer
* renderer
, const wxPrinterDC
& dc
);
345 wxCairoContext( wxGraphicsRenderer
* renderer
, GdkDrawable
*drawable
);
348 wxCairoContext( wxGraphicsRenderer
* renderer
, HDC context
);
350 wxCairoContext( wxGraphicsRenderer
* renderer
, cairo_t
*context
);
351 wxCairoContext( wxGraphicsRenderer
* renderer
, wxWindow
*window
);
353 virtual ~wxCairoContext();
355 virtual bool ShouldOffset() const
357 if ( !m_enableOffset
)
361 if ( !m_pen
.IsNull() )
363 penwidth
= (int)((wxCairoPenData
*)m_pen
.GetRefData())->GetWidth();
367 return ( penwidth
% 2 ) == 1;
370 virtual void Clip( const wxRegion
®ion
);
372 cairo_surface_t
* m_mswSurface
;
375 // clips drawings to the rect
376 virtual void Clip( wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
);
378 // resets the clipping to original extent
379 virtual void ResetClip();
381 virtual void * GetNativeContext();
383 virtual bool SetAntialiasMode(wxAntialiasMode antialias
);
385 virtual bool SetInterpolationQuality(wxInterpolationQuality interpolation
);
387 virtual bool SetCompositionMode(wxCompositionMode op
);
389 virtual void BeginLayer(wxDouble opacity
);
391 virtual void EndLayer();
393 virtual void StrokePath( const wxGraphicsPath
& p
);
394 virtual void FillPath( const wxGraphicsPath
& p
, wxPolygonFillMode fillStyle
= wxWINDING_RULE
);
396 virtual void Translate( wxDouble dx
, wxDouble dy
);
397 virtual void Scale( wxDouble xScale
, wxDouble yScale
);
398 virtual void Rotate( wxDouble angle
);
400 // concatenates this transform with the current transform of this context
401 virtual void ConcatTransform( const wxGraphicsMatrix
& matrix
);
403 // sets the transform of this context
404 virtual void SetTransform( const wxGraphicsMatrix
& matrix
);
406 // gets the matrix of this context
407 virtual wxGraphicsMatrix
GetTransform() const;
409 virtual void DrawBitmap( const wxGraphicsBitmap
&bmp
, wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
);
410 virtual void DrawBitmap( const wxBitmap
&bmp
, wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
);
411 virtual void DrawIcon( const wxIcon
&icon
, wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
);
412 virtual void PushState();
413 virtual void PopState();
415 virtual void GetTextExtent( const wxString
&str
, wxDouble
*width
, wxDouble
*height
,
416 wxDouble
*descent
, wxDouble
*externalLeading
) const;
417 virtual void GetPartialTextExtents(const wxString
& text
, wxArrayDouble
& widths
) const;
420 virtual void DoDrawText( const wxString
&str
, wxDouble x
, wxDouble y
);
423 void Init(cairo_t
*context
);
427 wxVector
<float> m_layerOpacities
;
429 wxDECLARE_NO_COPY_CLASS(wxCairoContext
);
432 //-----------------------------------------------------------------------------
433 // wxCairoPenData implementation
434 //-----------------------------------------------------------------------------
436 wxCairoPenData
::~wxCairoPenData()
438 delete[] m_userLengths
;
441 void wxCairoPenData
::Init()
444 m_userLengths
= NULL
;
449 wxCairoPenData
::wxCairoPenData( wxGraphicsRenderer
* renderer
, const wxPen
&pen
)
450 : wxGraphicsObjectRefData(renderer
)
454 m_width
= m_pen
.GetWidth();
458 m_red
= m_pen
.GetColour().Red()/255.0;
459 m_green
= m_pen
.GetColour().Green()/255.0;
460 m_blue
= m_pen
.GetColour().Blue()/255.0;
461 m_alpha
= m_pen
.GetColour().Alpha()/255.0;
463 switch ( m_pen
.GetCap() )
466 m_cap
= CAIRO_LINE_CAP_ROUND
;
469 case wxCAP_PROJECTING
:
470 m_cap
= CAIRO_LINE_CAP_SQUARE
;
474 m_cap
= CAIRO_LINE_CAP_BUTT
;
478 m_cap
= CAIRO_LINE_CAP_BUTT
;
482 switch ( m_pen
.GetJoin() )
485 m_join
= CAIRO_LINE_JOIN_BEVEL
;
489 m_join
= CAIRO_LINE_JOIN_MITER
;
493 m_join
= CAIRO_LINE_JOIN_ROUND
;
497 m_join
= CAIRO_LINE_JOIN_MITER
;
501 const double dashUnit
= m_width
< 1.0 ?
1.0 : m_width
;
502 const double dotted
[] =
504 dashUnit
, dashUnit
+ 2.0
506 static const double short_dashed
[] =
510 static const double dashed
[] =
514 static const double dotted_dashed
[] =
516 9.0 , 6.0 , 3.0 , 3.0
519 switch ( m_pen
.GetStyle() )
521 case wxPENSTYLE_SOLID
:
524 case wxPENSTYLE_DOT
:
525 m_count
= WXSIZEOF(dotted
);
526 m_userLengths
= new double[ m_count
] ;
527 memcpy( m_userLengths
, dotted
, sizeof(dotted
) );
528 m_lengths
= m_userLengths
;
531 case wxPENSTYLE_LONG_DASH
:
533 m_count
= WXSIZEOF(dashed
);
536 case wxPENSTYLE_SHORT_DASH
:
537 m_lengths
= short_dashed
;
538 m_count
= WXSIZEOF(short_dashed
);
541 case wxPENSTYLE_DOT_DASH
:
542 m_lengths
= dotted_dashed
;
543 m_count
= WXSIZEOF(dotted_dashed
);
546 case wxPENSTYLE_USER_DASH
:
549 m_count
= m_pen
.GetDashes( &wxdashes
) ;
550 if ((wxdashes
!= NULL
) && (m_count
> 0))
552 m_userLengths
= new double[m_count
] ;
553 for ( int i
= 0 ; i
< m_count
; ++i
)
555 m_userLengths
[i
] = wxdashes
[i
] * dashUnit
;
557 if ( i
% 2 == 1 && m_userLengths
[i
] < dashUnit
+ 2.0 )
558 m_userLengths
[i
] = dashUnit
+ 2.0 ;
559 else if ( i
% 2 == 0 && m_userLengths
[i
] < dashUnit
)
560 m_userLengths
[i
] = dashUnit
;
563 m_lengths
= m_userLengths
;
566 case wxPENSTYLE_STIPPLE
:
569 wxBitmap* bmp = pen.GetStipple();
570 if ( bmp && bmp->IsOk() )
572 wxDELETE( m_penImage );
573 wxDELETE( m_penBrush );
574 m_penImage = Bitmap::FromHBITMAP((HBITMAP)bmp->GetHBITMAP(),(HPALETTE)bmp->GetPalette()->GetHPALETTE());
575 m_penBrush = new TextureBrush(m_penImage);
576 m_pen->SetBrush( m_penBrush );
582 if ( m_pen
.GetStyle() >= wxPENSTYLE_FIRST_HATCH
583 && m_pen
.GetStyle() <= wxPENSTYLE_LAST_HATCH
)
586 wxDELETE( m_penBrush );
587 HatchStyle style = HatchStyleHorizontal;
588 switch( pen.GetStyle() )
590 case wxPENSTYLE_BDIAGONAL_HATCH :
591 style = HatchStyleBackwardDiagonal;
593 case wxPENSTYLE_CROSSDIAG_HATCH :
594 style = HatchStyleDiagonalCross;
596 case wxPENSTYLE_FDIAGONAL_HATCH :
597 style = HatchStyleForwardDiagonal;
599 case wxPENSTYLE_CROSS_HATCH :
600 style = HatchStyleCross;
602 case wxPENSTYLE_HORIZONTAL_HATCH :
603 style = HatchStyleHorizontal;
605 case wxPENSTYLE_VERTICAL_HATCH :
606 style = HatchStyleVertical;
610 m_penBrush = new HatchBrush(style,Color( pen.GetColour().Alpha() , pen.GetColour().Red() ,
611 pen.GetColour().Green() , pen.GetColour().Blue() ), Color.Transparent );
612 m_pen->SetBrush( m_penBrush )
619 void wxCairoPenData
::Apply( wxGraphicsContext
* context
)
621 cairo_t
* ctext
= (cairo_t
*) context
->GetNativeContext();
622 cairo_set_line_width(ctext
,m_width
);
623 cairo_set_source_rgba(ctext
,m_red
,m_green
, m_blue
,m_alpha
);
624 cairo_set_line_cap(ctext
,m_cap
);
625 cairo_set_line_join(ctext
,m_join
);
626 cairo_set_dash(ctext
,(double*)m_lengths
,m_count
,0.0);
629 //-----------------------------------------------------------------------------
630 // wxCairoBrushData implementation
631 //-----------------------------------------------------------------------------
633 wxCairoBrushData
::wxCairoBrushData( wxGraphicsRenderer
* renderer
)
634 : wxGraphicsObjectRefData( renderer
)
639 wxCairoBrushData
::wxCairoBrushData( wxGraphicsRenderer
* renderer
, const wxBrush
&brush
)
640 : wxGraphicsObjectRefData(renderer
)
644 m_red
= brush
.GetColour().Red()/255.0;
645 m_green
= brush
.GetColour().Green()/255.0;
646 m_blue
= brush
.GetColour().Blue()/255.0;
647 m_alpha
= brush
.GetColour().Alpha()/255.0;
649 if ( brush.GetStyle() == wxBRUSHSTYLE_SOLID)
651 m_brush = new SolidBrush( Color( brush.GetColour().Alpha() , brush.GetColour().Red() ,
652 brush.GetColour().Green() , brush.GetColour().Blue() ) );
654 else if ( brush.IsHatch() )
656 HatchStyle style = HatchStyleHorizontal;
657 switch( brush.GetStyle() )
659 case wxBRUSHSTYLE_BDIAGONAL_HATCH :
660 style = HatchStyleBackwardDiagonal;
662 case wxBRUSHSTYLE_CROSSDIAG_HATCH :
663 style = HatchStyleDiagonalCross;
665 case wxBRUSHSTYLE_FDIAGONAL_HATCH :
666 style = HatchStyleForwardDiagonal;
668 case wxBRUSHSTYLE_CROSS_HATCH :
669 style = HatchStyleCross;
671 case wxBRUSHSTYLE_HORIZONTAL_HATCH :
672 style = HatchStyleHorizontal;
674 case wxBRUSHSTYLE_VERTICAL_HATCH :
675 style = HatchStyleVertical;
679 m_brush = new HatchBrush(style,Color( brush.GetColour().Alpha() , brush.GetColour().Red() ,
680 brush.GetColour().Green() , brush.GetColour().Blue() ), Color.Transparent );
684 wxBitmap* bmp = brush.GetStipple();
685 if ( bmp && bmp->IsOk() )
687 wxDELETE( m_brushImage );
688 m_brushImage = Bitmap::FromHBITMAP((HBITMAP)bmp->GetHBITMAP(),(HPALETTE)bmp->GetPalette()->GetHPALETTE());
689 m_brush = new TextureBrush(m_brushImage);
695 wxCairoBrushData
::~wxCairoBrushData ()
698 cairo_pattern_destroy(m_brushPattern
);
701 void wxCairoBrushData
::Apply( wxGraphicsContext
* context
)
703 cairo_t
* ctext
= (cairo_t
*) context
->GetNativeContext();
704 if ( m_brushPattern
)
706 cairo_set_source(ctext
,m_brushPattern
);
710 cairo_set_source_rgba(ctext
,m_red
,m_green
, m_blue
,m_alpha
);
714 void wxCairoBrushData
::AddGradientStops(const wxGraphicsGradientStops
& stops
)
716 // loop over all the stops, they include the beginning and ending ones
717 const unsigned numStops
= stops
.GetCount();
718 for ( unsigned n
= 0; n
< numStops
; n
++ )
720 const wxGraphicsGradientStop stop
= stops
.Item(n
);
722 const wxColour col
= stop
.GetColour();
724 cairo_pattern_add_color_stop_rgba
735 wxASSERT_MSG(cairo_pattern_status(m_brushPattern
) == CAIRO_STATUS_SUCCESS
,
736 wxT("Couldn't create cairo pattern"));
740 wxCairoBrushData
::CreateLinearGradientBrush(wxDouble x1
, wxDouble y1
,
741 wxDouble x2
, wxDouble y2
,
742 const wxGraphicsGradientStops
& stops
)
744 m_brushPattern
= cairo_pattern_create_linear(x1
,y1
,x2
,y2
);
746 AddGradientStops(stops
);
750 wxCairoBrushData
::CreateRadialGradientBrush(wxDouble xo
, wxDouble yo
,
751 wxDouble xc
, wxDouble yc
,
753 const wxGraphicsGradientStops
& stops
)
755 m_brushPattern
= cairo_pattern_create_radial(xo
,yo
,0.0,xc
,yc
,radius
);
757 AddGradientStops(stops
);
760 void wxCairoBrushData
::Init()
762 m_brushPattern
= NULL
;
765 //-----------------------------------------------------------------------------
766 // wxCairoFontData implementation
767 //-----------------------------------------------------------------------------
769 wxCairoFontData
::wxCairoFontData( wxGraphicsRenderer
* renderer
, const wxFont
&font
,
770 const wxColour
& col
) : wxGraphicsObjectRefData(renderer
)
772 m_red
= col
.Red()/255.0;
773 m_green
= col
.Green()/255.0;
774 m_blue
= col
.Blue()/255.0;
775 m_alpha
= col
.Alpha()/255.0;
776 m_size
= font
.GetPointSize();
777 m_underlined
= font
.GetUnderlined();
780 m_font
= cairo_quartz_font_face_create_for_cgfont( font
.OSXGetCGFont() );
781 #elif defined(__WXGTK__)
782 m_font
= pango_font_description_copy( font
.GetNativeFontInfo()->description
);
784 m_fontName
= font
.GetFaceName().mb_str(wxConvUTF8
);
785 m_slant
= font
.GetStyle() == wxFONTSTYLE_ITALIC ? CAIRO_FONT_SLANT_ITALIC
:CAIRO_FONT_SLANT_NORMAL
;
786 m_weight
= font
.GetWeight() == wxFONTWEIGHT_BOLD ? CAIRO_FONT_WEIGHT_BOLD
:CAIRO_FONT_WEIGHT_NORMAL
;
790 wxCairoFontData
::~wxCairoFontData()
793 cairo_font_face_destroy( m_font
);
794 #elif defined(__WXGTK__)
795 pango_font_description_free( m_font
);
800 void wxCairoFontData
::Apply( wxGraphicsContext
* context
)
802 cairo_t
* ctext
= (cairo_t
*) context
->GetNativeContext();
803 cairo_set_source_rgba(ctext
,m_red
,m_green
, m_blue
,m_alpha
);
805 // the rest is done using Pango layouts
806 #elif defined(__WXMAC__)
807 cairo_set_font_face(ctext
, m_font
);
808 cairo_set_font_size(ctext
, m_size
);
810 cairo_select_font_face(ctext
, m_fontName
, m_slant
, m_weight
);
811 cairo_set_font_size(ctext
, m_size
);
815 //-----------------------------------------------------------------------------
816 // wxCairoPathData implementation
817 //-----------------------------------------------------------------------------
819 wxCairoPathData
::wxCairoPathData( wxGraphicsRenderer
* renderer
, cairo_t
* pathcontext
)
820 : wxGraphicsPathData(renderer
)
824 m_pathContext
= pathcontext
;
828 cairo_surface_t
* surface
= cairo_image_surface_create(CAIRO_FORMAT_ARGB32
,1,1);
829 m_pathContext
= cairo_create(surface
);
830 cairo_surface_destroy (surface
);
834 wxCairoPathData
::~wxCairoPathData()
836 cairo_destroy(m_pathContext
);
839 wxGraphicsObjectRefData
*wxCairoPathData
::Clone() const
841 cairo_surface_t
* surface
= cairo_image_surface_create(CAIRO_FORMAT_ARGB32
,1,1);
842 cairo_t
* pathcontext
= cairo_create(surface
);
843 cairo_surface_destroy (surface
);
845 cairo_path_t
* path
= cairo_copy_path(m_pathContext
);
846 cairo_append_path(pathcontext
, path
);
847 cairo_path_destroy(path
);
848 return new wxCairoPathData( GetRenderer() ,pathcontext
);
852 void* wxCairoPathData
::GetNativePath() const
854 return cairo_copy_path(m_pathContext
) ;
857 void wxCairoPathData
::UnGetNativePath(void *p
) const
859 cairo_path_destroy((cairo_path_t
*)p
);
866 void wxCairoPathData
::MoveToPoint( wxDouble x
, wxDouble y
)
868 cairo_move_to(m_pathContext
,x
,y
);
871 void wxCairoPathData
::AddLineToPoint( wxDouble x
, wxDouble y
)
873 cairo_line_to(m_pathContext
,x
,y
);
876 void wxCairoPathData
::AddPath( const wxGraphicsPathData
* path
)
878 cairo_path_t
* p
= (cairo_path_t
*)path
->GetNativePath();
879 cairo_append_path(m_pathContext
, p
);
883 void wxCairoPathData
::CloseSubpath()
885 cairo_close_path(m_pathContext
);
888 void wxCairoPathData
::AddCurveToPoint( wxDouble cx1
, wxDouble cy1
, wxDouble cx2
, wxDouble cy2
, wxDouble x
, wxDouble y
)
890 cairo_curve_to(m_pathContext
,cx1
,cy1
,cx2
,cy2
,x
,y
);
893 // gets the last point of the current path, (0,0) if not yet set
894 void wxCairoPathData
::GetCurrentPoint( wxDouble
* x
, wxDouble
* y
) const
897 cairo_get_current_point(m_pathContext
,&dx
,&dy
);
904 void wxCairoPathData
::AddArc( wxDouble x
, wxDouble y
, wxDouble r
, double startAngle
, double endAngle
, bool clockwise
)
906 // as clockwise means positive in our system (y pointing downwards)
907 // TODO make this interpretation dependent of the
909 if ( clockwise
||(endAngle
-startAngle
)>=2*M_PI
)
910 cairo_arc(m_pathContext
,x
,y
,r
,startAngle
,endAngle
);
912 cairo_arc_negative(m_pathContext
,x
,y
,r
,startAngle
,endAngle
);
915 // transforms each point of this path by the matrix
916 void wxCairoPathData
::Transform( const wxGraphicsMatrixData
* matrix
)
918 // as we don't have a true path object, we have to apply the inverse
919 // matrix to the context
920 cairo_matrix_t m
= *((cairo_matrix_t
*) matrix
->GetNativeMatrix());
921 cairo_matrix_invert( &m
);
922 cairo_transform(m_pathContext
,&m
);
925 // gets the bounding box enclosing all points (possibly including control points)
926 void wxCairoPathData
::GetBox(wxDouble
*x
, wxDouble
*y
, wxDouble
*w
, wxDouble
*h
) const
930 cairo_stroke_extents( m_pathContext
, &x1
, &y1
, &x2
, &y2
);
954 bool wxCairoPathData
::Contains( wxDouble x
, wxDouble y
, wxPolygonFillMode fillStyle
) const
956 cairo_set_fill_rule(m_pathContext
,fillStyle
==wxODDEVEN_RULE ? CAIRO_FILL_RULE_EVEN_ODD
: CAIRO_FILL_RULE_WINDING
);
957 return cairo_in_fill( m_pathContext
, x
, y
) != 0;
960 //-----------------------------------------------------------------------------
961 // wxCairoMatrixData implementation
962 //-----------------------------------------------------------------------------
964 wxCairoMatrixData
::wxCairoMatrixData(wxGraphicsRenderer
* renderer
, const cairo_matrix_t
* matrix
)
965 : wxGraphicsMatrixData(renderer
)
971 wxCairoMatrixData
::~wxCairoMatrixData()
976 wxGraphicsObjectRefData
*wxCairoMatrixData
::Clone() const
978 return new wxCairoMatrixData(GetRenderer(),&m_matrix
);
981 // concatenates the matrix
982 void wxCairoMatrixData
::Concat( const wxGraphicsMatrixData
*t
)
984 cairo_matrix_multiply( &m_matrix
, &m_matrix
, (cairo_matrix_t
*) t
->GetNativeMatrix());
987 // sets the matrix to the respective values
988 void wxCairoMatrixData
::Set(wxDouble a
, wxDouble b
, wxDouble c
, wxDouble d
,
989 wxDouble tx
, wxDouble ty
)
991 cairo_matrix_init( &m_matrix
, a
, b
, c
, d
, tx
, ty
);
994 // gets the component valuess of the matrix
995 void wxCairoMatrixData
::Get(wxDouble
* a
, wxDouble
* b
, wxDouble
* c
,
996 wxDouble
* d
, wxDouble
* tx
, wxDouble
* ty
) const
998 if (a
) *a
= m_matrix
.xx
;
999 if (b
) *b
= m_matrix
.yx
;
1000 if (c
) *c
= m_matrix
.xy
;
1001 if (d
) *d
= m_matrix
.yy
;
1002 if (tx
) *tx
= m_matrix
.x0
;
1003 if (ty
) *ty
= m_matrix
.y0
;
1006 // makes this the inverse matrix
1007 void wxCairoMatrixData
::Invert()
1009 cairo_matrix_invert( &m_matrix
);
1012 // returns true if the elements of the transformation matrix are equal ?
1013 bool wxCairoMatrixData
::IsEqual( const wxGraphicsMatrixData
* t
) const
1015 const cairo_matrix_t
* tm
= (cairo_matrix_t
*) t
->GetNativeMatrix();
1017 m_matrix
.xx
== tm
->xx
&&
1018 m_matrix
.yx
== tm
->yx
&&
1019 m_matrix
.xy
== tm
->xy
&&
1020 m_matrix
.yy
== tm
->yy
&&
1021 m_matrix
.x0
== tm
->x0
&&
1022 m_matrix
.y0
== tm
->y0
) ;
1025 // return true if this is the identity matrix
1026 bool wxCairoMatrixData
::IsIdentity() const
1028 return ( m_matrix
.xx
== 1 && m_matrix
.yy
== 1 &&
1029 m_matrix
.yx
== 0 && m_matrix
.xy
== 0 && m_matrix
.x0
== 0 && m_matrix
.y0
== 0);
1036 // add the translation to this matrix
1037 void wxCairoMatrixData
::Translate( wxDouble dx
, wxDouble dy
)
1039 cairo_matrix_translate( &m_matrix
, dx
, dy
) ;
1042 // add the scale to this matrix
1043 void wxCairoMatrixData
::Scale( wxDouble xScale
, wxDouble yScale
)
1045 cairo_matrix_scale( &m_matrix
, xScale
, yScale
) ;
1048 // add the rotation to this matrix (radians)
1049 void wxCairoMatrixData
::Rotate( wxDouble angle
)
1051 cairo_matrix_rotate( &m_matrix
, angle
) ;
1055 // apply the transforms
1058 // applies that matrix to the point
1059 void wxCairoMatrixData
::TransformPoint( wxDouble
*x
, wxDouble
*y
) const
1061 double lx
= *x
, ly
= *y
;
1062 cairo_matrix_transform_point( &m_matrix
, &lx
, &ly
);
1067 // applies the matrix except for translations
1068 void wxCairoMatrixData
::TransformDistance( wxDouble
*dx
, wxDouble
*dy
) const
1070 double lx
= *dx
, ly
= *dy
;
1071 cairo_matrix_transform_distance( &m_matrix
, &lx
, &ly
);
1076 // returns the native representation
1077 void * wxCairoMatrixData
::GetNativeMatrix() const
1079 return (void*) &m_matrix
;
1082 // ----------------------------------------------------------------------------
1083 // wxCairoBitmap implementation
1084 // ----------------------------------------------------------------------------
1086 int wxCairoBitmapData
::InitBuffer(int width
, int height
, cairo_format_t format
)
1088 wxUnusedVar(format
); // Only really unused with Cairo < 1.6.
1090 // Determine the stride: use cairo_format_stride_for_width() if available
1091 // but fall back to 4*width for the earlier versions as this is what that
1092 // function always returns, even in latest Cairo, anyhow.
1094 #if CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 6, 0)
1095 if ( cairo_version() >= CAIRO_VERSION_ENCODE(1, 6, 0) )
1097 stride
= cairo_format_stride_for_width(format
, width
);
1099 // All our code would totally break if stride were not a multiple of 4
1100 // so ensure this is the case.
1103 wxFAIL_MSG("Unexpected Cairo image surface stride.");
1105 stride
+= 4 - stride
% 4;
1114 m_buffer
= new unsigned char[height
*stride
];
1119 void wxCairoBitmapData
::InitSurface(cairo_format_t format
, int stride
)
1121 m_surface
= cairo_image_surface_create_for_data(
1122 m_buffer
, format
, m_width
, m_height
, stride
);
1123 m_pattern
= cairo_pattern_create_for_surface(m_surface
);
1126 wxCairoBitmapData
::wxCairoBitmapData( wxGraphicsRenderer
* renderer
, cairo_surface_t
* bitmap
) :
1127 wxGraphicsObjectRefData( renderer
)
1130 m_pattern
= cairo_pattern_create_for_surface(m_surface
);
1133 wxCairoBitmapData
::wxCairoBitmapData( wxGraphicsRenderer
* renderer
, const wxBitmap
& bmp
) : wxGraphicsObjectRefData( renderer
)
1135 wxCHECK_RET( bmp
.IsOk(), wxT("Invalid bitmap in wxCairoContext::DrawBitmap"));
1137 #ifdef wxHAS_RAW_BITMAP
1138 // Create a surface object and copy the bitmap pixel data to it. if the
1139 // image has alpha (or a mask represented as alpha) then we'll use a
1140 // different format and iterator than if it doesn't...
1141 const cairo_format_t bufferFormat
= bmp
.GetDepth() == 32
1145 ? CAIRO_FORMAT_ARGB32
1146 : CAIRO_FORMAT_RGB24
;
1148 int stride
= InitBuffer(bmp
.GetWidth(), bmp
.GetHeight(), bufferFormat
);
1152 wxBitmap bmpSource
= bmp
; // we need a non-const instance
1153 wxUint32
* data
= (wxUint32
*)m_buffer
;
1155 if ( bufferFormat
== CAIRO_FORMAT_ARGB32
)
1157 // use the bitmap's alpha
1158 wxAlphaPixelData
pixData(bmpSource
, wxPoint(0,0), wxSize(bw
, bh
));
1159 wxCHECK_RET( pixData
, wxT("Failed to gain raw access to bitmap data."));
1161 wxAlphaPixelData
::Iterator
p(pixData
);
1162 for (int y
=0; y
<bh
; y
++)
1164 wxAlphaPixelData
::Iterator rowStart
= p
;
1165 wxUint32
* const rowStartDst
= data
;
1166 for (int x
=0; x
<bw
; x
++)
1168 // Each pixel in CAIRO_FORMAT_ARGB32 is a 32-bit quantity,
1169 // with alpha in the upper 8 bits, then red, then green, then
1170 // blue. The 32-bit quantities are stored native-endian.
1171 // Pre-multiplied alpha is used.
1172 unsigned char alpha
= p
.Alpha();
1176 *data
= ( alpha
<< 24
1177 | (p
.Red() * alpha
/255) << 16
1178 | (p
.Green() * alpha
/255) << 8
1179 | (p
.Blue() * alpha
/255) );
1184 data
= rowStartDst
+ stride
/ 4;
1186 p
.OffsetY(pixData
, 1);
1191 wxNativePixelData
pixData(bmpSource
, wxPoint(0,0), wxSize(bw
, bh
));
1192 wxCHECK_RET( pixData
, wxT("Failed to gain raw access to bitmap data."));
1194 wxNativePixelData
::Iterator
p(pixData
);
1195 for (int y
=0; y
<bh
; y
++)
1197 wxNativePixelData
::Iterator rowStart
= p
;
1198 wxUint32
* const rowStartDst
= data
;
1199 for (int x
=0; x
<bw
; x
++)
1201 // Each pixel in CAIRO_FORMAT_RGB24 is a 32-bit quantity, with
1202 // the upper 8 bits unused. Red, Green, and Blue are stored in
1203 // the remaining 24 bits in that order. The 32-bit quantities
1204 // are stored native-endian.
1205 *data
= ( p
.Red() << 16 | p
.Green() << 8 | p
.Blue() );
1210 data
= rowStartDst
+ stride
/ 4;
1212 p
.OffsetY(pixData
, 1);
1216 // if there is a mask, set the alpha bytes in the target buffer to
1217 // fully transparent or fully opaque
1218 if (bmpSource
.GetMask())
1220 wxBitmap bmpMask
= bmpSource
.GetMaskBitmap();
1221 bufferFormat
= CAIRO_FORMAT_ARGB32
;
1222 data
= (wxUint32
*)m_buffer
;
1223 wxNativePixelData
pixData(bmpMask
, wxPoint(0,0), wxSize(bw
, bh
));
1224 wxCHECK_RET( pixData
, wxT("Failed to gain raw access to mask bitmap data."));
1226 wxNativePixelData
::Iterator
p(pixData
);
1227 for (int y
=0; y
<bh
; y
++)
1229 wxNativePixelData
::Iterator rowStart
= p
;
1230 wxUint32
* const rowStartDst
= data
;
1231 for (int x
=0; x
<bw
; x
++)
1233 if (p
.Red()+p
.Green()+p
.Blue() == 0)
1236 *data
= (wxALPHA_OPAQUE
<< 24) | (*data
& 0x00FFFFFF);
1241 data
= rowStartDst
+ stride
/ 4;
1243 p
.OffsetY(pixData
, 1);
1248 InitSurface(bufferFormat
, stride
);
1249 #endif // wxHAS_RAW_BITMAP
1252 wxCairoBitmapData
::~wxCairoBitmapData()
1255 cairo_pattern_destroy(m_pattern
);
1258 cairo_surface_destroy(m_surface
);
1265 //-----------------------------------------------------------------------------
1266 // wxCairoContext implementation
1267 //-----------------------------------------------------------------------------
1269 class wxCairoOffsetHelper
1272 wxCairoOffsetHelper( cairo_t
* ctx
, bool offset
)
1277 cairo_translate( m_ctx
, 0.5, 0.5 );
1279 ~wxCairoOffsetHelper( )
1282 cairo_translate( m_ctx
, -0.5, -0.5 );
1289 wxCairoContext
::wxCairoContext( wxGraphicsRenderer
* renderer
, const wxPrinterDC
& dc
)
1290 : wxGraphicsContext(renderer
)
1293 // wxMSW contexts always use MM_ANISOTROPIC, which messes up
1294 // text rendering when printing using Cairo. Switch it to MM_TEXT
1295 // map mode to avoid this problem.
1296 HDC hdc
= (HDC
)dc
.GetHDC();
1297 ::SetMapMode(hdc
, MM_TEXT
);
1298 m_mswSurface
= cairo_win32_printing_surface_create(hdc
);
1299 Init( cairo_create(m_mswSurface
) );
1303 const wxDCImpl
*impl
= dc
.GetImpl();
1304 Init( (cairo_t
*) impl
->GetCairoContext() );
1306 wxSize sz
= dc
.GetSize();
1310 wxPoint org
= dc
.GetDeviceOrigin();
1311 cairo_translate( m_context
, org
.x
, org
.y
);
1314 dc
.GetUserScale( &sx
, &sy
);
1316 // TODO: Determine if these fixes are needed on other platforms too.
1317 // On MSW, without this the printer context will not respect wxDC SetMapMode calls.
1318 // For example, using dc.SetMapMode(wxMM_POINTS) can let us share printer and screen
1322 dc
.GetLogicalScale( &lsx
, &lsy
);
1326 cairo_scale( m_context
, sx
, sy
);
1328 org
= dc
.GetLogicalOrigin();
1329 cairo_translate( m_context
, -org
.x
, -org
.y
);
1332 wxCairoContext
::wxCairoContext( wxGraphicsRenderer
* renderer
, const wxWindowDC
& dc
)
1333 : wxGraphicsContext(renderer
)
1336 dc
.GetSize( &width
, &height
);
1340 m_enableOffset
= true;
1343 m_mswSurface
= cairo_win32_surface_create((HDC
)dc
.GetHDC());
1344 Init( cairo_create(m_mswSurface
) );
1348 wxGTKDCImpl
*impldc
= (wxGTKDCImpl
*) dc
.GetImpl();
1349 Init( gdk_cairo_create( impldc
->GetGDKWindow() ) );
1352 wxGraphicsMatrix matrix
= CreateMatrix();
1354 wxPoint org
= dc
.GetDeviceOrigin();
1355 matrix
.Translate( org
.x
, org
.y
);
1357 org
= dc
.GetLogicalOrigin();
1358 matrix
.Translate( -org
.x
, -org
.y
);
1361 dc
.GetUserScale( &sx
, &sy
);
1362 matrix
.Scale( sx
, sy
);
1364 ConcatTransform( matrix
);
1369 CGContextRef cgcontext
= (CGContextRef
)dc
.GetWindow()->MacGetCGContextRef();
1370 cairo_surface_t
* surface
= cairo_quartz_surface_create_for_cg_context(cgcontext
, width
, height
);
1371 Init( cairo_create( surface
) );
1372 cairo_surface_destroy( surface
);
1376 wxCairoContext
::wxCairoContext( wxGraphicsRenderer
* renderer
, const wxMemoryDC
& dc
)
1377 : wxGraphicsContext(renderer
)
1380 dc
.GetSize( &width
, &height
);
1384 m_enableOffset
= true;
1387 m_mswSurface
= cairo_win32_surface_create((HDC
)dc
.GetHDC());
1388 Init( cairo_create(m_mswSurface
) );
1392 wxGTKDCImpl
*impldc
= (wxGTKDCImpl
*) dc
.GetImpl();
1393 Init( gdk_cairo_create( impldc
->GetGDKWindow() ) );
1396 wxGraphicsMatrix matrix
= CreateMatrix();
1398 wxPoint org
= dc
.GetDeviceOrigin();
1399 matrix
.Translate( org
.x
, org
.y
);
1401 org
= dc
.GetLogicalOrigin();
1402 matrix
.Translate( -org
.x
, -org
.y
);
1405 dc
.GetUserScale( &sx
, &sy
);
1406 matrix
.Scale( sx
, sy
);
1408 ConcatTransform( matrix
);
1413 CGContextRef cgcontext
= (CGContextRef
)dc
.GetWindow()->MacGetCGContextRef();
1414 cairo_surface_t
* surface
= cairo_quartz_surface_create_for_cg_context(cgcontext
, width
, height
);
1415 Init( cairo_create( surface
) );
1416 cairo_surface_destroy( surface
);
1421 wxCairoContext
::wxCairoContext( wxGraphicsRenderer
* renderer
, GdkDrawable
*drawable
)
1422 : wxGraphicsContext(renderer
)
1424 Init( gdk_cairo_create( drawable
) );
1427 gdk_drawable_get_size( drawable
, &width
, &height
);
1434 wxCairoContext
::wxCairoContext( wxGraphicsRenderer
* renderer
, HDC handle
)
1435 : wxGraphicsContext(renderer
)
1437 m_mswSurface
= cairo_win32_surface_create(handle
);
1438 Init( cairo_create(m_mswSurface
) );
1445 wxCairoContext
::wxCairoContext( wxGraphicsRenderer
* renderer
, cairo_t
*context
)
1446 : wxGraphicsContext(renderer
)
1453 wxCairoContext
::wxCairoContext( wxGraphicsRenderer
* renderer
, wxWindow
*window
)
1454 : wxGraphicsContext(renderer
)
1456 m_enableOffset
= true;
1458 // something along these lines (copied from dcclient)
1460 // Some controls don't have m_wxwindow - like wxStaticBox, but the user
1461 // code should still be able to create wxClientDCs for them, so we will
1462 // use the parent window here then.
1463 if (window
->m_wxwindow
== NULL
)
1465 window
= window
->GetParent();
1468 wxASSERT_MSG( window
->m_wxwindow
, wxT("wxCairoContext needs a widget") );
1470 Init(gdk_cairo_create(window
->GTKGetDrawingWindow()));
1472 wxSize sz
= window
->GetSize();
1478 m_mswSurface
= cairo_win32_surface_create((HDC
)window
->GetHandle());
1479 Init(cairo_create(m_mswSurface
));
1484 wxCairoContext
::~wxCairoContext()
1490 cairo_destroy(m_context
);
1494 cairo_surface_destroy(m_mswSurface
);
1498 void wxCairoContext
::Init(cairo_t
*context
)
1500 m_context
= context
;
1506 void wxCairoContext
::Clip( const wxRegion
& region
)
1508 // Create a path with all the rectangles in the region
1509 wxGraphicsPath path
= GetRenderer()->CreatePath();
1510 wxRegionIterator
ri(region
);
1513 path
.AddRectangle(ri
.GetX(), ri
.GetY(), ri
.GetW(), ri
.GetH());
1517 // Put it in the context
1518 cairo_path_t
* cp
= (cairo_path_t
*) path
.GetNativePath() ;
1519 cairo_append_path(m_context
, cp
);
1521 // clip to that path
1522 cairo_clip(m_context
);
1523 path
.UnGetNativePath(cp
);
1526 void wxCairoContext
::Clip( wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
)
1528 // Create a path with this rectangle
1529 wxGraphicsPath path
= GetRenderer()->CreatePath();
1530 path
.AddRectangle(x
,y
,w
,h
);
1532 // Put it in the context
1533 cairo_path_t
* cp
= (cairo_path_t
*) path
.GetNativePath() ;
1534 cairo_append_path(m_context
, cp
);
1536 // clip to that path
1537 cairo_clip(m_context
);
1538 path
.UnGetNativePath(cp
);
1541 void wxCairoContext
::ResetClip()
1543 cairo_reset_clip(m_context
);
1547 void wxCairoContext
::StrokePath( const wxGraphicsPath
& path
)
1549 if ( !m_pen
.IsNull() )
1551 wxCairoOffsetHelper
helper( m_context
, ShouldOffset() ) ;
1552 cairo_path_t
* cp
= (cairo_path_t
*) path
.GetNativePath() ;
1553 cairo_append_path(m_context
,cp
);
1554 ((wxCairoPenData
*)m_pen
.GetRefData())->Apply(this);
1555 cairo_stroke(m_context
);
1556 path
.UnGetNativePath(cp
);
1560 void wxCairoContext
::FillPath( const wxGraphicsPath
& path
, wxPolygonFillMode fillStyle
)
1562 if ( !m_brush
.IsNull() )
1564 wxCairoOffsetHelper
helper( m_context
, ShouldOffset() ) ;
1565 cairo_path_t
* cp
= (cairo_path_t
*) path
.GetNativePath() ;
1566 cairo_append_path(m_context
,cp
);
1567 ((wxCairoBrushData
*)m_brush
.GetRefData())->Apply(this);
1568 cairo_set_fill_rule(m_context
,fillStyle
==wxODDEVEN_RULE ? CAIRO_FILL_RULE_EVEN_ODD
: CAIRO_FILL_RULE_WINDING
);
1569 cairo_fill(m_context
);
1570 path
.UnGetNativePath(cp
);
1574 void wxCairoContext
::Rotate( wxDouble angle
)
1576 cairo_rotate(m_context
,angle
);
1579 void wxCairoContext
::Translate( wxDouble dx
, wxDouble dy
)
1581 cairo_translate(m_context
,dx
,dy
);
1584 void wxCairoContext
::Scale( wxDouble xScale
, wxDouble yScale
)
1586 cairo_scale(m_context
,xScale
,yScale
);
1589 // concatenates this transform with the current transform of this context
1590 void wxCairoContext
::ConcatTransform( const wxGraphicsMatrix
& matrix
)
1592 cairo_transform(m_context
,(const cairo_matrix_t
*) matrix
.GetNativeMatrix());
1595 // sets the transform of this context
1596 void wxCairoContext
::SetTransform( const wxGraphicsMatrix
& matrix
)
1598 cairo_set_matrix(m_context
,(const cairo_matrix_t
*) matrix
.GetNativeMatrix());
1601 // gets the matrix of this context
1602 wxGraphicsMatrix wxCairoContext
::GetTransform() const
1604 wxGraphicsMatrix matrix
= CreateMatrix();
1605 cairo_get_matrix(m_context
,(cairo_matrix_t
*) matrix
.GetNativeMatrix());
1611 void wxCairoContext
::PushState()
1613 cairo_save(m_context
);
1616 void wxCairoContext
::PopState()
1618 cairo_restore(m_context
);
1621 void wxCairoContext
::DrawBitmap( const wxBitmap
&bmp
, wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
)
1623 wxGraphicsBitmap bitmap
= GetRenderer()->CreateBitmap(bmp
);
1624 DrawBitmap(bitmap
, x
, y
, w
, h
);
1628 void wxCairoContext
::DrawBitmap(const wxGraphicsBitmap
&bmp
, wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
)
1632 // In case we're scaling the image by using a width and height different
1633 // than the bitmap's size create a pattern transformation on the surface and
1634 // draw the transformed pattern.
1635 wxCairoBitmapData
* data
= static_cast<wxCairoBitmapData
*>(bmp
.GetRefData());
1636 cairo_pattern_t
* pattern
= data
->GetCairoPattern();
1637 wxSize size
= data
->GetSize();
1639 wxDouble scaleX
= w
/ size
.GetWidth();
1640 wxDouble scaleY
= h
/ size
.GetHeight();
1642 // prepare to draw the image
1643 cairo_translate(m_context
, x
, y
);
1644 cairo_scale(m_context
, scaleX
, scaleY
);
1645 cairo_set_source(m_context
, pattern
);
1646 // use the original size here since the context is scaled already...
1647 cairo_rectangle(m_context
, 0, 0, size
.GetWidth(), size
.GetHeight());
1648 // fill the rectangle using the pattern
1649 cairo_fill(m_context
);
1654 void wxCairoContext
::DrawIcon( const wxIcon
&icon
, wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
)
1656 // An icon is a bitmap on wxGTK, so do this the easy way. When we want to
1657 // start using the Cairo backend on other platforms then we may need to
1658 // fiddle with this...
1659 DrawBitmap(icon
, x
, y
, w
, h
);
1663 void wxCairoContext
::DoDrawText(const wxString
& str
, wxDouble x
, wxDouble y
)
1665 wxCHECK_RET( !m_font
.IsNull(),
1666 wxT("wxCairoContext::DrawText - no valid font set") );
1671 const wxCharBuffer data
= str
.utf8_str();
1675 ((wxCairoFontData
*)m_font
.GetRefData())->Apply(this);
1678 size_t datalen
= strlen(data
);
1680 PangoLayout
*layout
= pango_cairo_create_layout (m_context
);
1681 wxCairoFontData
* font_data
= (wxCairoFontData
*) m_font
.GetRefData();
1682 pango_layout_set_font_description( layout
, font_data
->GetFont());
1683 pango_layout_set_text(layout
, data
, datalen
);
1685 if (font_data
->GetUnderlined())
1687 PangoAttrList
*attrs
= pango_attr_list_new();
1688 PangoAttribute
*attr
= pango_attr_underline_new(PANGO_UNDERLINE_SINGLE
);
1689 pango_attr_list_insert(attrs
, attr
);
1690 pango_layout_set_attributes(layout
, attrs
);
1691 pango_attr_list_unref(attrs
);
1694 cairo_move_to(m_context
, x
, y
);
1695 pango_cairo_show_layout (m_context
, layout
);
1697 g_object_unref (layout
);
1699 // Cairo's x,y for drawing text is at the baseline, so we need to adjust
1700 // the position we move to by the ascent.
1701 cairo_font_extents_t fe
;
1702 cairo_font_extents(m_context
, &fe
);
1703 cairo_move_to(m_context
, x
, y
+fe
.ascent
);
1705 cairo_show_text(m_context
, data
);
1709 void wxCairoContext
::GetTextExtent( const wxString
&str
, wxDouble
*width
, wxDouble
*height
,
1710 wxDouble
*descent
, wxDouble
*externalLeading
) const
1712 wxCHECK_RET( !m_font
.IsNull(), wxT("wxCairoContext::GetTextExtent - no valid font set") );
1720 if ( externalLeading
)
1721 *externalLeading
= 0;
1729 PangoLayout
*layout
= pango_cairo_create_layout (m_context
);
1730 pango_layout_set_font_description( layout
, ((wxCairoFontData
*)m_font
.GetRefData())->GetFont());
1731 const wxCharBuffer data
= str
.utf8_str();
1736 pango_layout_set_text( layout
, data
, strlen(data
) );
1737 pango_layout_get_pixel_size (layout
, &w
, &h
);
1744 PangoLayoutIter
*iter
= pango_layout_get_iter(layout
);
1745 int baseline
= pango_layout_iter_get_baseline(iter
);
1746 pango_layout_iter_free(iter
);
1747 *descent
= h
- PANGO_PIXELS(baseline
);
1749 g_object_unref (layout
);
1751 ((wxCairoFontData
*)m_font
.GetRefData())->Apply((wxCairoContext
*)this);
1755 const wxWX2MBbuf
buf(str
.mb_str(wxConvUTF8
));
1756 cairo_text_extents_t te
;
1757 cairo_text_extents(m_context
, buf
, &te
);
1761 if (height
|| descent
|| externalLeading
)
1763 cairo_font_extents_t fe
;
1764 cairo_font_extents(m_context
, &fe
);
1766 // some backends have negative descents
1768 if ( fe
.descent
< 0 )
1769 fe
.descent
= -fe
.descent
;
1771 if ( fe
.height
< (fe
.ascent
+ fe
.descent
) )
1773 // some backends are broken re height ... (eg currently ATSUI)
1774 fe
.height
= fe
.ascent
+ fe
.descent
;
1778 *height
= fe
.height
;
1780 *descent
= fe
.descent
;
1781 if ( externalLeading
)
1782 *externalLeading
= wxMax(0, fe
.height
- (fe
.ascent
+ fe
.descent
));
1787 void wxCairoContext
::GetPartialTextExtents(const wxString
& text
, wxArrayDouble
& widths
) const
1790 widths
.Add(0, text
.length());
1792 wxCHECK_RET( !m_font
.IsNull(), wxT("wxCairoContext::GetPartialTextExtents - no valid font set") );
1800 void * wxCairoContext
::GetNativeContext()
1805 bool wxCairoContext
::SetAntialiasMode(wxAntialiasMode antialias
)
1807 if (m_antialias
== antialias
)
1810 m_antialias
= antialias
;
1812 cairo_antialias_t antialiasMode
;
1815 case wxANTIALIAS_DEFAULT
:
1816 antialiasMode
= CAIRO_ANTIALIAS_DEFAULT
;
1818 case wxANTIALIAS_NONE
:
1819 antialiasMode
= CAIRO_ANTIALIAS_NONE
;
1824 cairo_set_antialias(m_context
, antialiasMode
);
1828 bool wxCairoContext
::SetInterpolationQuality(wxInterpolationQuality
WXUNUSED(interpolation
))
1834 bool wxCairoContext
::SetCompositionMode(wxCompositionMode op
)
1836 if ( m_composition
== op
)
1840 cairo_operator_t cop
;
1843 case wxCOMPOSITION_CLEAR
:
1844 cop
= CAIRO_OPERATOR_CLEAR
;
1846 case wxCOMPOSITION_SOURCE
:
1847 cop
= CAIRO_OPERATOR_SOURCE
;
1849 case wxCOMPOSITION_OVER
:
1850 cop
= CAIRO_OPERATOR_OVER
;
1852 case wxCOMPOSITION_IN
:
1853 cop
= CAIRO_OPERATOR_IN
;
1855 case wxCOMPOSITION_OUT
:
1856 cop
= CAIRO_OPERATOR_OUT
;
1858 case wxCOMPOSITION_ATOP
:
1859 cop
= CAIRO_OPERATOR_ATOP
;
1861 case wxCOMPOSITION_DEST
:
1862 cop
= CAIRO_OPERATOR_DEST
;
1864 case wxCOMPOSITION_DEST_OVER
:
1865 cop
= CAIRO_OPERATOR_DEST_OVER
;
1867 case wxCOMPOSITION_DEST_IN
:
1868 cop
= CAIRO_OPERATOR_DEST_IN
;
1870 case wxCOMPOSITION_DEST_OUT
:
1871 cop
= CAIRO_OPERATOR_DEST_OUT
;
1873 case wxCOMPOSITION_DEST_ATOP
:
1874 cop
= CAIRO_OPERATOR_DEST_ATOP
;
1876 case wxCOMPOSITION_XOR
:
1877 cop
= CAIRO_OPERATOR_XOR
;
1879 case wxCOMPOSITION_ADD
:
1880 cop
= CAIRO_OPERATOR_ADD
;
1885 cairo_set_operator(m_context
, cop
);
1889 void wxCairoContext
::BeginLayer(wxDouble opacity
)
1891 m_layerOpacities
.push_back(opacity
);
1892 cairo_push_group(m_context
);
1895 void wxCairoContext
::EndLayer()
1897 float opacity
= m_layerOpacities
.back();
1898 m_layerOpacities
.pop_back();
1899 cairo_pop_group_to_source(m_context
);
1900 cairo_paint_with_alpha(m_context
,opacity
);
1903 //-----------------------------------------------------------------------------
1904 // wxCairoRenderer declaration
1905 //-----------------------------------------------------------------------------
1907 class WXDLLIMPEXP_CORE wxCairoRenderer
: public wxGraphicsRenderer
1910 wxCairoRenderer() {}
1912 virtual ~wxCairoRenderer() {}
1916 virtual wxGraphicsContext
* CreateContext( const wxWindowDC
& dc
);
1917 virtual wxGraphicsContext
* CreateContext( const wxMemoryDC
& dc
);
1918 virtual wxGraphicsContext
* CreateContext( const wxPrinterDC
& dc
);
1920 virtual wxGraphicsContext
* CreateContextFromNativeContext( void * context
);
1922 virtual wxGraphicsContext
* CreateContextFromNativeWindow( void * window
);
1924 virtual wxGraphicsContext
* CreateContext( wxWindow
* window
);
1926 virtual wxGraphicsContext
* CreateMeasuringContext();
1928 #if wxUSE_ENH_METAFILE
1929 virtual wxGraphicsContext
* CreateContext( const wxEnhMetaFileDC
& dc
);
1934 virtual wxGraphicsPath
CreatePath();
1938 virtual wxGraphicsMatrix
CreateMatrix( wxDouble a
=1.0, wxDouble b
=0.0, wxDouble c
=0.0, wxDouble d
=1.0,
1939 wxDouble tx
=0.0, wxDouble ty
=0.0);
1942 virtual wxGraphicsPen
CreatePen(const wxPen
& pen
) ;
1944 virtual wxGraphicsBrush
CreateBrush(const wxBrush
& brush
) ;
1946 virtual wxGraphicsBrush
1947 CreateLinearGradientBrush(wxDouble x1
, wxDouble y1
,
1948 wxDouble x2
, wxDouble y2
,
1949 const wxGraphicsGradientStops
& stops
);
1951 virtual wxGraphicsBrush
1952 CreateRadialGradientBrush(wxDouble xo
, wxDouble yo
,
1953 wxDouble xc
, wxDouble yc
,
1955 const wxGraphicsGradientStops
& stops
);
1958 virtual wxGraphicsFont
CreateFont( const wxFont
&font
, const wxColour
&col
= *wxBLACK
) ;
1960 // create a native bitmap representation
1961 virtual wxGraphicsBitmap
CreateBitmap( const wxBitmap
&bitmap
);
1963 // create a graphics bitmap from a native bitmap
1964 virtual wxGraphicsBitmap
CreateBitmapFromNativeBitmap( void* bitmap
);
1966 // create a subimage from a native image representation
1967 virtual wxGraphicsBitmap
CreateSubBitmap( const wxGraphicsBitmap
&bitmap
, wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
);
1970 bool EnsureIsLoaded();
1973 friend class wxCairoModule
;
1976 DECLARE_DYNAMIC_CLASS_NO_COPY(wxCairoRenderer
)
1979 //-----------------------------------------------------------------------------
1980 // wxCairoRenderer implementation
1981 //-----------------------------------------------------------------------------
1983 IMPLEMENT_DYNAMIC_CLASS(wxCairoRenderer
,wxGraphicsRenderer
)
1985 static wxCairoRenderer gs_cairoGraphicsRenderer
;
1986 // temporary hack to allow creating a cairo context on any platform
1987 extern wxGraphicsRenderer
* gCairoRenderer
;
1988 wxGraphicsRenderer
* gCairoRenderer
= &gs_cairoGraphicsRenderer
;
1990 bool wxCairoRenderer
::EnsureIsLoaded()
1994 return wxCairoInit();
2000 void wxCairoRenderer
::Load()
2005 void wxCairoRenderer
::Unload()
2010 // call EnsureIsLoaded() and return returnOnFail value if it fails
2011 #define ENSURE_LOADED_OR_RETURN(returnOnFail) \
2012 if ( !EnsureIsLoaded() ) \
2013 return (returnOnFail)
2015 wxGraphicsContext
* wxCairoRenderer
::CreateContext( const wxWindowDC
& dc
)
2017 ENSURE_LOADED_OR_RETURN(NULL
);
2018 return new wxCairoContext(this,dc
);
2021 wxGraphicsContext
* wxCairoRenderer
::CreateContext( const wxMemoryDC
& dc
)
2023 ENSURE_LOADED_OR_RETURN(NULL
);
2024 return new wxCairoContext(this,dc
);
2027 wxGraphicsContext
* wxCairoRenderer
::CreateContext( const wxPrinterDC
& dc
)
2029 ENSURE_LOADED_OR_RETURN(NULL
);
2031 const wxDCImpl
*impl
= dc
.GetImpl();
2032 cairo_t
* context
= (cairo_t
*) impl
->GetCairoContext();
2034 return new wxCairoContext(this,dc
);
2037 return new wxCairoContext(this,dc
);
2041 #if wxUSE_ENH_METAFILE
2042 wxGraphicsContext
* wxCairoRenderer
::CreateContext( const wxEnhMetaFileDC
& WXUNUSED(dc
) )
2044 ENSURE_LOADED_OR_RETURN(NULL
);
2050 wxGraphicsContext
* wxCairoRenderer
::CreateContextFromNativeContext( void * context
)
2052 ENSURE_LOADED_OR_RETURN(NULL
);
2054 return new wxCairoContext(this,(HDC
)context
);
2056 return new wxCairoContext(this,(cairo_t
*)context
);
2061 wxGraphicsContext
* wxCairoRenderer
::CreateContextFromNativeWindow( void * window
)
2063 ENSURE_LOADED_OR_RETURN(NULL
);
2065 return new wxCairoContext(this,(GdkDrawable
*)window
);
2067 wxUnusedVar(window
);
2072 wxGraphicsContext
* wxCairoRenderer
::CreateMeasuringContext()
2074 ENSURE_LOADED_OR_RETURN(NULL
);
2076 return CreateContextFromNativeWindow(gdk_get_default_root_window());
2082 wxGraphicsContext
* wxCairoRenderer
::CreateContext( wxWindow
* window
)
2084 ENSURE_LOADED_OR_RETURN(NULL
);
2085 return new wxCairoContext(this, window
);
2090 wxGraphicsPath wxCairoRenderer
::CreatePath()
2092 ENSURE_LOADED_OR_RETURN(wxNullGraphicsPath
);
2093 wxGraphicsPath path
;
2094 path
.SetRefData( new wxCairoPathData(this) );
2101 wxGraphicsMatrix wxCairoRenderer
::CreateMatrix( wxDouble a
, wxDouble b
, wxDouble c
, wxDouble d
,
2102 wxDouble tx
, wxDouble ty
)
2105 ENSURE_LOADED_OR_RETURN(wxNullGraphicsMatrix
);
2107 wxCairoMatrixData
* data
= new wxCairoMatrixData( this );
2108 data
->Set( a
,b
,c
,d
,tx
,ty
) ;
2113 wxGraphicsPen wxCairoRenderer
::CreatePen(const wxPen
& pen
)
2115 ENSURE_LOADED_OR_RETURN(wxNullGraphicsPen
);
2116 if ( !pen
.IsOk() || pen
.GetStyle() == wxPENSTYLE_TRANSPARENT
)
2117 return wxNullGraphicsPen
;
2121 p
.SetRefData(new wxCairoPenData( this, pen
));
2126 wxGraphicsBrush wxCairoRenderer
::CreateBrush(const wxBrush
& brush
)
2128 ENSURE_LOADED_OR_RETURN(wxNullGraphicsBrush
);
2129 if ( !brush
.IsOk() || brush
.GetStyle() == wxBRUSHSTYLE_TRANSPARENT
)
2130 return wxNullGraphicsBrush
;
2134 p
.SetRefData(new wxCairoBrushData( this, brush
));
2140 wxCairoRenderer
::CreateLinearGradientBrush(wxDouble x1
, wxDouble y1
,
2141 wxDouble x2
, wxDouble y2
,
2142 const wxGraphicsGradientStops
& stops
)
2144 ENSURE_LOADED_OR_RETURN(wxNullGraphicsBrush
);
2146 wxCairoBrushData
* d
= new wxCairoBrushData( this );
2147 d
->CreateLinearGradientBrush(x1
, y1
, x2
, y2
, stops
);
2153 wxCairoRenderer
::CreateRadialGradientBrush(wxDouble xo
, wxDouble yo
,
2154 wxDouble xc
, wxDouble yc
, wxDouble r
,
2155 const wxGraphicsGradientStops
& stops
)
2157 ENSURE_LOADED_OR_RETURN(wxNullGraphicsBrush
);
2159 wxCairoBrushData
* d
= new wxCairoBrushData( this );
2160 d
->CreateRadialGradientBrush(xo
, yo
, xc
, yc
, r
, stops
);
2166 wxGraphicsFont wxCairoRenderer
::CreateFont( const wxFont
&font
, const wxColour
&col
)
2168 ENSURE_LOADED_OR_RETURN(wxNullGraphicsFont
);
2172 p
.SetRefData(new wxCairoFontData( this , font
, col
));
2176 return wxNullGraphicsFont
;
2179 wxGraphicsBitmap wxCairoRenderer
::CreateBitmap( const wxBitmap
& bmp
)
2181 ENSURE_LOADED_OR_RETURN(wxNullGraphicsBitmap
);
2185 p
.SetRefData(new wxCairoBitmapData( this , bmp
));
2189 return wxNullGraphicsBitmap
;
2192 wxGraphicsBitmap wxCairoRenderer
::CreateBitmapFromNativeBitmap( void* bitmap
)
2194 ENSURE_LOADED_OR_RETURN(wxNullGraphicsBitmap
);
2195 if ( bitmap
!= NULL
)
2198 p
.SetRefData(new wxCairoBitmapData( this , (cairo_surface_t
*) bitmap
));
2202 return wxNullGraphicsBitmap
;
2206 wxCairoRenderer
::CreateSubBitmap(const wxGraphicsBitmap
& WXUNUSED(bitmap
),
2207 wxDouble
WXUNUSED(x
),
2208 wxDouble
WXUNUSED(y
),
2209 wxDouble
WXUNUSED(w
),
2210 wxDouble
WXUNUSED(h
))
2212 ENSURE_LOADED_OR_RETURN(wxNullGraphicsBitmap
);
2213 wxFAIL_MSG("wxCairoRenderer::CreateSubBitmap is not implemented.");
2214 return wxNullGraphicsBitmap
;
2217 wxGraphicsRenderer
* wxGraphicsRenderer
::GetCairoRenderer()
2219 return &gs_cairoGraphicsRenderer
;
2222 #else // !wxUSE_CAIRO
2224 wxGraphicsRenderer
* wxGraphicsRenderer
::GetCairoRenderer()
2229 #endif // wxUSE_CAIRO/!wxUSE_CAIRO
2231 // MSW and OS X have their own native default renderers, but the other ports
2232 // use Cairo by default
2233 #if !(defined(__WXMSW__) || defined(__WXOSX__))
2234 wxGraphicsRenderer
* wxGraphicsRenderer
::GetDefaultRenderer()
2236 return GetCairoRenderer();
2238 #endif // !(__WXMSW__ || __WXOSX__)
2240 #endif // wxUSE_GRAPHICS_CONTEXT