src/generic/graphicc.cpp

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