src/mac/carbon/dccg.cpp

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