src/mac/carbon/dccg.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        dc.cpp
   3 // Purpose:     wxDC class
   4 // Author:      Stefan Csomor
   5 // Modified by:
   6 // Created:     01/02/97
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Stefan Csomor
   9 // Licence:       wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #include "wx/wxprec.h"
  13
  14 #include "wx/dc.h"
  15
  16 #if wxMAC_USE_CORE_GRAPHICS
  17
  18 #include "wx/app.h"
  19 #include "wx/mac/uma.h"
  20 #include "wx/dcmemory.h"
  21 #include "wx/dcprint.h"
  22 #include "wx/region.h"
  23 #include "wx/image.h"
  24 #include "wx/log.h"
  25
  26
  27 #ifdef __MSL__
  28     #if __MSL__ >= 0x6000
  29         #include "math.h"
  30         // in case our functions were defined outside std, we make it known all the same
  31         namespace std { }
  32         using namespace std ;
  33     #endif
  34 #endif
  35
  36 #include "wx/mac/private.h"
  37
  38 IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
  39
  40 #ifndef wxMAC_USE_CORE_GRAPHICS_BLEND_MODES
  41 #define wxMAC_USE_CORE_GRAPHICS_BLEND_MODES 0
  42 #endif
  43
  44 //-----------------------------------------------------------------------------
  45 // constants
  46 //-----------------------------------------------------------------------------
  47
  48 #if !defined( __DARWIN__ ) || defined(__MWERKS__)
  49 #ifndef M_PI
  50 const double M_PI = 3.14159265358979 ;
  51 #endif
  52 #endif
  53
  54 const double RAD2DEG  = 180.0 / M_PI;
  55 const short kEmulatedMode = -1 ;
  56 const short kUnsupportedMode = -2 ;
  57
  58 extern TECObjectRef s_TECNativeCToUnicode ;
  59
  60
  61 // TODO: update
  62 // The textctrl implementation still needs that (needs what?) for the non-HIView implementation
  63 //
  64 wxMacWindowClipper::wxMacWindowClipper( const wxWindow* win ) :
  65     wxMacPortSaver( (GrafPtr) GetWindowPort((WindowRef) win->MacGetTopLevelWindowRef()) )
  66 {
  67     m_newPort = (GrafPtr) GetWindowPort((WindowRef) win->MacGetTopLevelWindowRef()) ;
  68     m_formerClip = NewRgn() ;
  69     m_newClip = NewRgn() ;
  70     GetClip( m_formerClip ) ;
  71
  72     if ( win )
  73     {
  74         // guard against half constructed objects, this just leads to a empty clip
  75         if ( win->GetPeer() )
  76         {
  77             int x = 0 , y = 0;
  78             win->MacWindowToRootWindow( &x, &y ) ;
  79             // get area including focus rect
  80             CopyRgn( (RgnHandle) ((wxWindow*)win)->MacGetVisibleRegion(true).GetWXHRGN() , m_newClip ) ;
  81             if ( !EmptyRgn( m_newClip ) )
  82                 OffsetRgn( m_newClip , x , y ) ;
  83         }
  84
  85         SetClip( m_newClip ) ;
  86     }
  87 }
  88
  89 wxMacWindowClipper::~wxMacWindowClipper()
  90 {
  91     SetPort( m_newPort ) ;
  92     SetClip( m_formerClip ) ;
  93     DisposeRgn( m_newClip ) ;
  94     DisposeRgn( m_formerClip ) ;
  95 }
  96
  97 wxMacWindowStateSaver::wxMacWindowStateSaver( const wxWindow* win ) :
  98     wxMacWindowClipper( win )
  99 {
 100     // the port is already set at this point
 101     m_newPort = (GrafPtr) GetWindowPort((WindowRef) win->MacGetTopLevelWindowRef()) ;
 102     GetThemeDrawingState( &m_themeDrawingState ) ;
 103 }
 104
 105 wxMacWindowStateSaver::~wxMacWindowStateSaver()
 106 {
 107     SetPort( m_newPort ) ;
 108     SetThemeDrawingState( m_themeDrawingState , true ) ;
 109 }
 110
 111 // minimal implementation only used for appearance drawing < 10.3
 112
 113 wxMacPortSetter::wxMacPortSetter( const wxDC* dc ) :
 114     m_ph( (GrafPtr) dc->m_macPort )
 115 {
 116     wxASSERT( dc->Ok() ) ;
 117     m_dc = dc ;
 118
 119 //    dc->MacSetupPort(&m_ph) ;
 120 }
 121
 122 wxMacPortSetter::~wxMacPortSetter()
 123 {
 124 //    m_dc->MacCleanupPort(&m_ph) ;
 125 }
 126
 127 //-----------------------------------------------------------------------------
 128 // Local functions
 129 //-----------------------------------------------------------------------------
 130
 131 static inline double dmin(double a, double b) { return a < b ? a : b; }
 132 static inline double dmax(double a, double b) { return a > b ? a : b; }
 133 static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; }
 134
 135 //-----------------------------------------------------------------------------
 136 // device context implementation
 137 //
 138 // more and more of the dc functionality should be implemented by calling
 139 // the appropricate wxMacCGContext, but we will have to do that step by step
 140 // also coordinate conversions should be moved to native matrix ops
 141 //-----------------------------------------------------------------------------
 142
 143 // we always stock two context states, one at entry, to be able to preserve the
 144 // state we were called with, the other one after changing to HI Graphics orientation
 145 // (this one is used for getting back clippings etc)
 146
 147 wxMacCGPath::wxMacCGPath()
 148 {
 149     m_path = CGPathCreateMutable() ;
 150 }
 151
 152 wxMacCGPath::~wxMacCGPath()
 153 {
 154     CGPathRelease( m_path ) ;
 155 }
 156
 157 // opens (starts) a new subpath
 158 void wxMacCGPath::MoveToPoint( wxCoord x1 , wxCoord y1 )
 159 {
 160     CGPathMoveToPoint( m_path , NULL , x1 , y1 ) ;
 161 }
 162
 163 void wxMacCGPath::AddLineToPoint( wxCoord x1 , wxCoord y1 )
 164 {
 165     CGPathAddLineToPoint( m_path , NULL , x1 , y1 ) ;
 166 }
 167
 168 void wxMacCGPath::AddQuadCurveToPoint( wxCoord cx1, wxCoord cy1, wxCoord x1, wxCoord y1 )
 169 {
 170     CGPathAddQuadCurveToPoint( m_path , NULL , cx1 , cy1 , x1 , y1 );
 171 }
 172
 173 void wxMacCGPath::AddRectangle( wxCoord x, wxCoord y, wxCoord w, wxCoord h )
 174 {
 175     CGRect cgRect = { { x , y } , { w , h } } ;
 176     CGPathAddRect( m_path , NULL , cgRect ) ;
 177 }
 178
 179 void wxMacCGPath::AddCircle( wxCoord x, wxCoord y , wxCoord r )
 180 {
 181     CGPathAddArc( m_path , NULL , x , y , r , 0.0 , 2 * M_PI , true ) ;
 182 }
 183
 184 // closes the current subpath
 185 void wxMacCGPath::CloseSubpath()
 186 {
 187     CGPathCloseSubpath( m_path ) ;
 188 }
 189
 190 CGPathRef wxMacCGPath::GetPath() const
 191 {
 192     return m_path ;
 193 }
 194
 195 wxMacCGContext::wxMacCGContext( CGrafPtr port )
 196 {
 197     m_qdPort = port ;
 198     m_cgContext = NULL ;
 199 }
 200
 201 wxMacCGContext::wxMacCGContext( CGContextRef cgcontext )
 202 {
 203     m_qdPort = NULL ;
 204     m_cgContext = cgcontext ;
 205     CGContextSaveGState( m_cgContext ) ;
 206     CGContextSaveGState( m_cgContext ) ;
 207 }
 208
 209 wxMacCGContext::wxMacCGContext()
 210 {
 211     m_qdPort = NULL ;
 212     m_cgContext = NULL ;
 213 }
 214
 215 wxMacCGContext::~wxMacCGContext()
 216 {
 217     if ( m_cgContext )
 218     {
 219         CGContextSynchronize( m_cgContext ) ;
 220         CGContextRestoreGState( m_cgContext ) ;
 221         CGContextRestoreGState( m_cgContext ) ;
 222     }
 223
 224     if ( m_qdPort )
 225         CGContextRelease( m_cgContext ) ;
 226 }
 227
 228
 229 void wxMacCGContext::Clip( const wxRegion &region )
 230 {
 231 //    ClipCGContextToRegion ( m_cgContext, &bounds , (RgnHandle) dc->m_macCurrentClipRgn ) ;
 232 }
 233
 234 void wxMacCGContext::StrokePath( const wxGraphicPath *p )
 235 {
 236     const wxMacCGPath* path = dynamic_cast< const wxMacCGPath*>( p ) ;
 237     CGContextAddPath( m_cgContext , path->GetPath() ) ;
 238     CGContextStrokePath( m_cgContext ) ;
 239 }
 240
 241 void wxMacCGContext::DrawPath( const wxGraphicPath *p , int fillStyle )
 242 {
 243     const wxMacCGPath* path = dynamic_cast< const wxMacCGPath*>( p ) ;
 244     CGPathDrawingMode mode = m_mode ;
 245
 246     if ( fillStyle == wxODDEVEN_RULE )
 247     {
 248         if ( mode == kCGPathFill )
 249             mode = kCGPathEOFill ;
 250         else if ( mode == kCGPathFillStroke )
 251             mode = kCGPathEOFillStroke ;
 252     }
 253
 254     CGContextAddPath( m_cgContext , path->GetPath() ) ;
 255     CGContextDrawPath( m_cgContext , mode ) ;
 256 }
 257
 258 void wxMacCGContext::FillPath( const wxGraphicPath *p , const wxColor &fillColor , int fillStyle )
 259 {
 260     const wxMacCGPath* path = dynamic_cast< const wxMacCGPath*>( p ) ;
 261     CGContextSaveGState( m_cgContext ) ;
 262
 263     RGBColor col = MAC_WXCOLORREF( fillColor.GetPixel() ) ;
 264     CGContextSetRGBFillColor( m_cgContext , col.red / 65536.0 , col.green / 65536.0 , col.blue / 65536.0 , 1.0 ) ;
 265     CGPathDrawingMode mode = kCGPathFill ;
 266
 267     if ( fillStyle == wxODDEVEN_RULE )
 268         mode = kCGPathEOFill ;
 269
 270     CGContextBeginPath( m_cgContext ) ;
 271     CGContextAddPath( m_cgContext , path->GetPath() ) ;
 272     CGContextClosePath( m_cgContext ) ;
 273     CGContextDrawPath( m_cgContext , mode ) ;
 274
 275     CGContextRestoreGState( m_cgContext ) ;
 276 }
 277
 278 wxGraphicPath* wxMacCGContext::CreatePath()
 279 {
 280     // make sure that we now have a real cgref, before doing
 281     // anything with paths
 282     CGContextRef cg = GetNativeContext() ;
 283     cg = NULL ;
 284
 285     return new wxMacCGPath() ;
 286 }
 287
 288 // in case we only got a QDPort only create a cgref now
 289
 290 CGContextRef wxMacCGContext::GetNativeContext()
 291 {
 292     if ( m_cgContext == NULL )
 293     {
 294         Rect bounds ;
 295         GetPortBounds( (CGrafPtr) m_qdPort , &bounds ) ;
 296         OSStatus status = CreateCGContextForPort((CGrafPtr) m_qdPort , &m_cgContext) ;
 297         CGContextSaveGState( m_cgContext ) ;
 298
 299         wxASSERT_MSG( status == noErr , wxT("Cannot nest wxDCs on the same window") ) ;
 300
 301         CGContextTranslateCTM( m_cgContext , 0 , bounds.bottom - bounds.top ) ;
 302         CGContextScaleCTM( m_cgContext , 1 , -1 ) ;
 303
 304         CGContextSaveGState( m_cgContext ) ;
 305         SetPen( m_pen ) ;
 306         SetBrush( m_brush ) ;
 307     }
 308
 309     return m_cgContext ;
 310 }
 311
 312 void wxMacCGContext::SetNativeContext( CGContextRef cg )
 313 {
 314     // we allow either setting or clearing but not replacing
 315     wxASSERT( m_cgContext == NULL || cg == NULL ) ;
 316
 317     if ( cg )
 318         CGContextSaveGState( cg ) ;
 319     m_cgContext = cg ;
 320 }
 321
 322 #pragma mark -
 323 #pragma mark wxMacCGPattern, ImagePattern, HatchPattern classes
 324
 325 // CGPattern wrapper class: always allocate on heap, never call destructor
 326
 327 class wxMacCGPattern
 328 {
 329 public :
 330     wxMacCGPattern() {}
 331
 332     // is guaranteed to be called only with a non-Null CGContextRef
 333     virtual void Render( CGContextRef ctxRef ) = 0 ;
 334
 335     operator CGPatternRef() const { return m_patternRef ; }
 336
 337 protected :
 338     virtual ~wxMacCGPattern()
 339     {
 340         // as this is called only when the m_patternRef is been released;
 341         // don't release it again
 342     }
 343
 344     static void _Render( void *info, CGContextRef ctxRef )
 345     {
 346         wxMacCGPattern* self = (wxMacCGPattern*) info ;
 347         if ( self && ctxRef )
 348             self->Render( ctxRef ) ;
 349     }
 350
 351     static void _Dispose( void *info )
 352     {
 353         wxMacCGPattern* self = (wxMacCGPattern*) info ;
 354         delete self ;
 355     }
 356
 357     CGPatternRef m_patternRef ;
 358
 359     static const CGPatternCallbacks ms_Callbacks ;
 360 } ;
 361
 362 const CGPatternCallbacks wxMacCGPattern::ms_Callbacks = { 0, &wxMacCGPattern::_Render, &wxMacCGPattern::_Dispose };
 363
 364 class ImagePattern : public wxMacCGPattern
 365 {
 366 public :
 367     ImagePattern( const wxBitmap* bmp , CGAffineTransform transform )
 368     {
 369         wxASSERT( bmp && bmp->Ok() ) ;
 370
 371         Init( (CGImageRef) bmp->CGImageCreate() , transform ) ;
 372     }
 373
 374     // ImagePattern takes ownership of CGImageRef passed in
 375     ImagePattern( CGImageRef image , CGAffineTransform transform )
 376     {
 377         if ( image )
 378             CFRetain( image ) ;
 379
 380         Init( image , transform ) ;
 381     }
 382
 383     virtual void Render( CGContextRef ctxRef )
 384     {
 385         if (m_image != NULL)
 386             HIViewDrawCGImage( ctxRef, &m_imageBounds, m_image );
 387     }
 388
 389 protected :
 390     void Init( CGImageRef image, CGAffineTransform transform )
 391     {
 392         m_image = image ;
 393         if ( m_image )
 394         {
 395             m_imageBounds = CGRectMake( 0.0, 0.0, (float)CGImageGetWidth( m_image  ), (float)CGImageGetHeight( m_image ) ) ;
 396             m_patternRef = CGPatternCreate( this , m_imageBounds, transform ,
 397                                             m_imageBounds.size.width, m_imageBounds.size.height,
 398                                             kCGPatternTilingNoDistortion, true , &wxMacCGPattern::ms_Callbacks ) ;
 399         }
 400     }
 401
 402     ~ImagePattern()
 403     {
 404         if ( m_image )
 405             CGImageRelease( m_image ) ;
 406     }
 407
 408     CGImageRef  m_image ;
 409     CGRect      m_imageBounds ;
 410 } ;
 411
 412 class HatchPattern : public wxMacCGPattern
 413 {
 414 public :
 415     HatchPattern( int hatchstyle, CGAffineTransform transform )
 416     {
 417         m_hatch = hatchstyle ;
 418         m_imageBounds = CGRectMake( 0.0, 0.0, 8.0 , 8.0 ) ;
 419         m_patternRef = CGPatternCreate( this , m_imageBounds, transform ,
 420                                             m_imageBounds.size.width, m_imageBounds.size.height,
 421                                             kCGPatternTilingNoDistortion, false , &wxMacCGPattern::ms_Callbacks ) ;
 422     }
 423
 424     void StrokeLineSegments( CGContextRef ctxRef , const CGPoint pts[] , size_t count )
 425     {
 426 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4
 427         if ( UMAGetSystemVersion() >= 0x1040 )
 428         {
 429             CGContextStrokeLineSegments( ctxRef , pts , count ) ;
 430         }
 431         else
 432 #endif
 433         {
 434             CGContextBeginPath( ctxRef );
 435             for (size_t i = 0; i < count; i += 2)
 436             {
 437                 CGContextMoveToPoint(ctxRef, pts[i].x, pts[i].y);
 438                 CGContextAddLineToPoint(ctxRef, pts[i+1].x, pts[i+1].y);
 439             }
 440             CGContextStrokePath(ctxRef);
 441         }
 442     }
 443
 444     virtual void Render( CGContextRef ctxRef )
 445     {
 446         switch ( m_hatch )
 447         {
 448             case wxBDIAGONAL_HATCH :
 449                 {
 450                     CGPoint pts[] =
 451                     {
 452                     { 8.0 , 0.0 } , { 0.0 , 8.0 }
 453                     };
 454                     StrokeLineSegments( ctxRef , pts , 2 ) ;
 455                 }
 456                 break ;
 457
 458             case wxCROSSDIAG_HATCH :
 459                 {
 460                     CGPoint pts[] =
 461                     {
 462                         { 0.0 , 0.0 } , { 8.0 , 8.0 } ,
 463                         { 8.0 , 0.0 } , { 0.0 , 8.0 }
 464                     };
 465                     StrokeLineSegments( ctxRef , pts , 4 ) ;
 466                 }
 467                 break ;
 468
 469             case wxFDIAGONAL_HATCH :
 470                 {
 471                     CGPoint pts[] =
 472                     {
 473                     { 0.0 , 0.0 } , { 8.0 , 8.0 }
 474                     };
 475                     StrokeLineSegments( ctxRef , pts , 2 ) ;
 476                 }
 477                 break ;
 478
 479             case wxCROSS_HATCH :
 480                 {
 481                     CGPoint pts[] =
 482                     {
 483                     { 0.0 , 4.0 } , { 8.0 , 4.0 } ,
 484                     { 4.0 , 0.0 } , { 4.0 , 8.0 } ,
 485                     };
 486                     StrokeLineSegments( ctxRef , pts , 4 ) ;
 487                 }
 488                 break ;
 489
 490             case wxHORIZONTAL_HATCH :
 491                 {
 492                     CGPoint pts[] =
 493                     {
 494                     { 0.0 , 4.0 } , { 8.0 , 4.0 } ,
 495                     };
 496                     StrokeLineSegments( ctxRef , pts , 2 ) ;
 497                 }
 498                 break ;
 499
 500             case wxVERTICAL_HATCH :
 501                 {
 502                     CGPoint pts[] =
 503                     {
 504                     { 4.0 , 0.0 } , { 4.0 , 8.0 } ,
 505                     };
 506                     StrokeLineSegments( ctxRef , pts , 2 ) ;
 507                 }
 508                 break ;
 509
 510             default:
 511                 break;
 512         }
 513     }
 514
 515 protected :
 516     ~HatchPattern() {}
 517
 518     CGRect      m_imageBounds ;
 519     int         m_hatch ;
 520 } ;
 521
 522 #pragma mark -
 523
 524 void wxMacCGContext::SetPen( const wxPen &pen )
 525 {
 526     m_pen = pen ;
 527     if ( m_cgContext == NULL )
 528         return ;
 529
 530     bool fill = m_brush.GetStyle() != wxTRANSPARENT ;
 531     bool stroke = pen.GetStyle() != wxTRANSPARENT ;
 532
 533 #if 0
 534     // we can benchmark performance, should go into a setting later
 535     CGContextSetShouldAntialias( m_cgContext , false ) ;
 536 #endif
 537
 538     if ( fill | stroke )
 539     {
 540         // set up brushes
 541         m_mode = kCGPathFill ; // just a default
 542
 543         if ( stroke )
 544         {
 545             RGBColor col = MAC_WXCOLORREF( pen.GetColour().GetPixel() ) ;
 546             CGContextSetRGBStrokeColor( m_cgContext , col.red / 65536.0 , col.green / 65536.0 , col.blue / 65536.0 , 1.0 ) ;
 547
 548             // TODO * m_dc->m_scaleX
 549             float penWidth = pen.GetWidth();
 550             if (penWidth <= 0.0)
 551                 penWidth = 0.1;
 552             CGContextSetLineWidth( m_cgContext , penWidth ) ;
 553
 554             CGLineCap cap ;
 555             switch ( pen.GetCap() )
 556             {
 557                 case wxCAP_ROUND :
 558                     cap = kCGLineCapRound ;
 559                     break ;
 560
 561                 case wxCAP_PROJECTING :
 562                     cap = kCGLineCapSquare ;
 563                     break ;
 564
 565                 case wxCAP_BUTT :
 566                     cap = kCGLineCapButt ;
 567                     break ;
 568
 569                 default :
 570                     cap = kCGLineCapButt ;
 571                     break ;
 572             }
 573
 574             CGLineJoin join ;
 575             switch ( pen.GetJoin() )
 576             {
 577                 case wxJOIN_BEVEL :
 578                     join = kCGLineJoinBevel ;
 579                     break ;
 580
 581                 case wxJOIN_MITER :
 582                     join = kCGLineJoinMiter ;
 583                     break ;
 584
 585                 case wxJOIN_ROUND :
 586                     join = kCGLineJoinRound ;
 587                     break ;
 588
 589                 default :
 590                     join = kCGLineJoinMiter ;
 591                     break;
 592             }
 593
 594             m_mode = kCGPathStroke ;
 595             int count = 0 ;
 596
 597             const float *lengths = NULL ;
 598             float *userLengths = NULL ;
 599
 600             const float dashUnit = penWidth < 1.0 ? 1.0 : penWidth;
 601
 602             const float dotted[] = { dashUnit , dashUnit + 2.0 };
 603             const float short_dashed[] = { 9.0 , 6.0 };
 604             const float dashed[] = { 19.0 , 9.0 };
 605             const float dotted_dashed[] = { 9.0 , 6.0 , 3.0 , 3.0 };
 606
 607             switch ( pen.GetStyle() )
 608             {
 609                 case wxSOLID :
 610                     break ;
 611
 612                 case wxDOT :
 613                     lengths = dotted ;
 614                     count = WXSIZEOF(dotted);
 615                     break ;
 616
 617                 case wxLONG_DASH :
 618                     lengths = dashed ;
 619                     count = WXSIZEOF(dashed) ;
 620                     break ;
 621
 622                 case wxSHORT_DASH :
 623                     lengths = short_dashed ;
 624                     count = WXSIZEOF(short_dashed) ;
 625                     break ;
 626
 627                 case wxDOT_DASH :
 628                     lengths = dotted_dashed ;
 629                     count = WXSIZEOF(dotted_dashed);
 630                     break ;
 631
 632                 case wxUSER_DASH :
 633                     wxDash *dashes ;
 634                     count = pen.GetDashes( &dashes ) ;
 635                     if ((dashes != NULL) && (count > 0))
 636                     {
 637                         userLengths = new float[count] ;
 638                         for ( int i = 0 ; i < count ; ++i )
 639                         {
 640                             userLengths[i] = dashes[i] * dashUnit ;
 641
 642                             if ( i % 2 == 1 && userLengths[i] < dashUnit + 2.0 )
 643                                 userLengths[i] = dashUnit + 2.0 ;
 644                             else if ( i % 2 == 0 && userLengths[i] < dashUnit )
 645                                 userLengths[i] = dashUnit ;
 646                         }
 647                     }
 648                     lengths = userLengths ;
 649                     break ;
 650
 651                 case wxSTIPPLE :
 652                     {
 653                         float  alphaArray[1] = { 1.0 } ;
 654                         wxBitmap* bmp = pen.GetStipple() ;
 655                         if ( bmp && bmp->Ok() )
 656                         {
 657                             wxMacCFRefHolder<CGColorSpaceRef> patternSpace( CGColorSpaceCreatePattern( NULL ) ) ;
 658                             CGContextSetStrokeColorSpace( m_cgContext , patternSpace ) ;
 659                             wxMacCFRefHolder<CGPatternRef> pattern( *( new ImagePattern( bmp , CGContextGetCTM( m_cgContext ) ) ) );
 660                             CGContextSetStrokePattern( m_cgContext, pattern , alphaArray ) ;
 661                         }
 662                     }
 663                     break ;
 664
 665                 default :
 666                     {
 667                         wxMacCFRefHolder<CGColorSpaceRef> patternSpace( CGColorSpaceCreatePattern( wxMacGetGenericRGBColorSpace() ) ) ;
 668                         CGContextSetStrokeColorSpace( m_cgContext , patternSpace ) ;
 669                         wxMacCFRefHolder<CGPatternRef> pattern( *( new HatchPattern( pen.GetStyle() , CGContextGetCTM( m_cgContext ) ) ) );
 670
 671                         RGBColor col = MAC_WXCOLORREF( pen.GetColour().GetPixel() ) ;
 672                         float  colorArray[4] = { col.red / 65536.0 , col.green / 65536.0 , col.blue / 65536.0 , 1.0 } ;
 673
 674                         CGContextSetStrokePattern( m_cgContext, pattern , colorArray ) ;
 675                     }
 676                     break ;
 677             }
 678
 679             if ((lengths != NULL) && (count > 0))
 680             {
 681                 CGContextSetLineDash( m_cgContext , 0 , lengths , count ) ;
 682                 // force the line cap, otherwise we get artifacts (overlaps) and just solid lines
 683                 cap = kCGLineCapButt ;
 684             }
 685             else
 686             {
 687                CGContextSetLineDash( m_cgContext , 0 , NULL , 0 ) ;
 688             }
 689
 690             CGContextSetLineCap( m_cgContext , cap ) ;
 691             CGContextSetLineJoin( m_cgContext , join ) ;
 692
 693             delete[] userLengths ;
 694         }
 695
 696         if ( fill && stroke )
 697             m_mode = kCGPathFillStroke ;
 698     }
 699 }
 700
 701 void wxMacCGContext::SetBrush( const wxBrush &brush )
 702 {
 703     m_brush = brush ;
 704     if ( m_cgContext == NULL )
 705         return ;
 706
 707     bool fill = brush.GetStyle() != wxTRANSPARENT ;
 708     bool stroke = m_pen.GetStyle() != wxTRANSPARENT ;
 709
 710 #if 0
 711     // we can benchmark performance, should go into a setting later
 712     CGContextSetShouldAntialias( m_cgContext , false ) ;
 713 #endif
 714
 715     if ( fill | stroke )
 716     {
 717         // setup brushes
 718         m_mode = kCGPathFill ; // just a default
 719
 720         if ( fill )
 721         {
 722             if ( brush.GetStyle() == wxSOLID )
 723             {
 724                 RGBColor col = MAC_WXCOLORREF( brush.GetColour().GetPixel() ) ;
 725                 CGContextSetRGBFillColor( m_cgContext , col.red / 65536.0 , col.green / 65536.0 , col.blue / 65536.0 , 1.0 ) ;
 726             }
 727             else if ( brush.IsHatch() )
 728             {
 729                 wxMacCFRefHolder<CGColorSpaceRef> patternSpace( CGColorSpaceCreatePattern( wxMacGetGenericRGBColorSpace() ) ) ;
 730                 CGContextSetFillColorSpace( m_cgContext , patternSpace ) ;
 731                 wxMacCFRefHolder<CGPatternRef> pattern( *( new HatchPattern( brush.GetStyle() , CGContextGetCTM( m_cgContext ) ) ) );
 732
 733                 RGBColor col = MAC_WXCOLORREF( brush.GetColour().GetPixel() ) ;
 734                 float  colorArray[4] = { col.red / 65536.0 , col.green / 65536.0 , col.blue / 65536.0 , 1.0 } ;
 735
 736                 CGContextSetFillPattern( m_cgContext, pattern , colorArray ) ;
 737             }
 738             else
 739             {
 740                 // now brush is a bitmap
 741                 float  alphaArray[1] = { 1.0 } ;
 742                 wxBitmap* bmp = brush.GetStipple() ;
 743                 if ( bmp && bmp->Ok() )
 744                 {
 745                     wxMacCFRefHolder<CGColorSpaceRef> patternSpace( CGColorSpaceCreatePattern( NULL ) ) ;
 746                     CGContextSetFillColorSpace( m_cgContext , patternSpace ) ;
 747                     wxMacCFRefHolder<CGPatternRef> pattern( *( new ImagePattern( bmp , CGContextGetCTM( m_cgContext ) ) ) );
 748                     CGContextSetFillPattern( m_cgContext, pattern , alphaArray ) ;
 749                 }
 750             }
 751
 752             m_mode = kCGPathFill ;
 753         }
 754
 755         if ( fill && stroke )
 756             m_mode = kCGPathFillStroke ;
 757         else if ( stroke )
 758             m_mode = kCGPathStroke ;
 759     }
 760 }
 761
 762 void AddEllipticArcToPath(CGContextRef c, CGPoint center, float a, float b, float fromDegree , float toDegree )
 763 {
 764     CGContextSaveGState(c);
 765     CGContextTranslateCTM(c, center.x, center.y);
 766     CGContextScaleCTM(c, a, b);
 767     CGContextMoveToPoint(c, 1, 0);
 768     CGContextAddArc(c, 0, 0, 1, DegToRad(fromDegree), DegToRad(toDegree), 0);
 769     CGContextClosePath(c);
 770     CGContextRestoreGState(c);
 771 }
 772
 773 void AddRoundedRectToPath(CGContextRef c, CGRect rect, float ovalWidth,
 774       float ovalHeight)
 775 {
 776     float fw, fh;
 777     if (ovalWidth == 0 || ovalHeight == 0)
 778     {
 779         CGContextAddRect(c, rect);
 780         return;
 781     }
 782
 783     CGContextSaveGState(c);
 784     CGContextTranslateCTM(c, CGRectGetMinX(rect), CGRectGetMinY(rect));
 785     CGContextScaleCTM(c, ovalWidth, ovalHeight);
 786
 787     fw = CGRectGetWidth(rect) / ovalWidth;
 788     fh = CGRectGetHeight(rect) / ovalHeight;
 789
 790     CGContextMoveToPoint(c, fw, fh / 2);
 791     CGContextAddArcToPoint(c, fw, fh, fw / 2, fh, 1);
 792     CGContextAddArcToPoint(c, 0, fh, 0, fh / 2, 1);
 793     CGContextAddArcToPoint(c, 0, 0, fw / 2, 0, 1);
 794     CGContextAddArcToPoint(c, fw, 0, fw, fh / 2, 1);
 795     CGContextClosePath(c);
 796     CGContextRestoreGState(c);
 797 }
 798
 799 #pragma mark -
 800
 801 wxDC::wxDC()
 802 {
 803     m_ok = false ;
 804     m_colour = true;
 805     m_mm_to_pix_x = mm2pt;
 806     m_mm_to_pix_y = mm2pt;
 807
 808     m_externalDeviceOriginX = 0;
 809     m_externalDeviceOriginY = 0;
 810     m_logicalScaleX = 1.0;
 811     m_logicalScaleY = 1.0;
 812     m_userScaleX = 1.0;
 813     m_userScaleY = 1.0;
 814     m_scaleX = 1.0;
 815     m_scaleY = 1.0;
 816     m_needComputeScaleX =
 817     m_needComputeScaleY = false;
 818
 819     m_macPort = 0 ;
 820     m_macLocalOrigin.x =
 821     m_macLocalOrigin.y = 0 ;
 822
 823     m_pen = *wxBLACK_PEN;
 824     m_font = *wxNORMAL_FONT;
 825     m_brush = *wxWHITE_BRUSH;
 826
 827     m_macATSUIStyle = NULL ;
 828     m_graphicContext = NULL ;
 829 }
 830
 831 wxDC::~wxDC()
 832 {
 833     if ( m_macATSUIStyle )
 834     {
 835         ::ATSUDisposeStyle((ATSUStyle)m_macATSUIStyle);
 836         m_macATSUIStyle = NULL ;
 837     }
 838
 839     delete m_graphicContext ;
 840 }
 841
 842 void wxDC::DoDrawBitmap( const wxBitmap &bmp, wxCoord x, wxCoord y, bool useMask )
 843 {
 844     wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoDrawBitmap - invalid DC") );
 845     wxCHECK_RET( bmp.Ok(), wxT("wxDC(cg)::DoDrawBitmap - invalid bitmap") );
 846
 847     wxCoord xx = XLOG2DEVMAC(x);
 848     wxCoord yy = YLOG2DEVMAC(y);
 849     wxCoord w = bmp.GetWidth();
 850     wxCoord h = bmp.GetHeight();
 851     wxCoord ww = XLOG2DEVREL(w);
 852     wxCoord hh = YLOG2DEVREL(h);
 853
 854     CGContextRef cg = ((wxMacCGContext*)(m_graphicContext))->GetNativeContext() ;
 855     CGImageRef image = (CGImageRef)( bmp.CGImageCreate() ) ;
 856     HIRect r = CGRectMake( xx , yy , ww , hh ) ;
 857     HIViewDrawCGImage( cg , &r , image ) ;
 858     CGImageRelease( image ) ;
 859 }
 860
 861 void wxDC::DoDrawIcon( const wxIcon &icon, wxCoord x, wxCoord y )
 862 {
 863     wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoDrawIcon - invalid DC") );
 864     wxCHECK_RET( icon.Ok(), wxT("wxDC(cg)::DoDrawIcon - invalid icon") );
 865
 866     wxCoord xx = XLOG2DEVMAC(x);
 867     wxCoord yy = YLOG2DEVMAC(y);
 868     wxCoord w = icon.GetWidth();
 869     wxCoord h = icon.GetHeight();
 870     wxCoord ww = XLOG2DEVREL(w);
 871     wxCoord hh = YLOG2DEVREL(h);
 872
 873     CGContextRef cg = ((wxMacCGContext*)(m_graphicContext))->GetNativeContext() ;
 874     CGRect r = CGRectMake( 00 , 00 , ww , hh ) ;
 875     CGContextSaveGState( cg );
 876     CGContextTranslateCTM( cg, xx , yy + hh );
 877     CGContextScaleCTM( cg, 1, -1 );
 878     PlotIconRefInContext( cg , &r , kAlignNone , kTransformNone ,
 879         NULL , kPlotIconRefNormalFlags , MAC_WXHICON( icon.GetHICON() ) ) ;
 880     CGContextRestoreGState( cg ) ;
 881 }
 882
 883 void wxDC::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
 884 {
 885     wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoSetClippingRegion - invalid DC") );
 886
 887     wxCoord xx, yy, ww, hh;
 888     xx = XLOG2DEVMAC(x);
 889     yy = YLOG2DEVMAC(y);
 890     ww = XLOG2DEVREL(width);
 891     hh = YLOG2DEVREL(height);
 892
 893     CGContextRef cgContext = ((wxMacCGContext*)(m_graphicContext))->GetNativeContext() ;
 894     CGRect clipRect = CGRectMake( xx , yy , ww, hh ) ;
 895     CGContextClipToRect( cgContext , clipRect ) ;
 896
 897 //    SetRectRgn( (RgnHandle) m_macCurrentClipRgn , xx , yy , xx + ww , yy + hh ) ;
 898 //    SectRgn( (RgnHandle) m_macCurrentClipRgn , (RgnHandle) m_macBoundaryClipRgn , (RgnHandle) m_macCurrentClipRgn ) ;
 899
 900     if ( m_clipping )
 901     {
 902         m_clipX1 = wxMax( m_clipX1, xx );
 903         m_clipY1 = wxMax( m_clipY1, yy );
 904         m_clipX2 = wxMin( m_clipX2, (xx + ww) );
 905         m_clipY2 = wxMin( m_clipY2, (yy + hh) );
 906     }
 907     else
 908     {
 909         m_clipping = true;
 910
 911         m_clipX1 = xx;
 912         m_clipY1 = yy;
 913         m_clipX2 = xx + ww;
 914         m_clipY2 = yy + hh;
 915     }
 916
 917     // TODO: as soon as we don't reset the context for each operation anymore
 918     // we have to update the context as well
 919 }
 920
 921 void wxDC::DoSetClippingRegionAsRegion( const wxRegion &region )
 922 {
 923     wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoSetClippingRegionAsRegion - invalid DC") );
 924
 925     if (region.Empty())
 926     {
 927         DestroyClippingRegion();
 928         return;
 929     }
 930
 931     wxCoord x, y, w, h;
 932     region.GetBox( x, y, w, h );
 933     wxCoord xx, yy, ww, hh;
 934     xx = XLOG2DEVMAC(x);
 935     yy = YLOG2DEVMAC(y);
 936     ww = XLOG2DEVREL(w);
 937     hh = YLOG2DEVREL(h);
 938
 939     // if we have a scaling that we cannot map onto native regions
 940     // we must use the box
 941     if ( ww != w || hh != h )
 942     {
 943         wxDC::DoSetClippingRegion( x, y, w, h );
 944     }
 945     else
 946     {
 947 #if 0
 948         CopyRgn( (RgnHandle) region.GetWXHRGN() , (RgnHandle) m_macCurrentClipRgn ) ;
 949         if ( xx != x || yy != y )
 950             OffsetRgn( (RgnHandle) m_macCurrentClipRgn , xx - x , yy - y ) ;
 951         SectRgn( (RgnHandle)m_macCurrentClipRgn , (RgnHandle)m_macBoundaryClipRgn , (RgnHandle)m_macCurrentClipRgn ) ;
 952 #endif
 953
 954         if ( m_clipping )
 955         {
 956             m_clipX1 = wxMax( m_clipX1, xx );
 957             m_clipY1 = wxMax( m_clipY1, yy );
 958             m_clipX2 = wxMin( m_clipX2, (xx + ww) );
 959             m_clipY2 = wxMin( m_clipY2, (yy + hh) );
 960         }
 961         else
 962         {
 963             m_clipping = true;
 964
 965             m_clipX1 = xx;
 966             m_clipY1 = yy;
 967             m_clipX2 = xx + ww;
 968             m_clipY2 = yy + hh;
 969         }
 970     }
 971 }
 972
 973 void wxDC::DestroyClippingRegion()
 974 {
 975 //    CopyRgn( (RgnHandle) m_macBoundaryClipRgn , (RgnHandle) m_macCurrentClipRgn ) ;
 976
 977     CGContextRef cgContext = ((wxMacCGContext*)(m_graphicContext))->GetNativeContext() ;
 978     CGContextRestoreGState( cgContext );
 979     CGContextSaveGState( cgContext );
 980
 981     m_graphicContext->SetPen( m_pen ) ;
 982     m_graphicContext->SetBrush( m_brush ) ;
 983
 984     m_clipping = false;
 985 }
 986
 987 void wxDC::DoGetSizeMM( int* width, int* height ) const
 988 {
 989     int w = 0, h = 0;
 990
 991     GetSize( &w, &h );
 992     if (width)
 993         *width = long( double(w) / (m_scaleX * m_mm_to_pix_x) );
 994     if (height)
 995         *height = long( double(h) / (m_scaleY * m_mm_to_pix_y) );
 996 }
 997
 998 void wxDC::SetTextForeground( const wxColour &col )
 999 {
1000     wxCHECK_RET( Ok(), wxT("wxDC(cg)::SetTextForeground - invalid DC") );
1001
1002     if ( col != m_textForegroundColour )
1003     {
1004         m_textForegroundColour = col;
1005         MacInstallFont() ;
1006     }
1007 }
1008
1009 void wxDC::SetTextBackground( const wxColour &col )
1010 {
1011     wxCHECK_RET( Ok(), wxT("wxDC(cg)::SetTextBackground - invalid DC") );
1012
1013     m_textBackgroundColour = col;
1014 }
1015
1016 void wxDC::SetMapMode( int mode )
1017 {
1018     switch (mode)
1019     {
1020     case wxMM_TWIPS:
1021         SetLogicalScale( twips2mm * m_mm_to_pix_x, twips2mm * m_mm_to_pix_y );
1022         break;
1023
1024     case wxMM_POINTS:
1025         SetLogicalScale( pt2mm * m_mm_to_pix_x, pt2mm * m_mm_to_pix_y );
1026         break;
1027
1028     case wxMM_METRIC:
1029         SetLogicalScale( m_mm_to_pix_x, m_mm_to_pix_y );
1030         break;
1031
1032     case wxMM_LOMETRIC:
1033         SetLogicalScale( m_mm_to_pix_x / 10.0, m_mm_to_pix_y / 10.0 );
1034         break;
1035
1036     case wxMM_TEXT:
1037     default:
1038         SetLogicalScale( 1.0, 1.0 );
1039         break;
1040     }
1041
1042     if (mode != wxMM_TEXT)
1043     {
1044         m_needComputeScaleX =
1045         m_needComputeScaleY = true;
1046     }
1047 }
1048
1049 void wxDC::SetUserScale( double x, double y )
1050 {
1051     // allow negative ? -> no
1052     m_userScaleX = x;
1053     m_userScaleY = y;
1054     ComputeScaleAndOrigin();
1055 }
1056
1057 void wxDC::SetLogicalScale( double x, double y )
1058 {
1059     // allow negative ?
1060     m_logicalScaleX = x;
1061     m_logicalScaleY = y;
1062     ComputeScaleAndOrigin();
1063 }
1064
1065 void wxDC::SetLogicalOrigin( wxCoord x, wxCoord y )
1066 {
1067     m_logicalOriginX = x * m_signX;   // is this still correct ?
1068     m_logicalOriginY = y * m_signY;
1069     ComputeScaleAndOrigin();
1070 }
1071
1072 void wxDC::SetDeviceOrigin( wxCoord x, wxCoord y )
1073 {
1074     m_externalDeviceOriginX = x;
1075     m_externalDeviceOriginY = y;
1076     ComputeScaleAndOrigin();
1077 }
1078
1079 void wxDC::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
1080 {
1081     m_signX = (xLeftRight ?  1 : -1);
1082     m_signY = (yBottomUp ? -1 :  1);
1083     ComputeScaleAndOrigin();
1084 }
1085
1086 wxSize wxDC::GetPPI() const
1087 {
1088     return wxSize(72, 72);
1089 }
1090
1091 int wxDC::GetDepth() const
1092 {
1093     return 32 ;
1094 }
1095
1096 void wxDC::ComputeScaleAndOrigin()
1097 {
1098     // CMB: copy scale to see if it changes
1099     double origScaleX = m_scaleX;
1100     double origScaleY = m_scaleY;
1101     m_scaleX = m_logicalScaleX * m_userScaleX;
1102     m_scaleY = m_logicalScaleY * m_userScaleY;
1103     m_deviceOriginX = m_externalDeviceOriginX;
1104     m_deviceOriginY = m_externalDeviceOriginY;
1105
1106     // CMB: if scale has changed call SetPen to recalulate the line width
1107     if (m_scaleX != origScaleX || m_scaleY != origScaleY)
1108     {
1109         // this is a bit artificial, but we need to force wxDC to think
1110         // the pen has changed
1111         wxPen pen( GetPen() );
1112
1113         m_pen = wxNullPen;
1114         SetPen(pen);
1115     }
1116 }
1117
1118 void wxDC::SetPalette( const wxPalette& palette )
1119 {
1120 }
1121
1122 void wxDC::SetBackgroundMode( int mode )
1123 {
1124     m_backgroundMode = mode ;
1125 }
1126
1127 void wxDC::SetFont( const wxFont &font )
1128 {
1129     m_font = font;
1130     MacInstallFont() ;
1131 }
1132
1133 void wxDC::SetPen( const wxPen &pen )
1134 {
1135     if ( m_pen == pen )
1136         return ;
1137
1138     m_pen = pen;
1139     if ( m_graphicContext )
1140     {
1141         if ( m_pen.GetStyle() == wxSOLID || m_pen.GetStyle() == wxTRANSPARENT )
1142         {
1143             m_graphicContext->SetPen( m_pen ) ;
1144         }
1145         else
1146         {
1147             // we have to compensate for moved device origins etc. otherwise patterned pens are standing still
1148             // eg when using a wxScrollWindow and scrolling around
1149             CGContextRef cgContext = ((wxMacCGContext*)(m_graphicContext))->GetNativeContext() ;
1150             int origX = XLOG2DEVMAC(0) ;
1151             int origY = YLOG2DEVMAC(0) ;
1152             CGContextTranslateCTM( cgContext, origX, origY );
1153             m_graphicContext->SetPen( m_pen ) ;
1154             CGContextTranslateCTM( cgContext, -origX, -origY );
1155         }
1156     }
1157 }
1158
1159 void wxDC::SetBrush( const wxBrush &brush )
1160 {
1161     if (m_brush == brush)
1162         return;
1163
1164     m_brush = brush;
1165     if ( m_graphicContext )
1166     {
1167         if ( brush.GetStyle() == wxSOLID || brush.GetStyle() == wxTRANSPARENT )
1168         {
1169             m_graphicContext->SetBrush( m_brush ) ;
1170         }
1171         else
1172         {
1173             // we have to compensate for moved device origins etc. otherwise patterned brushes are standing still
1174             // eg when using a wxScrollWindow and scrolling around
1175             CGContextRef cgContext = ((wxMacCGContext*)(m_graphicContext))->GetNativeContext() ;
1176             int origX = XLOG2DEVMAC(0) ;
1177             int origY = YLOG2DEVMAC(0) ;
1178             CGContextTranslateCTM( cgContext, origX, origY );
1179             m_graphicContext->SetBrush( m_brush ) ;
1180             CGContextTranslateCTM( cgContext, -origX, -origY );
1181         }
1182     }
1183 }
1184
1185 void wxDC::SetBackground( const wxBrush &brush )
1186 {
1187     if (m_backgroundBrush == brush)
1188         return;
1189
1190     m_backgroundBrush = brush;
1191     if (!m_backgroundBrush.Ok())
1192         return;
1193 }
1194
1195 void wxDC::SetLogicalFunction( int function )
1196 {
1197     if (m_logicalFunction == function)
1198         return;
1199
1200     m_logicalFunction = function ;
1201 #if wxMAC_USE_CORE_GRAPHICS_BLEND_MODES
1202     CGContextRef cgContext = ((wxMacCGContext*)(m_graphicContext))->GetNativeContext() ;
1203     if ( m_logicalFunction == wxCOPY )
1204         CGContextSetBlendMode( cgContext, kCGBlendModeNormal ) ;
1205     else if ( m_logicalFunction == wxINVERT )
1206         CGContextSetBlendMode( cgContext, kCGBlendModeExclusion ) ;
1207     else
1208         CGContextSetBlendMode( cgContext, kCGBlendModeNormal ) ;
1209 #endif
1210 }
1211
1212 extern bool wxDoFloodFill(wxDC *dc, wxCoord x, wxCoord y,
1213                           const wxColour & col, int style);
1214
1215 bool wxDC::DoFloodFill(wxCoord x, wxCoord y,
1216                        const wxColour& col, int style)
1217 {
1218     return wxDoFloodFill(this, x, y, col, style);
1219 }
1220
1221 bool wxDC::DoGetPixel( wxCoord x, wxCoord y, wxColour *col ) const
1222 {
1223     wxCHECK_MSG( Ok(), false, wxT("wxDC(cg)::DoGetPixel - invalid DC") );
1224
1225     wxMacPortSaver helper((CGrafPtr)m_macPort) ;
1226     RGBColor colour;
1227
1228     // NB: GetCPixel is a deprecated QD call, and a slow one at that
1229     GetCPixel(
1230         XLOG2DEVMAC(x) + m_macLocalOriginInPort.x - m_macLocalOrigin.x,
1231         YLOG2DEVMAC(y) + m_macLocalOriginInPort.y - m_macLocalOrigin.y, &colour );
1232
1233     // convert from Mac colour to wx
1234     col->Set( colour.red >> 8, colour.green >> 8, colour.blue >> 8 );
1235
1236     return true ;
1237 }
1238
1239 void wxDC::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 )
1240 {
1241     wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoDrawLine - invalid DC") );
1242
1243 #if !wxMAC_USE_CORE_GRAPHICS_BLEND_MODES
1244     if ( m_logicalFunction != wxCOPY )
1245         return ;
1246 #endif
1247
1248     wxCoord xx1 = XLOG2DEVMAC(x1) ;
1249     wxCoord yy1 = YLOG2DEVMAC(y1) ;
1250     wxCoord xx2 = XLOG2DEVMAC(x2) ;
1251     wxCoord yy2 = YLOG2DEVMAC(y2) ;
1252
1253     wxGraphicPath* path = m_graphicContext->CreatePath() ;
1254     path->MoveToPoint( xx1, yy1 ) ;
1255     path->AddLineToPoint( xx2 , yy2 ) ;
1256     path->CloseSubpath() ;
1257     m_graphicContext->StrokePath( path ) ;
1258     delete path ;
1259
1260     CalcBoundingBox(x1, y1);
1261     CalcBoundingBox(x2, y2);
1262 }
1263
1264 void wxDC::DoCrossHair( wxCoord x, wxCoord y )
1265 {
1266     wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoCrossHair - invalid DC") );
1267
1268     if ( m_logicalFunction != wxCOPY )
1269         return ;
1270
1271     int w = 0, h = 0;
1272
1273     GetSize( &w, &h );
1274     wxCoord xx = XLOG2DEVMAC(x);
1275     wxCoord yy = YLOG2DEVMAC(y);
1276
1277     wxGraphicPath* path = m_graphicContext->CreatePath() ;
1278     path->MoveToPoint( XLOG2DEVMAC(0), yy ) ;
1279     path->AddLineToPoint( XLOG2DEVMAC(w), yy ) ;
1280     path->CloseSubpath() ;
1281     path->MoveToPoint( xx, YLOG2DEVMAC(0) ) ;
1282     path->AddLineToPoint( xx, YLOG2DEVMAC(h) ) ;
1283     path->CloseSubpath() ;
1284     m_graphicContext->StrokePath( path ) ;
1285     delete path ;
1286
1287     CalcBoundingBox(x, y);
1288     CalcBoundingBox(x + w, y + h);
1289 }
1290
1291 void wxDC::DoDrawArc( wxCoord x1, wxCoord y1,
1292                       wxCoord x2, wxCoord y2,
1293                       wxCoord xc, wxCoord yc )
1294 {
1295     wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoDrawArc - invalid DC") );
1296
1297     if ( m_logicalFunction != wxCOPY )
1298         return ;
1299
1300     wxCoord xx1 = XLOG2DEVMAC(x1);
1301     wxCoord yy1 = YLOG2DEVMAC(y1);
1302     wxCoord xx2 = XLOG2DEVMAC(x2);
1303     wxCoord yy2 = YLOG2DEVMAC(y2);
1304     wxCoord xxc = XLOG2DEVMAC(xc);
1305     wxCoord yyc = YLOG2DEVMAC(yc);
1306
1307     double dx = xx1 - xxc;
1308     double dy = yy1 - yyc;
1309     double radius = sqrt((double)(dx * dx + dy * dy));
1310     wxCoord rad = (wxCoord)radius;
1311     double sa, ea;
1312     if (xx1 == xx2 && yy1 == yy2)
1313     {
1314         sa = 0.0;
1315         ea = 360.0;
1316     }
1317     else if (radius == 0.0)
1318     {
1319         sa = ea = 0.0;
1320     }
1321     else
1322     {
1323         sa = (xx1 - xxc == 0) ?
1324             (yy1 - yyc < 0) ? 90.0 : -90.0 :
1325         -atan2(double(yy1 - yyc), double(xx1 - xxc)) * RAD2DEG;
1326         ea = (xx2 - xxc == 0) ?
1327             (yy2 - yyc < 0) ? 90.0 : -90.0 :
1328         -atan2(double(yy2 - yyc), double(xx2 - xxc)) * RAD2DEG;
1329     }
1330
1331     bool fill = m_brush.GetStyle() != wxTRANSPARENT ;
1332     wxMacCGContext* mctx = ((wxMacCGContext*) m_graphicContext) ;
1333     CGContextRef ctx = mctx->GetNativeContext() ;
1334     CGContextSaveGState( ctx ) ;
1335     CGContextTranslateCTM( ctx, xxc , yyc );
1336     CGContextScaleCTM( ctx , 1 , -1 ) ;
1337     if ( fill )
1338         CGContextMoveToPoint( ctx , 0 , 0 ) ;
1339     CGContextAddArc( ctx, 0, 0 , rad , DegToRad(sa), DegToRad(ea), 0 );
1340     if ( fill )
1341         CGContextAddLineToPoint( ctx , 0 , 0 ) ;
1342     CGContextRestoreGState( ctx ) ;
1343     CGContextDrawPath( ctx , mctx->GetDrawingMode() ) ;
1344 }
1345
1346 void wxDC::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord w, wxCoord h,
1347                               double sa, double ea )
1348 {
1349     wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoDrawEllipticArc - invalid DC") );
1350
1351     if ( m_logicalFunction != wxCOPY )
1352         return ;
1353
1354     wxCoord xx = XLOG2DEVMAC(x);
1355     wxCoord yy = YLOG2DEVMAC(y);
1356     wxCoord ww = m_signX * XLOG2DEVREL(w);
1357     wxCoord hh = m_signY * YLOG2DEVREL(h);
1358
1359     // handle -ve width and/or height
1360     if (ww < 0)
1361     {
1362         ww = -ww;
1363         xx = xx - ww;
1364     }
1365     if (hh < 0)
1366     {
1367         hh = -hh;
1368         yy = yy - hh;
1369     }
1370
1371     bool fill = m_brush.GetStyle() != wxTRANSPARENT ;
1372
1373     wxMacCGContext* mctx = ((wxMacCGContext*) m_graphicContext) ;
1374     CGContextRef ctx = mctx->GetNativeContext() ;
1375
1376     CGContextSaveGState( ctx ) ;
1377     CGContextTranslateCTM( ctx, xx + ww / 2, yy + hh / 2 );
1378     CGContextScaleCTM( ctx , 1 * ww / 2 , -1 * hh / 2 ) ;
1379     if ( fill )
1380         CGContextMoveToPoint( ctx , 0 , 0 ) ;
1381     CGContextAddArc( ctx, 0, 0, 1, DegToRad(sa), DegToRad(ea), 0 );
1382     if ( fill )
1383         CGContextAddLineToPoint( ctx , 0 , 0 ) ;
1384     CGContextRestoreGState( ctx ) ;
1385     CGContextDrawPath( ctx , mctx->GetDrawingMode() ) ;
1386 }
1387
1388 void wxDC::DoDrawPoint( wxCoord x, wxCoord y )
1389 {
1390     wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoDrawPoint - invalid DC") );
1391
1392     DoDrawLine( x , y , x + 1 , y + 1 ) ;
1393 }
1394
1395 void wxDC::DoDrawLines(int n, wxPoint points[],
1396                         wxCoord xoffset, wxCoord yoffset)
1397 {
1398     wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoDrawLines - invalid DC") );
1399
1400 #if !wxMAC_USE_CORE_GRAPHICS_BLEND_MODES
1401     if ( m_logicalFunction != wxCOPY )
1402         return ;
1403 #endif
1404
1405     wxCoord x1, x2 , y1 , y2 ;
1406     x1 = XLOG2DEVMAC(points[0].x + xoffset);
1407     y1 = YLOG2DEVMAC(points[0].y + yoffset);
1408     wxGraphicPath* path = m_graphicContext->CreatePath() ;
1409     path->MoveToPoint( x1 , y1 ) ;
1410     for (int i = 1; i < n; i++)
1411     {
1412         x2 = XLOG2DEVMAC(points[i].x + xoffset);
1413         y2 = YLOG2DEVMAC(points[i].y + yoffset);
1414
1415         path->AddLineToPoint( x2 , y2 ) ;
1416     }
1417
1418     m_graphicContext->StrokePath( path ) ;
1419     delete path ;
1420 }
1421
1422 #if wxUSE_SPLINES
1423 void wxDC::DoDrawSpline(wxList *points)
1424 {
1425     wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoDrawSpline - invalid DC") );
1426
1427     if ( m_logicalFunction != wxCOPY )
1428         return ;
1429
1430     wxGraphicPath* path = m_graphicContext->CreatePath() ;
1431
1432     wxList::compatibility_iterator node = points->GetFirst();
1433     if (node == wxList::compatibility_iterator())
1434         // empty list
1435         return;
1436
1437     wxPoint *p = (wxPoint *)node->GetData();
1438
1439     wxCoord x1 = p->x;
1440     wxCoord y1 = p->y;
1441
1442     node = node->GetNext();
1443     p = (wxPoint *)node->GetData();
1444
1445     wxCoord x2 = p->x;
1446     wxCoord y2 = p->y;
1447     wxCoord cx1 = ( x1 + x2 ) / 2;
1448     wxCoord cy1 = ( y1 + y2 ) / 2;
1449
1450     path->MoveToPoint( XLOG2DEVMAC( x1 ) , XLOG2DEVMAC( y1 ) ) ;
1451     path->AddLineToPoint( XLOG2DEVMAC( cx1 ) , XLOG2DEVMAC( cy1 ) ) ;
1452
1453 #if !wxUSE_STL
1454     while ((node = node->GetNext()) != NULL)
1455 #else
1456     while ((node = node->GetNext()))
1457 #endif // !wxUSE_STL
1458     {
1459         p = (wxPoint *)node->GetData();
1460         x1 = x2;
1461         y1 = y2;
1462         x2 = p->x;
1463         y2 = p->y;
1464         wxCoord cx4 = (x1 + x2) / 2;
1465         wxCoord cy4 = (y1 + y2) / 2;
1466
1467         path->AddQuadCurveToPoint( XLOG2DEVMAC( x1 ) , XLOG2DEVMAC( y1 ) ,
1468                                    XLOG2DEVMAC( cx4 ) , XLOG2DEVMAC( cy4 ) ) ;
1469
1470         cx1 = cx4;
1471         cy1 = cy4;
1472     }
1473
1474     path->AddLineToPoint( XLOG2DEVMAC( x2 ) , XLOG2DEVMAC( y2 ) ) ;
1475
1476     m_graphicContext->StrokePath( path ) ;
1477     delete path ;
1478 }
1479 #endif
1480
1481 void wxDC::DoDrawPolygon( int n, wxPoint points[],
1482                           wxCoord xoffset, wxCoord yoffset,
1483                           int fillStyle )
1484 {
1485     wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoDrawPolygon - invalid DC") );
1486
1487     if ( n <= 0 || (m_brush.GetStyle() == wxTRANSPARENT && m_pen.GetStyle() == wxTRANSPARENT ) )
1488         return ;
1489     if ( m_logicalFunction != wxCOPY )
1490         return ;
1491
1492     wxCoord x1, x2 , y1 , y2 ;
1493     x2 = x1 = XLOG2DEVMAC(points[0].x + xoffset);
1494     y2 = y1 = YLOG2DEVMAC(points[0].y + yoffset);
1495
1496     wxGraphicPath* path = m_graphicContext->CreatePath() ;
1497     path->MoveToPoint( x1 , y1 ) ;
1498     for (int i = 1; i < n; i++)
1499     {
1500         x2 = XLOG2DEVMAC(points[i].x + xoffset);
1501         y2 = YLOG2DEVMAC(points[i].y + yoffset);
1502
1503         path->AddLineToPoint( x2 , y2 ) ;
1504     }
1505
1506     if ( x1 != x2 || y1 != y2 )
1507         path->AddLineToPoint( x1, y1 ) ;
1508
1509     path->CloseSubpath() ;
1510     m_graphicContext->DrawPath( path , fillStyle ) ;
1511
1512     delete path ;
1513 }
1514
1515 void wxDC::DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
1516 {
1517     wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoDrawRectangle - invalid DC") );
1518
1519     if ( m_logicalFunction != wxCOPY )
1520         return ;
1521
1522     wxCoord xx = XLOG2DEVMAC(x);
1523     wxCoord yy = YLOG2DEVMAC(y);
1524     wxCoord ww = m_signX * XLOG2DEVREL(width);
1525     wxCoord hh = m_signY * YLOG2DEVREL(height);
1526
1527     // CMB: draw nothing if transformed w or h is 0
1528     if (ww == 0 || hh == 0)
1529         return;
1530
1531     // CMB: handle -ve width and/or height
1532     if (ww < 0)
1533     {
1534         ww = -ww;
1535         xx = xx - ww;
1536     }
1537     if (hh < 0)
1538     {
1539         hh = -hh;
1540         yy = yy - hh;
1541     }
1542
1543     wxGraphicPath* path = m_graphicContext->CreatePath() ;
1544     path->AddRectangle( xx , yy , ww , hh ) ;
1545     m_graphicContext->DrawPath( path ) ;
1546     delete path ;
1547 }
1548
1549 void wxDC::DoDrawRoundedRectangle(wxCoord x, wxCoord y,
1550                                    wxCoord width, wxCoord height,
1551                                    double radius)
1552 {
1553     wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoDrawRoundedRectangle - invalid DC") );
1554
1555     if ( m_logicalFunction != wxCOPY )
1556         return ;
1557
1558     if (radius < 0.0)
1559         radius = - radius * ((width < height) ? width : height);
1560     wxCoord xx = XLOG2DEVMAC(x);
1561     wxCoord yy = YLOG2DEVMAC(y);
1562     wxCoord ww = m_signX * XLOG2DEVREL(width);
1563     wxCoord hh = m_signY * YLOG2DEVREL(height);
1564
1565     // CMB: draw nothing if transformed w or h is 0
1566     if (ww == 0 || hh == 0)
1567         return;
1568
1569     // CMB: handle -ve width and/or height
1570     if (ww < 0)
1571     {
1572         ww = -ww;
1573         xx = xx - ww;
1574     }
1575     if (hh < 0)
1576     {
1577         hh = -hh;
1578         yy = yy - hh;
1579     }
1580
1581     wxMacCGContext* mctx = ((wxMacCGContext*) m_graphicContext) ;
1582     CGContextRef ctx = mctx->GetNativeContext() ;
1583     AddRoundedRectToPath( ctx , CGRectMake( xx , yy , ww , hh ) , 16 ,16  ) ;
1584     CGContextDrawPath( ctx , mctx->GetDrawingMode() ) ;
1585 }
1586
1587 void wxDC::DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
1588 {
1589     wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoDrawEllipse - invalid DC") );
1590
1591     if ( m_logicalFunction != wxCOPY )
1592         return ;
1593
1594     wxCoord xx = XLOG2DEVMAC(x);
1595     wxCoord yy = YLOG2DEVMAC(y);
1596     wxCoord ww = m_signX * XLOG2DEVREL(width);
1597     wxCoord hh = m_signY * YLOG2DEVREL(height);
1598     // CMB: draw nothing if transformed w or h is 0
1599     if (ww == 0 || hh == 0)
1600         return;
1601
1602     // CMB: handle -ve width and/or height
1603     if (ww < 0)
1604     {
1605         ww = -ww;
1606         xx = xx - ww;
1607     }
1608     if (hh < 0)
1609     {
1610         hh = -hh;
1611         yy = yy - hh;
1612     }
1613
1614     wxMacCGContext* mctx = ((wxMacCGContext*) m_graphicContext) ;
1615     CGContextRef ctx = mctx->GetNativeContext() ;
1616     CGContextSaveGState( ctx ) ;
1617     CGContextTranslateCTM( ctx, xx + ww / 2, yy + hh / 2 );
1618     CGContextScaleCTM( ctx , ww / 2 , hh / 2 ) ;
1619     CGContextAddArc( ctx, 0, 0, 1, 0 , 2 * M_PI , 0 );
1620     CGContextRestoreGState( ctx ) ;
1621     CGContextDrawPath( ctx , mctx->GetDrawingMode() ) ;
1622 }
1623
1624 bool wxDC::CanDrawBitmap(void) const
1625 {
1626     return true ;
1627 }
1628
1629 bool wxDC::DoBlit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
1630                    wxDC *source, wxCoord xsrc, wxCoord ysrc, int logical_func , bool useMask,
1631                    wxCoord xsrcMask, wxCoord ysrcMask )
1632 {
1633     wxCHECK_MSG( Ok(), false, wxT("wxDC(cg)::DoBlit - invalid DC") );
1634     wxCHECK_MSG( source->Ok(), false, wxT("wxDC(cg)::DoBlit - invalid source DC") );
1635
1636     if ( logical_func == wxNO_OP )
1637         return true ;
1638
1639     if (xsrcMask == -1 && ysrcMask == -1)
1640     {
1641         xsrcMask = xsrc;
1642         ysrcMask = ysrc;
1643     }
1644
1645     wxCoord yysrc = source->YLOG2DEVMAC(ysrc) ;
1646     wxCoord xxsrc = source->XLOG2DEVMAC(xsrc) ;
1647     wxCoord wwsrc = source->XLOG2DEVREL(width) ;
1648     wxCoord hhsrc = source->YLOG2DEVREL(height) ;
1649
1650     wxCoord yydest = YLOG2DEVMAC(ydest) ;
1651     wxCoord xxdest = XLOG2DEVMAC(xdest) ;
1652     wxCoord wwdest = XLOG2DEVREL(width) ;
1653     wxCoord hhdest = YLOG2DEVREL(height) ;
1654
1655     wxMemoryDC* memdc = dynamic_cast<wxMemoryDC*>(source) ;
1656     if ( memdc && logical_func == wxCOPY )
1657     {
1658         wxBitmap blit = memdc->GetSelectedObject() ;
1659
1660         wxASSERT_MSG( blit.Ok() , wxT("Invalid bitmap for blitting") ) ;
1661
1662         wxCoord bmpwidth = blit.GetWidth();
1663         wxCoord bmpheight = blit.GetHeight();
1664
1665         if ( xxsrc != 0 || yysrc != 0 || bmpwidth != wwsrc || bmpheight != hhsrc )
1666         {
1667             wwsrc = wxMin( wwsrc , bmpwidth - xxsrc ) ;
1668             hhsrc = wxMin( hhsrc , bmpheight - yysrc ) ;
1669             if ( wwsrc > 0 && hhsrc > 0 )
1670             {
1671                 if ( xxsrc >= 0 && yysrc >= 0 )
1672                 {
1673                     wxRect subrect( xxsrc, yysrc, wwsrc , hhsrc ) ;
1674                     blit = blit.GetSubBitmap( subrect ) ;
1675                 }
1676                 else
1677                 {
1678                     // in this case we'd probably have to adjust the different coordinates, but
1679                     // we have to find out proper contract first
1680                     blit = wxNullBitmap ;
1681                 }
1682             }
1683             else
1684             {
1685                 blit = wxNullBitmap ;
1686             }
1687         }
1688
1689         if ( blit.Ok() )
1690         {
1691             CGContextRef cg = ((wxMacCGContext*)(m_graphicContext))->GetNativeContext() ;
1692             CGImageRef image = (CGImageRef)( blit.CGImageCreate() ) ;
1693             HIRect r = CGRectMake( xxdest , yydest , wwdest , hhdest ) ;
1694             HIViewDrawCGImage( cg , &r , image ) ;
1695             CGImageRelease( image ) ;
1696         }
1697     }
1698     else
1699     {
1700 #if 0
1701         CGContextRef cg = (wxMacCGContext*)(source->GetGraphicContext())->GetNativeContext() ;
1702         void *data = CGBitmapContextGetData( cg ) ;
1703 #endif
1704
1705         return false ; // wxFAIL_MSG( wxT("Blitting is only supported from bitmap contexts") ) ;
1706     }
1707
1708     return true;
1709 }
1710
1711 void wxDC::DoDrawRotatedText(const wxString& str, wxCoord x, wxCoord y,
1712                               double angle)
1713 {
1714     wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoDrawRotatedText - invalid DC") );
1715     wxCHECK_RET( m_macATSUIStyle != NULL, wxT("wxDC(cg)::DoDrawRotatedText - no valid font set") );
1716
1717     if ( str.Length() == 0 )
1718         return ;
1719     if ( m_logicalFunction != wxCOPY )
1720         return ;
1721
1722     OSStatus status = noErr ;
1723     ATSUTextLayout atsuLayout ;
1724     UniCharCount chars = str.Length() ;
1725     UniChar* ubuf = NULL ;
1726
1727 #if SIZEOF_WCHAR_T == 4
1728     wxMBConvUTF16 converter ;
1729 #if wxUSE_UNICODE
1730     size_t unicharlen = converter.WC2MB( NULL , str.wc_str() , 0 ) ;
1731     ubuf = (UniChar*) malloc( unicharlen + 2 ) ;
1732     converter.WC2MB( (char*) ubuf , str.wc_str(), unicharlen + 2 ) ;
1733 #else
1734     const wxWCharBuffer wchar = str.wc_str( wxConvLocal ) ;
1735     size_t unicharlen = converter.WC2MB( NULL , wchar.data() , 0 ) ;
1736     ubuf = (UniChar*) malloc( unicharlen + 2 ) ;
1737     converter.WC2MB( (char*) ubuf , wchar.data() , unicharlen + 2 ) ;
1738 #endif
1739     chars = unicharlen / 2 ;
1740 #else
1741 #if wxUSE_UNICODE
1742     ubuf = (UniChar*) str.wc_str() ;
1743 #else
1744     wxWCharBuffer wchar = str.wc_str( wxConvLocal ) ;
1745     chars = wxWcslen( wchar.data() ) ;
1746     ubuf = (UniChar*) wchar.data() ;
1747 #endif
1748 #endif
1749
1750     int drawX = XLOG2DEVMAC(x) ;
1751     int drawY = YLOG2DEVMAC(y) ;
1752
1753     status = ::ATSUCreateTextLayoutWithTextPtr( (UniCharArrayPtr) ubuf , 0 , chars , chars , 1 ,
1754         &chars , (ATSUStyle*) &m_macATSUIStyle , &atsuLayout ) ;
1755
1756     wxASSERT_MSG( status == noErr , wxT("couldn't create the layout of the rotated text") );
1757
1758     status = ::ATSUSetTransientFontMatching( atsuLayout , true ) ;
1759     wxASSERT_MSG( status == noErr , wxT("couldn't setup transient font matching") );
1760
1761     int iAngle = int( angle );
1762     if ( abs(iAngle) > 0 )
1763     {
1764         Fixed atsuAngle = IntToFixed( iAngle ) ;
1765         ATSUAttributeTag atsuTags[] =
1766         {
1767             kATSULineRotationTag ,
1768         } ;
1769         ByteCount atsuSizes[sizeof(atsuTags) / sizeof(ATSUAttributeTag)] =
1770         {
1771             sizeof( Fixed ) ,
1772         } ;
1773         ATSUAttributeValuePtr    atsuValues[sizeof(atsuTags) / sizeof(ATSUAttributeTag)] =
1774         {
1775             &atsuAngle ,
1776         } ;
1777         status = ::ATSUSetLayoutControls(atsuLayout , sizeof(atsuTags) / sizeof(ATSUAttributeTag),
1778             atsuTags, atsuSizes, atsuValues ) ;
1779     }
1780
1781     {
1782         CGContextRef cgContext = ((wxMacCGContext*)(m_graphicContext))->GetNativeContext() ;
1783         ATSUAttributeTag atsuTags[] =
1784         {
1785             kATSUCGContextTag ,
1786         } ;
1787         ByteCount atsuSizes[sizeof(atsuTags) / sizeof(ATSUAttributeTag)] =
1788         {
1789             sizeof( CGContextRef ) ,
1790         } ;
1791         ATSUAttributeValuePtr    atsuValues[sizeof(atsuTags) / sizeof(ATSUAttributeTag)] =
1792         {
1793             &cgContext ,
1794         } ;
1795         status = ::ATSUSetLayoutControls(atsuLayout , sizeof(atsuTags) / sizeof(ATSUAttributeTag),
1796             atsuTags, atsuSizes, atsuValues ) ;
1797     }
1798
1799     ATSUTextMeasurement textBefore, textAfter ;
1800     ATSUTextMeasurement ascent, descent ;
1801
1802     status = ::ATSUGetUnjustifiedBounds( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd,
1803         &textBefore , &textAfter, &ascent , &descent );
1804
1805     wxASSERT_MSG( status == noErr , wxT("couldn't measure the rotated text") );
1806
1807     Rect rect ;
1808
1809     if ( m_backgroundMode == wxSOLID )
1810     {
1811         wxGraphicPath* path = m_graphicContext->CreatePath() ;
1812         path->MoveToPoint(
1813             drawX ,
1814             drawY ) ;
1815         path->AddLineToPoint(
1816             (int) (drawX + sin(angle / RAD2DEG) * FixedToInt(ascent + descent)) ,
1817             (int) (drawY + cos(angle / RAD2DEG) * FixedToInt(ascent + descent)) ) ;
1818         path->AddLineToPoint(
1819             (int) (drawX + sin(angle / RAD2DEG) * FixedToInt(ascent + descent ) + cos(angle / RAD2DEG) * FixedToInt(textAfter)) ,
1820             (int) (drawY + cos(angle / RAD2DEG) * FixedToInt(ascent + descent) - sin(angle / RAD2DEG) * FixedToInt(textAfter)) ) ;
1821         path->AddLineToPoint(
1822             (int) (drawX + cos(angle / RAD2DEG) * FixedToInt(textAfter)) ,
1823             (int) (drawY - sin(angle / RAD2DEG) * FixedToInt(textAfter)) ) ;
1824
1825         m_graphicContext->FillPath( path , m_textBackgroundColour ) ;
1826         delete path ;
1827     }
1828
1829     drawX += (int)(sin(angle / RAD2DEG) * FixedToInt(ascent));
1830     drawY += (int)(cos(angle / RAD2DEG) * FixedToInt(ascent));
1831
1832     status = ::ATSUMeasureTextImage( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd,
1833         IntToFixed(drawX) , IntToFixed(drawY) , &rect );
1834     wxASSERT_MSG( status == noErr , wxT("couldn't measure the rotated text") );
1835
1836     CGContextSaveGState(((wxMacCGContext*)(m_graphicContext))->GetNativeContext());
1837     CGContextTranslateCTM(((wxMacCGContext*)(m_graphicContext))->GetNativeContext(), drawX, drawY);
1838     CGContextScaleCTM(((wxMacCGContext*)(m_graphicContext))->GetNativeContext(), 1, -1);
1839     status = ::ATSUDrawText( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd,
1840         IntToFixed(0) , IntToFixed(0) );
1841
1842     wxASSERT_MSG( status == noErr , wxT("couldn't draw the rotated text") );
1843
1844     CGContextRestoreGState( ((wxMacCGContext*)(m_graphicContext))->GetNativeContext() ) ;
1845
1846     CalcBoundingBox(XDEV2LOG(rect.left), YDEV2LOG(rect.top) );
1847     CalcBoundingBox(XDEV2LOG(rect.right), YDEV2LOG(rect.bottom) );
1848
1849     ::ATSUDisposeTextLayout(atsuLayout);
1850
1851 #if SIZEOF_WCHAR_T == 4
1852     free( ubuf ) ;
1853 #endif
1854 }
1855
1856 void wxDC::DoDrawText(const wxString& strtext, wxCoord x, wxCoord y)
1857 {
1858     wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoDrawText - invalid DC") );
1859
1860     DoDrawRotatedText( strtext , x , y , 0.0 ) ;
1861 }
1862
1863 bool wxDC::CanGetTextExtent() const
1864 {
1865     wxCHECK_MSG( Ok(), false, wxT("wxDC(cg)::CanGetTextExtent - invalid DC") );
1866
1867     return true ;
1868 }
1869
1870 void wxDC::DoGetTextExtent( const wxString &str, wxCoord *width, wxCoord *height,
1871                             wxCoord *descent, wxCoord *externalLeading ,
1872                             wxFont *theFont ) const
1873 {
1874     wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoGetTextExtent - invalid DC") );
1875
1876     wxFont formerFont = m_font ;
1877     if ( theFont )
1878     {
1879         // work around the const-ness
1880         *((wxFont*)(&m_font)) = *theFont ;
1881         MacInstallFont() ;
1882     }
1883
1884     if ( str.Length() == 0 )
1885         return ;
1886
1887     wxCHECK_RET( m_macATSUIStyle != NULL, wxT("wxDC(cg)::DoGetTextExtent - no valid font set") ) ;
1888
1889     OSStatus status = noErr ;
1890     ATSUTextLayout atsuLayout ;
1891     UniCharCount chars = str.Length() ;
1892     UniChar* ubuf = NULL ;
1893
1894 #if SIZEOF_WCHAR_T == 4
1895     wxMBConvUTF16 converter ;
1896 #if wxUSE_UNICODE
1897     size_t unicharlen = converter.WC2MB( NULL , str.wc_str() , 0 ) ;
1898     ubuf = (UniChar*) malloc( unicharlen + 2 ) ;
1899     converter.WC2MB( (char*) ubuf , str.wc_str(), unicharlen + 2 ) ;
1900 #else
1901     const wxWCharBuffer wchar = str.wc_str( wxConvLocal ) ;
1902     size_t unicharlen = converter.WC2MB( NULL , wchar.data() , 0 ) ;
1903     ubuf = (UniChar*) malloc( unicharlen + 2 ) ;
1904     converter.WC2MB( (char*) ubuf , wchar.data() , unicharlen + 2 ) ;
1905 #endif
1906     chars = unicharlen / 2 ;
1907 #else
1908 #if wxUSE_UNICODE
1909     ubuf = (UniChar*) str.wc_str() ;
1910 #else
1911     wxWCharBuffer wchar = str.wc_str( wxConvLocal ) ;
1912     chars = wxWcslen( wchar.data() ) ;
1913     ubuf = (UniChar*) wchar.data() ;
1914 #endif
1915 #endif
1916
1917     status = ::ATSUCreateTextLayoutWithTextPtr( (UniCharArrayPtr) ubuf , 0 , chars , chars , 1 ,
1918         &chars , (ATSUStyle*) &m_macATSUIStyle , &atsuLayout ) ;
1919
1920     wxASSERT_MSG( status == noErr , wxT("couldn't create the layout of the text") );
1921
1922     ATSUTextMeasurement textBefore, textAfter ;
1923     ATSUTextMeasurement textAscent, textDescent ;
1924
1925     status = ::ATSUGetUnjustifiedBounds( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd,
1926         &textBefore , &textAfter, &textAscent , &textDescent );
1927
1928     if ( height )
1929         *height = YDEV2LOGREL( FixedToInt(textAscent + textDescent) ) ;
1930     if ( descent )
1931         *descent =YDEV2LOGREL( FixedToInt(textDescent) );
1932     if ( externalLeading )
1933         *externalLeading = 0 ;
1934     if ( width )
1935         *width = XDEV2LOGREL( FixedToInt(textAfter - textBefore) ) ;
1936
1937     ::ATSUDisposeTextLayout(atsuLayout);
1938
1939 #if SIZEOF_WCHAR_T == 4
1940     free( ubuf ) ;
1941 #endif
1942
1943     if ( theFont )
1944     {
1945         // work around the constness
1946         *((wxFont*)(&m_font)) = formerFont ;
1947         MacInstallFont() ;
1948     }
1949 }
1950
1951 bool wxDC::DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const
1952 {
1953     wxCHECK_MSG( Ok(), false, wxT("wxDC(cg)::DoGetPartialTextExtents - invalid DC") );
1954
1955     widths.Empty();
1956     widths.Add(0, text.Length());
1957
1958     if (text.Length() == 0)
1959         return false;
1960
1961     ATSUTextLayout atsuLayout ;
1962     UniCharCount chars = text.Length() ;
1963     UniChar* ubuf = NULL ;
1964
1965 #if SIZEOF_WCHAR_T == 4
1966     wxMBConvUTF16 converter ;
1967 #if wxUSE_UNICODE
1968     size_t unicharlen = converter.WC2MB( NULL , text.wc_str() , 0 ) ;
1969     ubuf = (UniChar*) malloc( unicharlen + 2 ) ;
1970     converter.WC2MB( (char*) ubuf , text.wc_str(), unicharlen + 2 ) ;
1971 #else
1972     const wxWCharBuffer wchar = text.wc_str( wxConvLocal ) ;
1973     size_t unicharlen = converter.WC2MB( NULL , wchar.data() , 0 ) ;
1974     ubuf = (UniChar*) malloc( unicharlen + 2 ) ;
1975     converter.WC2MB( (char*) ubuf , wchar.data() , unicharlen + 2 ) ;
1976 #endif
1977     chars = unicharlen / 2 ;
1978 #else
1979 #if wxUSE_UNICODE
1980     ubuf = (UniChar*) text.wc_str() ;
1981 #else
1982     wxWCharBuffer wchar = text.wc_str( wxConvLocal ) ;
1983     chars = wxWcslen( wchar.data() ) ;
1984     ubuf = (UniChar*) wchar.data() ;
1985 #endif
1986 #endif
1987
1988     OSStatus status;
1989     status = ::ATSUCreateTextLayoutWithTextPtr( (UniCharArrayPtr) ubuf , 0 , chars , chars , 1 ,
1990         &chars , (ATSUStyle*) &m_macATSUIStyle , &atsuLayout ) ;
1991
1992     for ( int pos = 0; pos < (int)chars; pos ++ )
1993     {
1994         unsigned long actualNumberOfBounds = 0;
1995         ATSTrapezoid glyphBounds;
1996
1997         // We get a single bound, since the text should only require one. If it requires more, there is an issue
1998         OSStatus result;
1999         result = ATSUGetGlyphBounds( atsuLayout, 0, 0, kATSUFromTextBeginning, pos + 1,
2000             kATSUseDeviceOrigins, 1, &glyphBounds, &actualNumberOfBounds );
2001         if (result != noErr || actualNumberOfBounds != 1 )
2002             return false;
2003
2004         widths[pos] = XDEV2LOGREL(FixedToInt( glyphBounds.upperRight.x - glyphBounds.upperLeft.x ));
2005         //unsigned char uch = s[i];
2006     }
2007
2008     ::ATSUDisposeTextLayout(atsuLayout);
2009     return true;
2010 }
2011
2012 wxCoord wxDC::GetCharWidth(void) const
2013 {
2014     wxCoord width ;
2015     DoGetTextExtent( wxT("g") , &width , NULL , NULL , NULL , NULL ) ;
2016
2017     return width ;
2018 }
2019
2020 wxCoord wxDC::GetCharHeight(void) const
2021 {
2022     wxCoord height ;
2023     DoGetTextExtent( wxT("g") , NULL , &height , NULL , NULL , NULL ) ;
2024
2025     return height ;
2026 }
2027
2028 void wxDC::Clear(void)
2029 {
2030     wxCHECK_RET( Ok(), wxT("wxDC(cg)::Clear - invalid DC") );
2031
2032     if (m_backgroundBrush.Ok() && m_backgroundBrush.GetStyle() != wxTRANSPARENT)
2033     {
2034         HIRect rect = CGRectMake( -10000 , -10000 , 20000 , 20000 ) ;
2035         CGContextRef cg = ((wxMacCGContext*)(m_graphicContext))->GetNativeContext() ;
2036         switch ( m_backgroundBrush.MacGetBrushKind() )
2037         {
2038             case kwxMacBrushTheme :
2039                 {
2040 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4
2041                     if ( HIThemeSetFill != 0 )
2042                     {
2043                         HIThemeSetFill( m_backgroundBrush.MacGetTheme(), NULL, cg, kHIThemeOrientationNormal );
2044                         CGContextFillRect(cg, rect);
2045
2046                     }
2047                     else
2048 #endif
2049                     {
2050                         RGBColor color;
2051                         GetThemeBrushAsColor( m_backgroundBrush.MacGetTheme(), 32, true, &color );
2052                         CGContextSetRGBFillColor( cg, (float) color.red / 65536,
2053                             (float) color.green / 65536, (float) color.blue / 65536, 1 );
2054                             CGContextFillRect( cg, rect );
2055                     }
2056
2057                     // reset to normal value
2058                     RGBColor col = MAC_WXCOLORREF( GetBrush().GetColour().GetPixel() ) ;
2059                     CGContextSetRGBFillColor( cg, col.red / 65536.0, col.green / 65536.0, col.blue / 65536.0, 1.0 );
2060                 }
2061                 break ;
2062
2063             case kwxMacBrushThemeBackground :
2064                 {
2065                     wxFAIL_MSG( wxT("There shouldn't be theme backgrounds under Quartz") ) ;
2066
2067 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_3
2068                     if ( UMAGetSystemVersion() >= 0x1030 )
2069                     {
2070                         HIThemeBackgroundDrawInfo drawInfo ;
2071                         drawInfo.version = 0 ;
2072                         drawInfo.state = kThemeStateActive ;
2073                         drawInfo.kind = m_backgroundBrush.MacGetThemeBackground( NULL ) ;
2074                         if ( drawInfo.kind == kThemeBackgroundMetal )
2075                         {
2076                             HIThemeDrawBackground( &rect, &drawInfo, cg, kHIThemeOrientationNormal ) ;
2077                             HIThemeApplyBackground( &rect, &drawInfo, cg, kHIThemeOrientationNormal ) ;
2078                         }
2079                     }
2080 #endif
2081                 }
2082                 break ;
2083
2084             case kwxMacBrushColour :
2085                 {
2086                     // FIXME: doesn't correctly render stippled brushes !!
2087                     // FIXME: should this be replaced by ::SetBrush() ??
2088
2089                     RGBColor col = MAC_WXCOLORREF( m_backgroundBrush.GetColour().GetPixel()) ;
2090                     CGContextSetRGBFillColor( cg , col.red / 65536.0 , col.green / 65536.0 , col.blue / 65536.0 , 1.0 ) ;
2091                     CGContextFillRect(cg, rect);
2092
2093                     // reset to normal value
2094                     col = MAC_WXCOLORREF( GetBrush().GetColour().GetPixel() ) ;
2095                     CGContextSetRGBFillColor( cg , col.red / 65536.0 , col.green / 65536.0 , col.blue / 65536.0 , 1.0 ) ;
2096                 }
2097                 break ;
2098
2099             default :
2100                 wxFAIL_MSG( wxT("unknown brush kind") ) ;
2101                 break ;
2102         }
2103     }
2104 }
2105
2106 void wxDC::MacInstallFont() const
2107 {
2108     wxCHECK_RET( Ok(), wxT("wxDC(cg)::MacInstallFont - invalid DC") );
2109
2110     if ( m_macATSUIStyle )
2111     {
2112         ::ATSUDisposeStyle((ATSUStyle)m_macATSUIStyle);
2113         m_macATSUIStyle = NULL ;
2114     }
2115
2116     if ( m_font.Ok() )
2117     {
2118         OSStatus status ;
2119
2120         status = ATSUCreateAndCopyStyle( (ATSUStyle) m_font.MacGetATSUStyle() , (ATSUStyle*) &m_macATSUIStyle ) ;
2121
2122         wxASSERT_MSG( status == noErr, wxT("couldn't create ATSU style") ) ;
2123
2124         Fixed atsuSize = IntToFixed( int(m_scaleY * m_font.MacGetFontSize()) ) ;
2125         RGBColor atsuColor = MAC_WXCOLORREF( m_textForegroundColour.GetPixel() ) ;
2126         ATSUAttributeTag atsuTags[] =
2127         {
2128                 kATSUSizeTag ,
2129                 kATSUColorTag ,
2130         } ;
2131         ByteCount atsuSizes[sizeof(atsuTags) / sizeof(ATSUAttributeTag)] =
2132         {
2133                 sizeof( Fixed ) ,
2134                 sizeof( RGBColor ) ,
2135         } ;
2136         ATSUAttributeValuePtr atsuValues[sizeof(atsuTags) / sizeof(ATSUAttributeTag)] =
2137         {
2138                 &atsuSize ,
2139                 &atsuColor ,
2140         } ;
2141
2142         status = ::ATSUSetAttributes(
2143             (ATSUStyle)m_macATSUIStyle, sizeof(atsuTags) / sizeof(ATSUAttributeTag) ,
2144             atsuTags, atsuSizes, atsuValues);
2145
2146         wxASSERT_MSG( status == noErr , wxT("couldn't modify ATSU style") ) ;
2147     }
2148 }
2149
2150 #pragma mark -
2151
2152 // ---------------------------------------------------------------------------
2153 // coordinates transformations
2154 // ---------------------------------------------------------------------------
2155
2156 wxCoord wxDCBase::DeviceToLogicalX(wxCoord x) const
2157 {
2158     return ((wxDC *)this)->XDEV2LOG(x);
2159 }
2160
2161 wxCoord wxDCBase::DeviceToLogicalY(wxCoord y) const
2162 {
2163     return ((wxDC *)this)->YDEV2LOG(y);
2164 }
2165
2166 wxCoord wxDCBase::DeviceToLogicalXRel(wxCoord x) const
2167 {
2168     return ((wxDC *)this)->XDEV2LOGREL(x);
2169 }
2170
2171 wxCoord wxDCBase::DeviceToLogicalYRel(wxCoord y) const
2172 {
2173     return ((wxDC *)this)->YDEV2LOGREL(y);
2174 }
2175
2176 wxCoord wxDCBase::LogicalToDeviceX(wxCoord x) const
2177 {
2178     return ((wxDC *)this)->XLOG2DEV(x);
2179 }
2180
2181 wxCoord wxDCBase::LogicalToDeviceY(wxCoord y) const
2182 {
2183     return ((wxDC *)this)->YLOG2DEV(y);
2184 }
2185
2186 wxCoord wxDCBase::LogicalToDeviceXRel(wxCoord x) const
2187 {
2188     return ((wxDC *)this)->XLOG2DEVREL(x);
2189 }
2190
2191 wxCoord wxDCBase::LogicalToDeviceYRel(wxCoord y) const
2192 {
2193     return ((wxDC *)this)->YLOG2DEVREL(y);
2194 }
2195
2196 #endif // wxMAC_USE_CORE_GRAPHICS
2197