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 #ifdef __GNUG__
  13 #pragma implementation "dc.h"
  14 #endif
  15
  16 #include "wx/wxprec.h"
  17
  18 #include "wx/dc.h"
  19
  20 #if wxMAC_USE_CORE_GRAPHICS
  21
  22 #include "wx/app.h"
  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 #include "wx/log.h"
  29
  30
  31 #if __MSL__ >= 0x6000
  32 #include "math.h"
  33 using namespace std ;
  34 #endif
  35
  36 #include "wx/mac/private.h"
  37 #include <ATSUnicode.h>
  38 #include <TextCommon.h>
  39 #include <TextEncodingConverter.h>
  40 #include <FixMath.h>
  41 #include <CGContext.h>
  42
  43 #if !USE_SHARED_LIBRARY
  44 IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
  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 const double RAD2DEG  = 180.0 / M_PI;
  57 const short kEmulatedMode = -1 ;
  58 const short kUnsupportedMode = -2 ;
  59
  60 extern TECObjectRef s_TECNativeCToUnicode ;
  61
  62 // TODO Update
  63 // The text ctrl implementation still needs that for the non hiview implementation
  64
  65 wxMacWindowClipper::wxMacWindowClipper( const wxWindow* win ) :
  66     wxMacPortSaver( (GrafPtr) GetWindowPort((WindowRef) win->MacGetTopLevelWindowRef()) )
  67 {
  68     m_newPort =(GrafPtr) GetWindowPort((WindowRef) win->MacGetTopLevelWindowRef()) ;
  69     m_formerClip = NewRgn() ;
  70     m_newClip = NewRgn() ;
  71     GetClip( m_formerClip ) ;
  72
  73     if ( win )
  74     {
  75         int x = 0 , y = 0;
  76         win->MacWindowToRootWindow( &x,&y ) ;
  77         // get area including focus rect
  78         CopyRgn( (RgnHandle) ((wxWindow*)win)->MacGetVisibleRegion(true).GetWXHRGN() , m_newClip ) ;
  79         if ( !EmptyRgn( m_newClip ) )
  80             OffsetRgn( m_newClip , x , y ) ;
  81
  82         SetClip( m_newClip ) ;
  83     }
  84 }
  85
  86 wxMacWindowClipper::~wxMacWindowClipper()
  87 {
  88     SetPort( m_newPort ) ;
  89     SetClip( m_formerClip ) ;
  90     DisposeRgn( m_newClip ) ;
  91     DisposeRgn( m_formerClip ) ;
  92 }
  93
  94 wxMacWindowStateSaver::wxMacWindowStateSaver( const wxWindow* win ) :
  95     wxMacWindowClipper( win )
  96 {
  97     // the port is already set at this point
  98     m_newPort =(GrafPtr) GetWindowPort((WindowRef) win->MacGetTopLevelWindowRef()) ;
  99     GetThemeDrawingState( &m_themeDrawingState ) ;
 100 }
 101
 102 wxMacWindowStateSaver::~wxMacWindowStateSaver()
 103 {
 104     SetPort( m_newPort ) ;
 105     SetThemeDrawingState( m_themeDrawingState , true ) ;
 106 }
 107
 108 //-----------------------------------------------------------------------------
 109 // Local functions
 110 //-----------------------------------------------------------------------------
 111
 112 static inline double dmin(double a, double b) { return a < b ? a : b; }
 113 static inline double dmax(double a, double b) { return a > b ? a : b; }
 114 static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; }
 115
 116 //-----------------------------------------------------------------------------
 117 // device context implementation
 118 //
 119 // more and more of the dc functionality should be implemented by calling
 120 // the appropricate wxMacCGContext, but we will have to do that step by step
 121 // also coordinate conversions should be moved to native matrix ops
 122 //-----------------------------------------------------------------------------
 123
 124 wxMacCGPath::wxMacCGPath()
 125 {
 126     m_path = CGPathCreateMutable() ;
 127 }
 128
 129 wxMacCGPath::~wxMacCGPath()
 130 {
 131     CGPathRelease( m_path ) ;
 132 }
 133
 134 //  Starts a new subpath at
 135 void wxMacCGPath::MoveToPoint( wxCoord x1 , wxCoord y1 )
 136 {
 137     CGPathMoveToPoint( m_path , NULL , x1 , y1 ) ;
 138 }
 139
 140 void wxMacCGPath::AddLineToPoint( wxCoord x1 , wxCoord y1 )
 141 {
 142     CGPathAddLineToPoint( m_path , NULL , x1 , y1 ) ;
 143 }
 144
 145 void wxMacCGPath::AddRectangle( wxCoord x, wxCoord y, wxCoord w, wxCoord h )
 146 {
 147     CGRect cgRect = { { x , y } , { w , h } } ;
 148     CGPathAddRect( m_path , NULL , cgRect ) ;
 149 }
 150
 151 void wxMacCGPath::AddCircle( wxCoord x, wxCoord y , wxCoord r )
 152 {
 153     CGPathAddArc( m_path , NULL , x , y , r , 0.0 , 2 * M_PI , true ) ;
 154 }
 155
 156 // closes the current subpath
 157 void wxMacCGPath::CloseSubpath()
 158 {
 159     CGPathCloseSubpath( m_path ) ;
 160 }
 161
 162 CGPathRef wxMacCGPath::GetPath() const
 163 {
 164     return m_path ;
 165 }
 166
 167
 168 wxMacCGContext::wxMacCGContext( CGrafPtr port )
 169 {
 170     m_qdPort = port ;
 171     m_cgContext = NULL ;
 172 }
 173
 174 wxMacCGContext::wxMacCGContext( CGContextRef cgcontext )
 175 {
 176     m_qdPort = NULL ;
 177     m_cgContext = cgcontext ;
 178 }
 179
 180 wxMacCGContext::wxMacCGContext()
 181 {
 182     m_qdPort = NULL ;
 183     m_cgContext = NULL ;
 184 }
 185
 186 wxMacCGContext::~wxMacCGContext()
 187 {
 188     if ( m_qdPort )
 189         QDEndCGContext( m_qdPort , &m_cgContext ) ;
 190 }
 191
 192
 193 void wxMacCGContext::Clip( const wxRegion &region )
 194 {
 195 //        ClipCGContextToRegion ( m_cgContext, &bounds , (RgnHandle) dc->m_macCurrentClipRgn ) ;
 196 }
 197
 198 void wxMacCGContext::StrokePath( const wxGraphicPath *p )
 199 {
 200     const wxMacCGPath* path = dynamic_cast< const wxMacCGPath*>( p ) ;
 201     CGContextBeginPath( m_cgContext ) ;
 202     CGContextAddPath( m_cgContext , path->GetPath() ) ;
 203     CGContextClosePath( m_cgContext ) ;
 204     CGContextStrokePath( m_cgContext ) ;
 205 }
 206
 207 void wxMacCGContext::DrawPath( const wxGraphicPath *p , int fillStyle )
 208 {
 209     const wxMacCGPath* path = dynamic_cast< const wxMacCGPath*>( p ) ;
 210     CGPathDrawingMode mode = m_mode ;
 211     if ( fillStyle == wxODDEVEN_RULE )
 212     {
 213         if ( mode == kCGPathFill )
 214             mode = kCGPathEOFill ;
 215         else if ( mode == kCGPathFillStroke )
 216             mode = kCGPathEOFillStroke ;
 217     }
 218     CGContextBeginPath( m_cgContext ) ;
 219     CGContextAddPath( m_cgContext , path->GetPath() ) ;
 220     CGContextClosePath( m_cgContext ) ;
 221     CGContextDrawPath( m_cgContext , mode ) ;
 222 }
 223
 224 void wxMacCGContext::FillPath( const wxGraphicPath *p , const wxColor &fillColor , int fillStyle )
 225 {
 226     const wxMacCGPath* path = dynamic_cast< const wxMacCGPath*>( p ) ;
 227     CGContextSaveGState( m_cgContext ) ;
 228
 229     RGBColor col = MAC_WXCOLORREF( fillColor.GetPixel() ) ;
 230     CGContextSetRGBFillColor( m_cgContext , col.red / 65536.0 , col.green / 65536.0 , col.blue / 65536.0 , 1.0 ) ;
 231     CGPathDrawingMode mode = kCGPathFill ;
 232
 233     if ( fillStyle == wxODDEVEN_RULE )
 234         mode = kCGPathEOFill ;
 235
 236     CGContextBeginPath( m_cgContext ) ;
 237     CGContextAddPath( m_cgContext , path->GetPath() ) ;
 238     CGContextClosePath( m_cgContext ) ;
 239     CGContextDrawPath( m_cgContext , mode ) ;
 240
 241     CGContextRestoreGState( m_cgContext ) ;
 242 }
 243
 244 wxGraphicPath* wxMacCGContext::CreatePath()
 245 {
 246     CGContextRef cg = GetNativeContext() ;
 247     // make sure that we now have a real cgref, before doing
 248     // anything with paths
 249     return new wxMacCGPath() ;
 250 }
 251
 252 // in case we only got a QDPort only create a cgref now
 253
 254 CGContextRef wxMacCGContext::GetNativeContext()
 255 {
 256     if( m_cgContext == NULL )
 257     {
 258         Rect bounds ;
 259         GetPortBounds( (CGrafPtr) m_qdPort , &bounds ) ;
 260         OSStatus status = QDBeginCGContext( (CGrafPtr) m_qdPort , &m_cgContext ) ;
 261
 262         wxASSERT_MSG( status == noErr , wxT("Cannot nest wxDCs on the same window") ) ;
 263         CGContextTranslateCTM( m_cgContext , 0 , bounds.bottom - bounds.top ) ;
 264         CGContextScaleCTM( m_cgContext , 1 , -1 ) ;
 265
 266         SetPen( m_pen ) ;
 267         SetBrush( m_brush ) ;
 268     }
 269     return m_cgContext ;
 270 }
 271
 272 void wxMacCGContext::SetNativeContext( CGContextRef cg )
 273 {
 274     m_cgContext = cg ;
 275 }
 276
 277 void wxMacCGContext::SetPen( const wxPen &pen )
 278 {
 279     m_pen = pen ;
 280     if ( m_cgContext == NULL )
 281         return ;
 282     bool fill = m_brush.GetStyle() != wxTRANSPARENT ;
 283     bool stroke = pen.GetStyle() != wxTRANSPARENT ;
 284
 285 #if 0
 286     // we can benchmark performance, should go into a setting later
 287     CGContextSetShouldAntialias( m_cgContext , false ) ;
 288 #endif
 289     if ( fill | stroke )
 290     {
 291         // setup brushes
 292         m_mode = kCGPathFill ; // just a default
 293
 294         if ( fill )
 295         {
 296             m_mode = kCGPathFill ;
 297         }
 298         if ( stroke )
 299         {
 300             RGBColor col = MAC_WXCOLORREF( pen.GetColour().GetPixel() ) ;
 301             CGContextSetRGBStrokeColor( m_cgContext , col.red / 65536.0 , col.green / 65536.0 , col.blue / 65536.0 , 1.0 ) ;
 302
 303             CGLineCap cap ;
 304             switch( pen.GetCap() )
 305             {
 306                 case wxCAP_ROUND :
 307                     cap = kCGLineCapRound ;
 308                     break ;
 309                 case wxCAP_PROJECTING :
 310                     cap = kCGLineCapSquare ;
 311                     break ;
 312                 case wxCAP_BUTT :
 313                     cap = kCGLineCapButt ;
 314                     break ;
 315                 default :
 316                     cap = kCGLineCapButt ;
 317                     break ;
 318             }
 319             CGContextSetLineCap( m_cgContext , cap ) ;
 320
 321             CGLineJoin join ;
 322             switch( pen.GetJoin() )
 323             {
 324                 case wxJOIN_BEVEL :
 325                     join = kCGLineJoinBevel ;
 326                     break ;
 327                 case wxJOIN_MITER :
 328                     join = kCGLineJoinMiter ;
 329                     break ;
 330                 case wxJOIN_ROUND :
 331                     join = kCGLineJoinRound ;
 332                     break ;
 333                 default :
 334                     join = kCGLineJoinMiter ;
 335                     break;
 336             }
 337             CGContextSetLineJoin( m_cgContext , join ) ;
 338
 339             CGContextSetLineWidth( m_cgContext , pen.GetWidth() == 0 ? 0.1 :  pen.GetWidth() /* TODO * m_dc->m_scaleX */ ) ;
 340
 341             m_mode = kCGPathStroke ;
 342             int count = 0 ;
 343             const float *lengths = NULL ;
 344             float *userLengths = NULL ;
 345
 346             const float dotted[] = { 3 , 3 };
 347             const float dashed[] = { 19 , 9 };
 348             const float short_dashed[] = { 9 , 6 };
 349             const float dotted_dashed[] = { 9 , 6 , 3 , 3 };
 350
 351             switch( pen.GetStyle() )
 352             {
 353                 case wxSOLID :
 354                     break ;
 355                 case wxDOT :
 356                     lengths = dotted ;
 357                     count = WXSIZEOF(dotted);
 358                     break ;
 359                 case wxLONG_DASH :
 360                     lengths = dashed ;
 361                     count = WXSIZEOF(dashed) ;
 362                     break ;
 363                 case wxSHORT_DASH :
 364                     lengths = short_dashed ;
 365                     count = WXSIZEOF(short_dashed) ;
 366                     break ;
 367                 case wxDOT_DASH :
 368                     lengths = dotted_dashed ;
 369                     count = WXSIZEOF(dotted_dashed);
 370                     break ;
 371                 case wxUSER_DASH :
 372                     wxDash *dashes ;
 373                     count = pen.GetDashes( &dashes ) ;
 374                     if ( count >0 )
 375                     {
 376                         userLengths = new float[count] ;
 377                         for( int i = 0 ; i < count ; ++i )
 378                             userLengths[i] = dashes[i] ;
 379                     }
 380                     lengths = userLengths ;
 381                     break ;
 382                 default :
 383                     break ;
 384             }
 385
 386             CGContextSetLineDash( m_cgContext , 0 , lengths , count ) ;
 387             delete[] userLengths ;
 388             // we need to change the cap, otherwise everything overlaps
 389             // and we get solid lines
 390             if ( count > 0 )
 391                 CGContextSetLineCap( m_cgContext , kCGLineCapButt ) ;
 392         }
 393         if ( fill && stroke )
 394         {
 395             m_mode = kCGPathFillStroke ;
 396         }
 397
 398     }
 399 }
 400 void wxMacCGContext::SetBrush( const wxBrush &brush )
 401 {
 402     m_brush = brush ;
 403     if ( m_cgContext == NULL )
 404         return ;
 405
 406     bool fill = brush.GetStyle() != wxTRANSPARENT ;
 407     bool stroke = m_pen.GetStyle() != wxTRANSPARENT ;
 408
 409 #if 0
 410     // we can benchmark performance, should go into a setting later
 411     CGContextSetShouldAntialias( m_cgContext , false ) ;
 412 #endif
 413     if ( fill | stroke )
 414     {
 415
 416         // setup brushes
 417         m_mode = kCGPathFill ; // just a default
 418
 419         if ( fill )
 420         {
 421             RGBColor col = MAC_WXCOLORREF( brush.GetColour().GetPixel() ) ;
 422             CGContextSetRGBFillColor( m_cgContext , col.red / 65536.0 , col.green / 65536.0 , col.blue / 65536.0 , 1.0 ) ;
 423             m_mode = kCGPathFill ;
 424         }
 425         if ( stroke )
 426         {
 427             m_mode = kCGPathStroke ;
 428         }
 429         if ( fill && stroke )
 430         {
 431             m_mode = kCGPathFillStroke ;
 432         }
 433
 434     }
 435 }
 436
 437 // snippets from Sketch Sample from Apple :
 438
 439 #define kGenericRGBProfilePathStr       "/System/Library/ColorSync/Profiles/Generic RGB Profile.icc"
 440 /*
 441     This function locates, opens, and returns the profile reference for the calibrated
 442     Generic RGB color space. It is up to the caller to call CMCloseProfile when done
 443     with the profile reference this function returns.
 444 */
 445 CMProfileRef wxMacOpenGenericProfile(void)
 446 {
 447     static CMProfileRef cachedRGBProfileRef = NULL;
 448
 449     // we only create the profile reference once
 450     if (cachedRGBProfileRef == NULL)
 451     {
 452                 CMProfileLocation       loc;
 453
 454                 loc.locType = cmPathBasedProfile;
 455                 strcpy(loc.u.pathLoc.path, kGenericRGBProfilePathStr);
 456
 457                 verify_noerr( CMOpenProfile(&cachedRGBProfileRef, &loc) );
 458     }
 459
 460     if (cachedRGBProfileRef)
 461     {
 462                 // clone the profile reference so that the caller has their own reference, not our cached one
 463                 CMCloneProfileRef(cachedRGBProfileRef);
 464     }
 465
 466     return cachedRGBProfileRef;
 467 }
 468
 469 /*
 470     Return the generic RGB color space. This is a 'get' function and the caller should
 471     not release the returned value unless the caller retains it first. Usually callers
 472     of this routine will immediately use the returned colorspace with CoreGraphics
 473     so they typically do not need to retain it themselves.
 474
 475     This function creates the generic RGB color space once and hangs onto it so it can
 476     return it whenever this function is called.
 477 */
 478
 479 CGColorSpaceRef wxMacGetGenericRGBColorSpace()
 480 {
 481     static CGColorSpaceRef genericRGBColorSpace = NULL;
 482
 483         if (genericRGBColorSpace == NULL)
 484         {
 485                 CMProfileRef genericRGBProfile = wxMacOpenGenericProfile();
 486
 487                 if (genericRGBProfile)
 488                 {
 489                         genericRGBColorSpace = CGColorSpaceCreateWithPlatformColorSpace(genericRGBProfile);
 490                         wxASSERT_MSG( genericRGBColorSpace != NULL, wxT("couldn't create the generic RGB color space") ) ;
 491
 492                         // we opened the profile so it is up to us to close it
 493                         CMCloseProfile(genericRGBProfile);
 494                 }
 495         }
 496     return genericRGBColorSpace;
 497 }
 498
 499 void AddEllipticArcToPath(CGContextRef c, CGPoint center, float a, float b, float fromDegree , float toDegree )
 500 {
 501     CGContextSaveGState(c);
 502     CGContextTranslateCTM(c, center.x, center.y);
 503     CGContextScaleCTM(c, a, b);
 504     CGContextMoveToPoint(c, 1, 0);
 505     CGContextAddArc(c, 0, 0, 1, DegToRad(fromDegree), DegToRad(toDegree), 0);
 506     CGContextClosePath(c);
 507     CGContextRestoreGState(c);
 508 }
 509
 510 void AddRoundedRectToPath(CGContextRef c, CGRect rect, float ovalWidth,
 511       float ovalHeight)
 512 {
 513     float fw, fh;
 514     if (ovalWidth == 0 || ovalHeight == 0)
 515     {
 516         CGContextAddRect(c, rect);
 517         return;
 518     }
 519     CGContextSaveGState(c);
 520     CGContextTranslateCTM(c, CGRectGetMinX(rect), CGRectGetMinY(rect));
 521     CGContextScaleCTM(c, ovalWidth, ovalHeight);
 522     fw = CGRectGetWidth(rect) / ovalWidth;
 523     fh = CGRectGetHeight(rect) / ovalHeight;
 524     CGContextMoveToPoint(c, fw, fh/2);
 525     CGContextAddArcToPoint(c, fw, fh, fw/2, fh, 1);
 526     CGContextAddArcToPoint(c, 0, fh, 0, fh/2, 1);
 527     CGContextAddArcToPoint(c, 0, 0, fw/2, 0, 1);
 528     CGContextAddArcToPoint(c, fw, 0, fw, fh/2, 1);
 529     CGContextClosePath(c);
 530     CGContextRestoreGState(c);
 531 }
 532
 533 wxDC::wxDC()
 534 {
 535     m_ok = FALSE;
 536     m_colour = TRUE;
 537     m_mm_to_pix_x = mm2pt;
 538     m_mm_to_pix_y = mm2pt;
 539     m_internalDeviceOriginX = 0;
 540     m_internalDeviceOriginY = 0;
 541     m_externalDeviceOriginX = 0;
 542     m_externalDeviceOriginY = 0;
 543     m_logicalScaleX = 1.0;
 544     m_logicalScaleY = 1.0;
 545     m_userScaleX = 1.0;
 546     m_userScaleY = 1.0;
 547     m_scaleX = 1.0;
 548     m_scaleY = 1.0;
 549     m_needComputeScaleX = FALSE;
 550     m_needComputeScaleY = FALSE;
 551
 552     m_ok = FALSE ;
 553
 554     m_macLocalOrigin.x = m_macLocalOrigin.y = 0 ;
 555
 556     m_pen = *wxBLACK_PEN;
 557     m_font = *wxNORMAL_FONT;
 558     m_brush = *wxWHITE_BRUSH;
 559
 560     m_macATSUIStyle = NULL ;
 561
 562     m_graphicContext = NULL ;
 563 }
 564
 565 wxDC::~wxDC(void)
 566 {
 567     if( m_macATSUIStyle )
 568     {
 569         ::ATSUDisposeStyle((ATSUStyle)m_macATSUIStyle);
 570         m_macATSUIStyle = NULL ;
 571     }
 572
 573     delete m_graphicContext ;
 574 }
 575
 576 void wxDC::DoDrawBitmap( const wxBitmap &bmp, wxCoord x, wxCoord y, bool useMask )
 577 {
 578     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 579     wxCHECK_RET( bmp.Ok(), wxT("invalid bitmap") );
 580     wxCoord xx = XLOG2DEVMAC(x);
 581     wxCoord yy = YLOG2DEVMAC(y);
 582     wxCoord w = bmp.GetWidth();
 583     wxCoord h = bmp.GetHeight();
 584     wxCoord ww = XLOG2DEVREL(w);
 585     wxCoord hh = YLOG2DEVREL(h);
 586
 587     CGContextRef cg = dynamic_cast<wxMacCGContext*>(m_graphicContext)->GetNativeContext() ;
 588     CGImageRef image = (CGImageRef)( bmp.CGImageCreate() ) ;
 589     HIRect r = CGRectMake( xx , yy , ww , hh ) ;
 590     HIViewDrawCGImage( cg , &r , image ) ;
 591     CGImageRelease( image ) ;
 592 }
 593
 594 void wxDC::DoDrawIcon( const wxIcon &icon, wxCoord x, wxCoord y )
 595 {
 596     wxCHECK_RET(Ok(), wxT("Invalid dc  wxDC::DoDrawIcon"));
 597     wxCHECK_RET(icon.Ok(), wxT("Invalid icon wxDC::DoDrawIcon"));
 598
 599     wxCoord xx = XLOG2DEVMAC(x);
 600     wxCoord yy = YLOG2DEVMAC(y);
 601     wxCoord w = icon.GetWidth();
 602     wxCoord h = icon.GetHeight();
 603     wxCoord ww = XLOG2DEVREL(w);
 604     wxCoord hh = YLOG2DEVREL(h);
 605
 606     CGContextRef cg = dynamic_cast<wxMacCGContext*>(m_graphicContext)->GetNativeContext() ;
 607     CGRect r = CGRectMake( 00 , 00 , ww , hh ) ;
 608     CGContextSaveGState(cg);
 609     CGContextTranslateCTM(cg, xx , yy + hh );
 610     CGContextScaleCTM(cg, 1, -1);
 611     PlotIconRefInContext( cg , &r , kAlignNone , kTransformNone ,
 612         NULL , kPlotIconRefNormalFlags , MAC_WXHICON( icon.GetHICON() ) ) ;
 613     CGContextRestoreGState( cg ) ;
 614 }
 615
 616 void wxDC::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
 617 {
 618     wxCHECK_RET(Ok(), wxT("wxDC::DoSetClippingRegion  Invalid DC"));
 619     wxCoord xx, yy, ww, hh;
 620     xx = XLOG2DEVMAC(x);
 621     yy = YLOG2DEVMAC(y);
 622     ww = XLOG2DEVREL(width);
 623     hh = YLOG2DEVREL(height);
 624 //    SetRectRgn( (RgnHandle) m_macCurrentClipRgn , xx , yy , xx + ww , yy + hh ) ;
 625 //    SectRgn( (RgnHandle) m_macCurrentClipRgn , (RgnHandle) m_macBoundaryClipRgn , (RgnHandle) m_macCurrentClipRgn ) ;
 626     if( m_clipping )
 627     {
 628         m_clipX1 = wxMax( m_clipX1 , xx );
 629         m_clipY1 = wxMax( m_clipY1 , yy );
 630         m_clipX2 = wxMin( m_clipX2, (xx + ww));
 631         m_clipY2 = wxMin( m_clipY2, (yy + hh));
 632     }
 633     else
 634     {
 635         m_clipping = TRUE;
 636         m_clipX1 = xx;
 637         m_clipY1 = yy;
 638         m_clipX2 = xx + ww;
 639         m_clipY2 = yy + hh;
 640     }
 641     // TODO as soon as we don't reset the context for each operation anymore
 642     // we have to update the context as well
 643 }
 644
 645 void wxDC::DoSetClippingRegionAsRegion( const wxRegion &region  )
 646 {
 647     wxCHECK_RET( Ok(), wxT("invalid window dc") ) ;
 648     if (region.Empty())
 649     {
 650         DestroyClippingRegion();
 651         return;
 652     }
 653     wxCoord x, y, w, h;
 654     region.GetBox( x, y, w, h );
 655     wxCoord xx, yy, ww, hh;
 656     xx = XLOG2DEVMAC(x);
 657     yy = YLOG2DEVMAC(y);
 658     ww = XLOG2DEVREL(w);
 659     hh = YLOG2DEVREL(h);
 660     // if we have a scaling that we cannot map onto native regions
 661     // we must use the box
 662     if ( ww != w || hh != h )
 663     {
 664         wxDC::DoSetClippingRegion( x, y, w, h );
 665     }
 666     else
 667     {
 668         /*
 669         CopyRgn( (RgnHandle) region.GetWXHRGN() , (RgnHandle) m_macCurrentClipRgn ) ;
 670         if ( xx != x || yy != y )
 671         {
 672             OffsetRgn( (RgnHandle) m_macCurrentClipRgn , xx - x , yy - y ) ;
 673         }
 674         SectRgn( (RgnHandle) m_macCurrentClipRgn , (RgnHandle) m_macBoundaryClipRgn , (RgnHandle) m_macCurrentClipRgn ) ;
 675         */
 676         if( m_clipping )
 677         {
 678             m_clipX1 = wxMax( m_clipX1 , xx );
 679             m_clipY1 = wxMax( m_clipY1 , yy );
 680             m_clipX2 = wxMin( m_clipX2, (xx + ww));
 681             m_clipY2 = wxMin( m_clipY2, (yy + hh));
 682         }
 683         else
 684         {
 685             m_clipping = TRUE;
 686             m_clipX1 = xx;
 687             m_clipY1 = yy;
 688             m_clipX2 = xx + ww;
 689             m_clipY2 = yy + hh;
 690         }
 691     }
 692 }
 693
 694 void wxDC::DestroyClippingRegion()
 695 {
 696 //    CopyRgn( (RgnHandle) m_macBoundaryClipRgn , (RgnHandle) m_macCurrentClipRgn ) ;
 697     m_clipping = FALSE;
 698 }
 699
 700 void wxDC::DoGetSizeMM( int* width, int* height ) const
 701 {
 702     int w = 0;
 703     int h = 0;
 704     GetSize( &w, &h );
 705     *width = long( double(w) / (m_scaleX*m_mm_to_pix_x) );
 706     *height = long( double(h) / (m_scaleY*m_mm_to_pix_y) );
 707 }
 708
 709 void wxDC::SetTextForeground( const wxColour &col )
 710 {
 711     wxCHECK_RET(Ok(), wxT("Invalid DC"));
 712     if ( col != m_textForegroundColour )
 713     {
 714         m_textForegroundColour = col;
 715         MacInstallFont() ;
 716     }
 717 }
 718
 719 void wxDC::SetTextBackground( const wxColour &col )
 720 {
 721     wxCHECK_RET(Ok(), wxT("Invalid DC"));
 722     m_textBackgroundColour = col;
 723 }
 724
 725 void wxDC::SetMapMode( int mode )
 726 {
 727     switch (mode)
 728     {
 729     case wxMM_TWIPS:
 730         SetLogicalScale( twips2mm*m_mm_to_pix_x, twips2mm*m_mm_to_pix_y );
 731         break;
 732     case wxMM_POINTS:
 733         SetLogicalScale( pt2mm*m_mm_to_pix_x, pt2mm*m_mm_to_pix_y );
 734         break;
 735     case wxMM_METRIC:
 736         SetLogicalScale( m_mm_to_pix_x, m_mm_to_pix_y );
 737         break;
 738     case wxMM_LOMETRIC:
 739         SetLogicalScale( m_mm_to_pix_x/10.0, m_mm_to_pix_y/10.0 );
 740         break;
 741     default:
 742     case wxMM_TEXT:
 743         SetLogicalScale( 1.0, 1.0 );
 744         break;
 745     }
 746     if (mode != wxMM_TEXT)
 747     {
 748         m_needComputeScaleX = TRUE;
 749         m_needComputeScaleY = TRUE;
 750     }
 751 }
 752
 753 void wxDC::SetUserScale( double x, double y )
 754 {
 755     // allow negative ? -> no
 756     m_userScaleX = x;
 757     m_userScaleY = y;
 758     ComputeScaleAndOrigin();
 759 }
 760
 761 void wxDC::SetLogicalScale( double x, double y )
 762 {
 763     // allow negative ?
 764     m_logicalScaleX = x;
 765     m_logicalScaleY = y;
 766     ComputeScaleAndOrigin();
 767 }
 768
 769 void wxDC::SetLogicalOrigin( wxCoord x, wxCoord y )
 770 {
 771     m_logicalOriginX = x * m_signX;   // is this still correct ?
 772     m_logicalOriginY = y * m_signY;
 773     ComputeScaleAndOrigin();
 774 }
 775
 776 void wxDC::SetDeviceOrigin( wxCoord x, wxCoord y )
 777 {
 778     m_externalDeviceOriginX = x;
 779     m_externalDeviceOriginY = y;
 780     ComputeScaleAndOrigin();
 781 }
 782
 783 void wxDC::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
 784 {
 785     m_signX = (xLeftRight ?  1 : -1);
 786     m_signY = (yBottomUp  ? -1 :  1);
 787     ComputeScaleAndOrigin();
 788 }
 789
 790 wxSize wxDC::GetPPI() const
 791 {
 792     return wxSize(72, 72);
 793 }
 794
 795 int wxDC::GetDepth() const
 796 {
 797     return 32 ;
 798 }
 799
 800 void wxDC::ComputeScaleAndOrigin()
 801 {
 802     // CMB: copy scale to see if it changes
 803     double origScaleX = m_scaleX;
 804     double origScaleY = m_scaleY;
 805     m_scaleX = m_logicalScaleX * m_userScaleX;
 806     m_scaleY = m_logicalScaleY * m_userScaleY;
 807     m_deviceOriginX = m_internalDeviceOriginX + m_externalDeviceOriginX;
 808     m_deviceOriginY = m_internalDeviceOriginY + m_externalDeviceOriginY;
 809     // CMB: if scale has changed call SetPen to recalulate the line width
 810     if (m_scaleX != origScaleX || m_scaleY != origScaleY)
 811     {
 812         // this is a bit artificial, but we need to force wxDC to think
 813         // the pen has changed
 814         wxPen pen(GetPen());
 815         m_pen = wxNullPen;
 816         SetPen(pen);
 817     }
 818 }
 819
 820 void  wxDC::SetPalette( const wxPalette& palette )
 821 {
 822 }
 823
 824 void  wxDC::SetBackgroundMode( int mode )
 825 {
 826     m_backgroundMode = mode ;
 827 }
 828
 829 void  wxDC::SetFont( const wxFont &font )
 830 {
 831     m_font = font;
 832     MacInstallFont() ;
 833 }
 834
 835 void  wxDC::SetPen( const wxPen &pen )
 836 {
 837     if ( m_pen == pen )
 838         return ;
 839     m_pen = pen;
 840     if ( m_graphicContext )
 841     {
 842         m_graphicContext->SetPen( m_pen ) ;
 843     }
 844 }
 845
 846 void  wxDC::SetBrush( const wxBrush &brush )
 847 {
 848     if (m_brush == brush)
 849         return;
 850     m_brush = brush;
 851     if ( m_graphicContext )
 852     {
 853         m_graphicContext->SetBrush( m_brush ) ;
 854     }
 855 }
 856
 857 void  wxDC::SetBackground( const wxBrush &brush )
 858 {
 859     if (m_backgroundBrush == brush)
 860         return;
 861     m_backgroundBrush = brush;
 862     if (!m_backgroundBrush.Ok())
 863         return;
 864 }
 865
 866 void  wxDC::SetLogicalFunction( int function )
 867 {
 868     if (m_logicalFunction == function)
 869         return;
 870     m_logicalFunction = function ;
 871 }
 872
 873 extern bool wxDoFloodFill(wxDC *dc, wxCoord x, wxCoord y,
 874                           const wxColour & col, int style);
 875
 876 bool wxDC::DoFloodFill(wxCoord x, wxCoord y,
 877                        const wxColour& col, int style)
 878 {
 879     return wxDoFloodFill(this, x, y, col, style);
 880 }
 881
 882 bool  wxDC::DoGetPixel( wxCoord x, wxCoord y, wxColour *col ) const
 883 {
 884     wxCHECK_MSG( Ok(), false, wxT("wxDC::DoGetPixel  Invalid DC") );
 885     wxFAIL_MSG( wxT("GetPixel not implemented on Core Graphics") ) ;
 886     return false ;
 887 }
 888
 889 void  wxDC::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 )
 890 {
 891     wxCHECK_RET(Ok(), wxT("Invalid DC"));
 892
 893     wxCoord xx1 = XLOG2DEVMAC(x1) ;
 894     wxCoord yy1 = YLOG2DEVMAC(y1) ;
 895     wxCoord xx2 = XLOG2DEVMAC(x2) ;
 896     wxCoord yy2 = YLOG2DEVMAC(y2) ;
 897
 898     wxGraphicPath* path = m_graphicContext->CreatePath() ;
 899     path->MoveToPoint( xx1 , yy1 ) ;
 900     path->AddLineToPoint( xx2 , yy2 ) ;
 901     path->CloseSubpath() ;
 902     m_graphicContext->StrokePath( path ) ;
 903     delete path ;
 904
 905     CalcBoundingBox(x1, y1);
 906     CalcBoundingBox(x2, y2);
 907 }
 908
 909 void  wxDC::DoCrossHair( wxCoord x, wxCoord y )
 910 {
 911     wxCHECK_RET( Ok(), wxT("wxDC::DoCrossHair  Invalid window dc") );
 912
 913
 914     int w = 0;
 915     int h = 0;
 916     GetSize( &w, &h );
 917     wxCoord xx = XLOG2DEVMAC(x);
 918     wxCoord yy = YLOG2DEVMAC(y);
 919
 920     wxGraphicPath* path = m_graphicContext->CreatePath() ;
 921     path->MoveToPoint( XLOG2DEVMAC(0), yy  ) ;
 922     path->AddLineToPoint( XLOG2DEVMAC(w), yy ) ;
 923     path->CloseSubpath() ;
 924     path->MoveToPoint( xx, YLOG2DEVMAC(0) ) ;
 925     path->AddLineToPoint( xx, YLOG2DEVMAC(h) ) ;
 926     path->CloseSubpath() ;
 927     m_graphicContext->StrokePath( path ) ;
 928     delete path ;
 929
 930     CalcBoundingBox(x, y);
 931     CalcBoundingBox(x+w, y+h);
 932 }
 933
 934 /*
 935 * To draw arcs properly the angles need to be converted from the WX style:
 936 * Angles start on the +ve X axis and go anti-clockwise (As you would draw on
 937 * a normal axis on paper).
 938 * TO
 939 * the Mac style:
 940 * Angles start on the +ve y axis and go clockwise.
 941 */
 942
 943 static double wxConvertWXangleToMACangle(double angle)
 944 {
 945     double newAngle = 90 - angle ;
 946     if ( newAngle < 0 )
 947         newAngle += 360 ;
 948     return newAngle ;
 949 }
 950
 951 void  wxDC::DoDrawArc( wxCoord x1, wxCoord y1,
 952                       wxCoord x2, wxCoord y2,
 953                       wxCoord xc, wxCoord yc )
 954 {
 955     wxCHECK_RET(Ok(), wxT("wxDC::DoDrawArc  Invalid DC"));
 956     wxCoord xx1 = XLOG2DEVMAC(x1);
 957     wxCoord yy1 = YLOG2DEVMAC(y1);
 958     wxCoord xx2 = XLOG2DEVMAC(x2);
 959     wxCoord yy2 = YLOG2DEVMAC(y2);
 960     wxCoord xxc = XLOG2DEVMAC(xc);
 961     wxCoord yyc = YLOG2DEVMAC(yc);
 962     double dx = xx1 - xxc;
 963     double dy = yy1 - yyc;
 964     double radius = sqrt((double)(dx*dx+dy*dy));
 965     wxCoord rad   = (wxCoord)radius;
 966     double radius1, radius2;
 967     if (xx1 == xx2 && yy1 == yy2)
 968     {
 969         radius1 = 0.0;
 970         radius2 = 360.0;
 971     }
 972     else if (radius == 0.0)
 973     {
 974         radius1 = radius2 = 0.0;
 975     }
 976     else
 977     {
 978         radius1 = (xx1 - xxc == 0) ?
 979             (yy1 - yyc < 0) ? 90.0 : -90.0 :
 980         -atan2(double(yy1-yyc), double(xx1-xxc)) * RAD2DEG;
 981         radius2 = (xx2 - xxc == 0) ?
 982             (yy2 - yyc < 0) ? 90.0 : -90.0 :
 983         -atan2(double(yy2-yyc), double(xx2-xxc)) * RAD2DEG;
 984     }
 985     wxCoord alpha2 = wxCoord(radius2 - radius1);
 986     wxCoord alpha1 = wxCoord(wxConvertWXangleToMACangle(radius1));
 987     if( (xx1 > xx2) || (yy1 > yy2) ) {
 988         alpha2 *= -1;
 989     }
 990     Rect r = { yyc - rad, xxc - rad, yyc + rad, xxc + rad };
 991     wxMacCGContext* mctx = ((wxMacCGContext*) m_graphicContext) ;
 992     CGContextRef ctx = mctx->GetNativeContext() ;
 993     AddEllipticArcToPath( ctx , CGPointMake( xxc , yyc ) , rad , rad , 0 , 180 ) ;
 994     CGContextDrawPath( ctx , mctx->GetDrawingMode() ) ;
 995 }
 996
 997 void  wxDC::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord w, wxCoord h,
 998                               double sa, double ea )
 999 {
1000     wxCHECK_RET(Ok(), wxT("wxDC::DoDrawEllepticArc  Invalid DC"));
1001
1002     double angle = sa - ea;  // Order important Mac in opposite direction to wx
1003     // we have to make sure that the filling is always counter-clockwise
1004     if ( angle > 0 )
1005         angle -= 360 ;
1006     wxCoord xx = XLOG2DEVMAC(x);
1007     wxCoord yy = YLOG2DEVMAC(y);
1008     wxCoord ww = m_signX * XLOG2DEVREL(w);
1009     wxCoord hh = m_signY * YLOG2DEVREL(h);
1010     // handle -ve width and/or height
1011     if (ww < 0) { ww = -ww; xx = xx - ww; }
1012     if (hh < 0) { hh = -hh; yy = yy - hh; }
1013     sa = wxConvertWXangleToMACangle(sa);
1014     wxMacCGContext* mctx = ((wxMacCGContext*) m_graphicContext) ;
1015     CGContextRef ctx = mctx->GetNativeContext() ;
1016     AddEllipticArcToPath( ctx  , CGPointMake( xx + ww / 2 , yy + hh / 2 ) , ww / 2 , hh / 2 , sa , angle) ;
1017     CGContextDrawPath( ctx , mctx->GetDrawingMode() ) ;
1018 }
1019
1020 void  wxDC::DoDrawPoint( wxCoord x, wxCoord y )
1021 {
1022     wxCHECK_RET(Ok(), wxT("Invalid DC"));
1023     DoDrawLine( x , y , x + 1 , y + 1 ) ;
1024 }
1025
1026 void  wxDC::DoDrawLines(int n, wxPoint points[],
1027                         wxCoord xoffset, wxCoord yoffset)
1028 {
1029     wxCHECK_RET(Ok(), wxT("Invalid DC"));
1030
1031     wxCoord x1, x2 , y1 , y2 ;
1032     x1 = XLOG2DEVMAC(points[0].x + xoffset);
1033     y1 = YLOG2DEVMAC(points[0].y + yoffset);
1034     wxGraphicPath* path = m_graphicContext->CreatePath() ;
1035     path->MoveToPoint( x1 , y1 ) ;
1036     for (int i = 1; i < n; i++)
1037     {
1038         x2 = XLOG2DEVMAC(points[i].x + xoffset);
1039         y2 = YLOG2DEVMAC(points[i].y + yoffset);
1040
1041         path->AddLineToPoint( x2 , y2 ) ;
1042     }
1043     m_graphicContext->StrokePath( path ) ;
1044     delete path ;
1045 }
1046
1047 void  wxDC::DoDrawPolygon(int n, wxPoint points[],
1048                           wxCoord xoffset, wxCoord yoffset,
1049                           int fillStyle )
1050 {
1051     wxCHECK_RET(Ok(), wxT("Invalid DC"));
1052         wxCoord x1, x2 , y1 , y2 ;
1053     if ( n== 0 || (m_brush.GetStyle() == wxTRANSPARENT && m_pen.GetStyle() == wxTRANSPARENT ) )
1054         return ;
1055
1056     x2 = x1 = XLOG2DEVMAC(points[0].x + xoffset);
1057     y2 = y1 = YLOG2DEVMAC(points[0].y + yoffset);
1058
1059     wxGraphicPath* path = m_graphicContext->CreatePath() ;
1060     path->MoveToPoint( x1 , y1 ) ;
1061     for (int i = 1; i < n; i++)
1062     {
1063         x2 = XLOG2DEVMAC(points[i].x + xoffset);
1064         y2 = YLOG2DEVMAC(points[i].y + yoffset);
1065
1066         path->AddLineToPoint( x2 , y2 ) ;
1067     }
1068     if ( x1 != x2 || y1 != y2 )
1069     {
1070         path->AddLineToPoint( x1,y1 ) ;
1071     }
1072     path->CloseSubpath() ;
1073     m_graphicContext->DrawPath( path , fillStyle ) ;
1074     delete path ;
1075 }
1076
1077 void wxDC::DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
1078 {
1079     wxCHECK_RET(Ok(), wxT("Invalid DC"));
1080     wxCoord xx = XLOG2DEVMAC(x);
1081     wxCoord yy = YLOG2DEVMAC(y);
1082     wxCoord ww = m_signX * XLOG2DEVREL(width);
1083     wxCoord hh = m_signY * YLOG2DEVREL(height);
1084     // CMB: draw nothing if transformed w or h is 0
1085     if (ww == 0 || hh == 0)
1086         return;
1087     // CMB: handle -ve width and/or height
1088     if (ww < 0)
1089     {
1090         ww = -ww;
1091         xx = xx - ww;
1092     }
1093     if (hh < 0)
1094     {
1095         hh = -hh;
1096         yy = yy - hh;
1097     }
1098     wxGraphicPath* path = m_graphicContext->CreatePath() ;
1099     path->AddRectangle(xx ,yy , ww , hh ) ;
1100     path->CloseSubpath() ;
1101     m_graphicContext->DrawPath( path ) ;
1102     delete path ;
1103 }
1104
1105 void  wxDC::DoDrawRoundedRectangle(wxCoord x, wxCoord y,
1106                                    wxCoord width, wxCoord height,
1107                                    double radius)
1108 {
1109     wxCHECK_RET(Ok(), wxT("Invalid DC"));
1110     if (radius < 0.0)
1111         radius = - radius * ((width < height) ? width : height);
1112     wxCoord xx = XLOG2DEVMAC(x);
1113     wxCoord yy = YLOG2DEVMAC(y);
1114     wxCoord ww = m_signX * XLOG2DEVREL(width);
1115     wxCoord hh = m_signY * YLOG2DEVREL(height);
1116     // CMB: draw nothing if transformed w or h is 0
1117     if (ww == 0 || hh == 0)
1118         return;
1119     // CMB: handle -ve width and/or height
1120     if (ww < 0)
1121     {
1122         ww = -ww;
1123         xx = xx - ww;
1124     }
1125     if (hh < 0)
1126     {
1127         hh = -hh;
1128         yy = yy - hh;
1129     }
1130     Rect rect = { yy , xx , yy + hh , xx + ww } ;
1131     wxMacCGContext* mctx = ((wxMacCGContext*) m_graphicContext) ;
1132     CGContextRef ctx = mctx->GetNativeContext() ;
1133     AddRoundedRectToPath( ctx  , CGRectMake( xx , yy , ww , hh ) , 16 ,16  ) ;
1134     CGContextDrawPath( ctx , mctx->GetDrawingMode() ) ;
1135 }
1136
1137 void  wxDC::DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
1138 {
1139     wxCHECK_RET(Ok(), wxT("Invalid DC"));
1140     wxCoord xx = XLOG2DEVMAC(x);
1141     wxCoord yy = YLOG2DEVMAC(y);
1142     wxCoord ww = m_signX * XLOG2DEVREL(width);
1143     wxCoord hh = m_signY * YLOG2DEVREL(height);
1144     // CMB: draw nothing if transformed w or h is 0
1145     if (ww == 0 || hh == 0)
1146         return;
1147     // CMB: handle -ve width and/or height
1148     if (ww < 0)
1149     {
1150         ww = -ww;
1151         xx = xx - ww;
1152     }
1153     if (hh < 0)
1154     {
1155         hh = -hh;
1156         yy = yy - hh;
1157     }
1158
1159     wxMacCGContext* mctx = ((wxMacCGContext*) m_graphicContext) ;
1160     CGContextRef ctx = mctx->GetNativeContext() ;
1161     if ( width == height )
1162     {
1163         CGContextBeginPath(ctx);
1164         CGContextAddArc(ctx ,
1165             xx + ww / 2,
1166             yy + hh / 2,
1167             ww / 2,
1168             0,
1169             2 * M_PI,
1170             0 ) ;
1171         CGContextClosePath(ctx);
1172
1173         CGContextDrawPath( ctx , kCGPathFillStroke ) ;
1174     }
1175     else
1176     {
1177         AddEllipticArcToPath( ctx , CGPointMake( xx + ww / 2 , yy + hh / 2 ) , ww / 2 , hh / 2 , 0 , 360) ;
1178         CGContextDrawPath( ctx , mctx->GetDrawingMode() ) ;
1179     }
1180 }
1181
1182 bool  wxDC::CanDrawBitmap(void) const
1183 {
1184     return true ;
1185 }
1186
1187 bool  wxDC::DoBlit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
1188                    wxDC *source, wxCoord xsrc, wxCoord ysrc, int logical_func , bool useMask,
1189                    wxCoord xsrcMask,  wxCoord ysrcMask )
1190 {
1191     wxCHECK_MSG(Ok(), false, wxT("wxDC::DoBlit Illegal dc"));
1192     wxCHECK_MSG(source->Ok(), false, wxT("wxDC::DoBlit  Illegal source DC"));
1193     if ( logical_func == wxNO_OP )
1194         return TRUE ;
1195     if (xsrcMask == -1 && ysrcMask == -1)
1196     {
1197         xsrcMask = xsrc; ysrcMask = ysrc;
1198     }
1199
1200     wxMemoryDC* memdc = dynamic_cast<wxMemoryDC*>(source) ;
1201     if ( memdc )
1202     {
1203         wxBitmap blit = memdc->GetSelectedObject() ;
1204         wxASSERT_MSG( blit.Ok() , wxT("Invalid bitmap for blitting") ) ;
1205
1206         wxCoord xxdest = XLOG2DEVMAC(xdest);
1207         wxCoord yydest = YLOG2DEVMAC(ydest);
1208         wxCoord ww = XLOG2DEVREL(width);
1209         wxCoord hh = YLOG2DEVREL(height);
1210
1211         wxCoord bmpwidth = blit.GetWidth();
1212         wxCoord bmpheight = blit.GetHeight();
1213
1214         if ( xsrc != 0 || ysrc != 0 || bmpwidth != width || bmpheight != height )
1215         {
1216             wxRect subrect( xsrc, ysrc, width , height ) ;
1217             blit = blit.GetSubBitmap( subrect ) ;
1218         }
1219
1220         CGContextRef cg = dynamic_cast<wxMacCGContext*>(m_graphicContext)->GetNativeContext() ;
1221         CGImageRef image = (CGImageRef)( blit.CGImageCreate() ) ;
1222         HIRect r = CGRectMake( xxdest , yydest , ww , hh ) ;
1223         HIViewDrawCGImage( cg , &r , image ) ;
1224         CGImageRelease( image ) ;
1225
1226     }
1227     else
1228     {
1229         wxFAIL_MSG( wxT("Blitting is only supported from bitmap contexts") ) ;
1230     }
1231     return TRUE;
1232 }
1233
1234 void  wxDC::DoDrawRotatedText(const wxString& str, wxCoord x, wxCoord y,
1235                               double angle)
1236 {
1237     wxCHECK_RET( Ok(), wxT("wxDC::DoDrawRotatedText  Invalid window dc") );
1238
1239     if ( str.Length() == 0 )
1240         return ;
1241
1242     wxCHECK_RET( m_macATSUIStyle != NULL , wxT("No valid font set") ) ;
1243
1244     OSStatus status = noErr ;
1245     ATSUTextLayout atsuLayout ;
1246     UniCharCount chars = str.Length() ;
1247     UniChar* ubuf = NULL ;
1248 #if SIZEOF_WCHAR_T == 4
1249         wxMBConvUTF16BE converter ;
1250 #if wxUSE_UNICODE
1251         size_t unicharlen = converter.WC2MB( NULL , str.wc_str() , 0 ) ;
1252         ubuf = (UniChar*) malloc( unicharlen + 2 ) ;
1253         converter.WC2MB( (char*) ubuf , str.wc_str(), unicharlen + 2 ) ;
1254 #else
1255     const wxWCharBuffer wchar = str.wc_str( wxConvLocal ) ;
1256         size_t unicharlen = converter.WC2MB( NULL , wchar.data()  , 0 ) ;
1257         ubuf = (UniChar*) malloc( unicharlen + 2 ) ;
1258         converter.WC2MB( (char*) ubuf , wchar.data() , unicharlen + 2 ) ;
1259 #endif
1260     chars = unicharlen / 2 ;
1261 #else
1262 #if wxUSE_UNICODE
1263     ubuf = (UniChar*) str.wc_str() ;
1264 #else
1265     wxWCharBuffer wchar = str.wc_str( wxConvLocal ) ;
1266     chars = wxWcslen( wchar.data() ) ;
1267     ubuf = (UniChar*) wchar.data() ;
1268 #endif
1269 #endif
1270
1271     int drawX = XLOG2DEVMAC(x) ;
1272     int drawY = YLOG2DEVMAC(y) ;
1273
1274     status = ::ATSUCreateTextLayoutWithTextPtr( (UniCharArrayPtr) ubuf , 0 , chars , chars , 1 ,
1275         &chars , (ATSUStyle*) &m_macATSUIStyle , &atsuLayout ) ;
1276
1277     wxASSERT_MSG( status == noErr , wxT("couldn't create the layout of the rotated text") );
1278     int iAngle = int( angle );
1279
1280
1281
1282     if ( abs(iAngle) > 0 )
1283     {
1284         Fixed atsuAngle = IntToFixed( iAngle ) ;
1285         ATSUAttributeTag atsuTags[] =
1286         {
1287             kATSULineRotationTag ,
1288         } ;
1289         ByteCount atsuSizes[sizeof(atsuTags)/sizeof(ATSUAttributeTag)] =
1290         {
1291             sizeof( Fixed ) ,
1292         } ;
1293         ATSUAttributeValuePtr    atsuValues[sizeof(atsuTags)/sizeof(ATSUAttributeTag)] =
1294         {
1295             &atsuAngle ,
1296         } ;
1297         status = ::ATSUSetLayoutControls(atsuLayout , sizeof(atsuTags)/sizeof(ATSUAttributeTag),
1298             atsuTags, atsuSizes, atsuValues ) ;
1299     }
1300     {
1301         CGContextRef cgContext = dynamic_cast<wxMacCGContext*>(m_graphicContext)->GetNativeContext() ;
1302         ATSUAttributeTag atsuTags[] =
1303         {
1304             kATSUCGContextTag ,
1305         } ;
1306         ByteCount atsuSizes[sizeof(atsuTags)/sizeof(ATSUAttributeTag)] =
1307         {
1308             sizeof( CGContextRef ) ,
1309         } ;
1310         ATSUAttributeValuePtr    atsuValues[sizeof(atsuTags)/sizeof(ATSUAttributeTag)] =
1311         {
1312             &cgContext ,
1313         } ;
1314         status = ::ATSUSetLayoutControls(atsuLayout , sizeof(atsuTags)/sizeof(ATSUAttributeTag),
1315             atsuTags, atsuSizes, atsuValues ) ;
1316     }
1317
1318     ATSUTextMeasurement textBefore ;
1319     ATSUTextMeasurement textAfter ;
1320     ATSUTextMeasurement ascent ;
1321     ATSUTextMeasurement descent ;
1322
1323     status = ::ATSUGetUnjustifiedBounds( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd,
1324         &textBefore , &textAfter, &ascent , &descent );
1325     wxASSERT_MSG( status == noErr , wxT("couldn't measure the rotated text") );
1326
1327     Rect rect ;
1328
1329     if ( m_backgroundMode == wxSOLID )
1330     {
1331         wxGraphicPath* path = m_graphicContext->CreatePath() ;
1332         path->MoveToPoint(
1333             drawX ,
1334             drawY ) ;
1335         path->AddLineToPoint(
1336             drawX + sin(angle/RAD2DEG) * FixedToInt(ascent + descent) ,
1337             drawY + cos(angle/RAD2DEG) * FixedToInt(ascent + descent) ) ;
1338         path->AddLineToPoint(
1339             drawX + sin(angle/RAD2DEG) * FixedToInt(ascent + descent ) + cos(angle/RAD2DEG) * FixedToInt(textAfter) ,
1340             drawY + cos(angle/RAD2DEG) * FixedToInt(ascent + descent) - sin(angle/RAD2DEG) * FixedToInt(textAfter) ) ;
1341         path->AddLineToPoint(
1342             drawX + cos(angle/RAD2DEG) * FixedToInt(textAfter) ,
1343             drawY - sin(angle/RAD2DEG) * FixedToInt(textAfter) ) ;
1344
1345         m_graphicContext->FillPath( path , m_textBackgroundColour ) ;
1346         delete path ;
1347     }
1348
1349     drawX += (int)(sin(angle/RAD2DEG) * FixedToInt(ascent));
1350     drawY += (int)(cos(angle/RAD2DEG) * FixedToInt(ascent));
1351
1352     status = ::ATSUMeasureTextImage( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd,
1353         IntToFixed(drawX) , IntToFixed(drawY) , &rect );
1354     wxASSERT_MSG( status == noErr , wxT("couldn't measure the rotated text") );
1355
1356     CGContextSaveGState(dynamic_cast<wxMacCGContext*>(m_graphicContext)->GetNativeContext());
1357     CGContextTranslateCTM(dynamic_cast<wxMacCGContext*>(m_graphicContext)->GetNativeContext(), drawX, drawY);
1358     CGContextScaleCTM(dynamic_cast<wxMacCGContext*>(m_graphicContext)->GetNativeContext(), 1, -1);
1359     status = ::ATSUDrawText( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd,
1360         IntToFixed(0) , IntToFixed(0) );
1361     wxASSERT_MSG( status == noErr , wxT("couldn't draw the rotated text") );
1362     CGContextRestoreGState( dynamic_cast<wxMacCGContext*>(m_graphicContext)->GetNativeContext() ) ;
1363
1364     CalcBoundingBox(XDEV2LOG(rect.left), YDEV2LOG(rect.top) );
1365     CalcBoundingBox(XDEV2LOG(rect.right), YDEV2LOG(rect.bottom) );
1366
1367     ::ATSUDisposeTextLayout(atsuLayout);
1368 #if SIZEOF_WCHAR_T == 4
1369     free( ubuf ) ;
1370 #endif
1371 }
1372
1373 void  wxDC::DoDrawText(const wxString& strtext, wxCoord x, wxCoord y)
1374 {
1375     wxCHECK_RET(Ok(), wxT("wxDC::DoDrawText  Invalid DC"));
1376     DoDrawRotatedText( strtext , x , y , 0.0 ) ;
1377 }
1378
1379 bool  wxDC::CanGetTextExtent() const
1380 {
1381     wxCHECK_MSG(Ok(), false, wxT("Invalid DC"));
1382     return true ;
1383 }
1384
1385 void  wxDC::DoGetTextExtent( const wxString &str, wxCoord *width, wxCoord *height,
1386                             wxCoord *descent, wxCoord *externalLeading ,
1387                             wxFont *theFont ) const
1388 {
1389     wxCHECK_RET(Ok(), wxT("Invalid DC"));
1390     wxFont formerFont = m_font ;
1391     if ( theFont )
1392     {
1393         // work around the constness
1394         *((wxFont*)(&m_font)) = *theFont ;
1395         MacInstallFont() ;
1396     }
1397
1398     if ( str.Length() == 0 )
1399         return ;
1400
1401     wxCHECK_RET( m_macATSUIStyle != NULL , wxT("No valid font set") ) ;
1402
1403     OSStatus status = noErr ;
1404     ATSUTextLayout atsuLayout ;
1405     UniCharCount chars = str.Length() ;
1406     UniChar* ubuf = NULL ;
1407 #if SIZEOF_WCHAR_T == 4
1408         wxMBConvUTF16BE converter ;
1409 #if wxUSE_UNICODE
1410         size_t unicharlen = converter.WC2MB( NULL , str.wc_str() , 0 ) ;
1411         ubuf = (UniChar*) malloc( unicharlen + 2 ) ;
1412         converter.WC2MB( (char*) ubuf , str.wc_str(), unicharlen + 2 ) ;
1413 #else
1414     const wxWCharBuffer wchar = str.wc_str( wxConvLocal ) ;
1415         size_t unicharlen = converter.WC2MB( NULL , wchar.data()  , 0 ) ;
1416         ubuf = (UniChar*) malloc( unicharlen + 2 ) ;
1417         converter.WC2MB( (char*) ubuf , wchar.data() , unicharlen + 2 ) ;
1418 #endif
1419     chars = unicharlen / 2 ;
1420 #else
1421 #if wxUSE_UNICODE
1422     ubuf = (UniChar*) str.wc_str() ;
1423 #else
1424     wxWCharBuffer wchar = str.wc_str( wxConvLocal ) ;
1425     chars = wxWcslen( wchar.data() ) ;
1426     ubuf = (UniChar*) wchar.data() ;
1427 #endif
1428 #endif
1429
1430
1431     status = ::ATSUCreateTextLayoutWithTextPtr( (UniCharArrayPtr) ubuf , 0 , chars , chars , 1 ,
1432         &chars , (ATSUStyle*) &m_macATSUIStyle , &atsuLayout ) ;
1433
1434     wxASSERT_MSG( status == noErr , wxT("couldn't create the layout of the text") );
1435
1436     ATSUTextMeasurement textBefore ;
1437     ATSUTextMeasurement textAfter ;
1438     ATSUTextMeasurement textAscent ;
1439     ATSUTextMeasurement textDescent ;
1440
1441     status = ::ATSUGetUnjustifiedBounds( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd,
1442         &textBefore , &textAfter, &textAscent , &textDescent );
1443
1444     if ( height )
1445         *height = YDEV2LOGREL( FixedToInt(textAscent + textDescent) ) ;
1446     if ( descent )
1447         *descent =YDEV2LOGREL( FixedToInt(textDescent) );
1448     if ( externalLeading )
1449         *externalLeading = 0 ;
1450     if ( width )
1451         *width = XDEV2LOGREL( FixedToInt(textAfter - textBefore) ) ;
1452
1453     ::ATSUDisposeTextLayout(atsuLayout);
1454 #if SIZEOF_WCHAR_T == 4
1455     free( ubuf ) ;
1456 #endif
1457     if ( theFont )
1458     {
1459         // work around the constness
1460         *((wxFont*)(&m_font)) = formerFont ;
1461         MacInstallFont() ;
1462     }
1463 }
1464
1465
1466 bool wxDC::DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const
1467 {
1468     wxCHECK_MSG(Ok(), false, wxT("Invalid DC"));
1469
1470     widths.Empty();
1471     widths.Add(0, text.Length());
1472
1473     if (text.Length() == 0)
1474         return false;
1475
1476     wxFAIL_MSG( wxT("Unimplemented for Core Graphics") ) ;
1477
1478     return false;
1479 }
1480
1481 wxCoord   wxDC::GetCharWidth(void) const
1482 {
1483     wxCoord width ;
1484     DoGetTextExtent(wxT("g") , &width , NULL , NULL , NULL , NULL ) ;
1485     return width ;
1486 }
1487
1488 wxCoord   wxDC::GetCharHeight(void) const
1489 {
1490     wxCoord height ;
1491     DoGetTextExtent(wxT("g") , NULL , &height , NULL , NULL , NULL ) ;
1492     return height ;
1493 }
1494
1495 void  wxDC::Clear(void)
1496 {
1497     wxCHECK_RET(Ok(), wxT("Invalid DC"));
1498
1499     if ( m_backgroundBrush.Ok() && m_backgroundBrush.GetStyle() != wxTRANSPARENT)
1500     {
1501                 HIRect rect = CGRectMake( -10000 , -10000 , 20000 , 20000 ) ;
1502         switch( m_backgroundBrush.MacGetBrushKind() )
1503         {
1504             case kwxMacBrushTheme :
1505                 {
1506                 }
1507             break ;
1508             case kwxMacBrushThemeBackground :
1509                 {
1510                     HIThemeBackgroundDrawInfo drawInfo ;
1511                     drawInfo.version = 0 ;
1512                     drawInfo.state = kThemeStateActive ;
1513                     drawInfo.kind = m_backgroundBrush.MacGetThemeBackground(NULL) ;
1514                     HIThemeDrawBackground( &rect , &drawInfo, dynamic_cast<wxMacCGContext*>(m_graphicContext)->GetNativeContext() ,
1515                         kHIThemeOrientationNormal) ;
1516
1517                 }
1518             break ;
1519             case kwxMacBrushColour :
1520             {
1521                 RGBColor col = MAC_WXCOLORREF( m_backgroundBrush.GetColour().GetPixel()) ;
1522                 CGContextSetRGBFillColor( dynamic_cast<wxMacCGContext*>(m_graphicContext)->GetNativeContext() , col.red / 65536.0 , col.green / 65536.0 , col.blue / 65536.0 , 1.0 ) ;
1523                 CGContextFillRect(dynamic_cast<wxMacCGContext*>(m_graphicContext)->GetNativeContext(), rect);
1524
1525                 // reset to normal value
1526                 col = MAC_WXCOLORREF( GetBrush().GetColour().GetPixel() ) ;
1527                 CGContextSetRGBFillColor( dynamic_cast<wxMacCGContext*>(m_graphicContext)->GetNativeContext() , col.red / 65536.0 , col.green / 65536.0 , col.blue / 65536.0 , 1.0 ) ;
1528             }
1529             break ;
1530         }
1531     }
1532 }
1533
1534 void wxDC::MacInstallFont() const
1535 {
1536     wxCHECK_RET(Ok(), wxT("Invalid DC"));
1537
1538     if( m_macATSUIStyle )
1539     {
1540         ::ATSUDisposeStyle((ATSUStyle)m_macATSUIStyle);
1541         m_macATSUIStyle = NULL ;
1542     }
1543
1544     OSStatus status = noErr ;
1545     status = ATSUCreateAndCopyStyle( (ATSUStyle) m_font.MacGetATSUStyle() , (ATSUStyle*) &m_macATSUIStyle ) ;
1546     wxASSERT_MSG( status == noErr , wxT("couldn't set create ATSU style") ) ;
1547
1548     Fixed atsuSize = IntToFixed( int(m_scaleY * m_font.MacGetFontSize()) ) ;
1549     RGBColor atsuColor = MAC_WXCOLORREF( m_textForegroundColour.GetPixel() ) ;
1550     ATSUAttributeTag atsuTags[] =
1551     {
1552             kATSUSizeTag ,
1553             kATSUColorTag ,
1554     } ;
1555     ByteCount atsuSizes[sizeof(atsuTags)/sizeof(ATSUAttributeTag)] =
1556     {
1557             sizeof( Fixed ) ,
1558             sizeof( RGBColor ) ,
1559     } ;
1560 //    Boolean kTrue = true ;
1561 //    Boolean kFalse = false ;
1562
1563 //    ATSUVerticalCharacterType kHorizontal = kATSUStronglyHorizontal;
1564     ATSUAttributeValuePtr    atsuValues[sizeof(atsuTags)/sizeof(ATSUAttributeTag)] =
1565     {
1566             &atsuSize ,
1567             &atsuColor ,
1568     } ;
1569     status = ::ATSUSetAttributes((ATSUStyle)m_macATSUIStyle, sizeof(atsuTags)/sizeof(ATSUAttributeTag) ,
1570         atsuTags, atsuSizes, atsuValues);
1571
1572     wxASSERT_MSG( status == noErr , wxT("couldn't Modify ATSU style") ) ;
1573 }
1574
1575 // ---------------------------------------------------------------------------
1576 // coordinates transformations
1577 // ---------------------------------------------------------------------------
1578
1579 wxCoord wxDCBase::DeviceToLogicalX(wxCoord x) const
1580 {
1581     return ((wxDC *)this)->XDEV2LOG(x);
1582 }
1583
1584 wxCoord wxDCBase::DeviceToLogicalY(wxCoord y) const
1585 {
1586     return ((wxDC *)this)->YDEV2LOG(y);
1587 }
1588
1589 wxCoord wxDCBase::DeviceToLogicalXRel(wxCoord x) const
1590 {
1591     return ((wxDC *)this)->XDEV2LOGREL(x);
1592 }
1593
1594 wxCoord wxDCBase::DeviceToLogicalYRel(wxCoord y) const
1595 {
1596     return ((wxDC *)this)->YDEV2LOGREL(y);
1597 }
1598
1599 wxCoord wxDCBase::LogicalToDeviceX(wxCoord x) const
1600 {
1601     return ((wxDC *)this)->XLOG2DEV(x);
1602 }
1603
1604 wxCoord wxDCBase::LogicalToDeviceY(wxCoord y) const
1605 {
1606     return ((wxDC *)this)->YLOG2DEV(y);
1607 }
1608
1609 wxCoord wxDCBase::LogicalToDeviceXRel(wxCoord x) const
1610 {
1611     return ((wxDC *)this)->XLOG2DEVREL(x);
1612 }
1613
1614 wxCoord wxDCBase::LogicalToDeviceYRel(wxCoord y) const
1615 {
1616     return ((wxDC *)this)->YLOG2DEVREL(y);
1617 }
1618
1619 #endif // wxMAC_USE_CORE_GRAPHICS
1620