src/mac/carbon/dc.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/mac/carbon/dc.cpp
   3 // Purpose:     wxDC class
   4 // Author:      Stefan Csomor
   5 // Modified by:
   6 // Created:     01/02/97
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Stefan Csomor
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #include "wx/wxprec.h"
  13
  14 #include "wx/dc.h"
  15
  16 #if !wxMAC_USE_CORE_GRAPHICS
  17
  18 #ifndef WX_PRECOMP
  19     #include "wx/log.h"
  20     #include "wx/app.h"
  21     #include "wx/dcmemory.h"
  22     #include "wx/dcprint.h"
  23 #endif
  24
  25 #include "wx/mac/uma.h"
  26 #include "wx/region.h"
  27 #include "wx/image.h"
  28
  29 #ifdef __MSL__
  30     #if __MSL__ >= 0x6000
  31         namespace std {}
  32         using namespace std ;
  33     #endif
  34 #endif
  35
  36 #include "wx/mac/private.h"
  37 #ifndef __DARWIN__
  38 #include <ATSUnicode.h>
  39 #include <TextCommon.h>
  40 #include <TextEncodingConverter.h>
  41 #endif
  42
  43
  44 // set to 0 if problems arise
  45 #define wxMAC_EXPERIMENTAL_DC 1
  46
  47
  48 IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
  49
  50 //-----------------------------------------------------------------------------
  51 // constants
  52 //-----------------------------------------------------------------------------
  53
  54 const double RAD2DEG  = 180.0 / M_PI;
  55 const short kEmulatedMode = -1 ;
  56 const short kUnsupportedMode = -2 ;
  57
  58 extern TECObjectRef s_TECNativeCToUnicode ;
  59
  60
  61 wxMacPortSetter::wxMacPortSetter( const wxDC* dc ) :
  62     m_ph( (GrafPtr) dc->m_macPort )
  63 {
  64     wxASSERT( dc->Ok() ) ;
  65     m_dc = dc ;
  66     dc->MacSetupPort(&m_ph) ;
  67 }
  68
  69 wxMacPortSetter::~wxMacPortSetter()
  70 {
  71     m_dc->MacCleanupPort(&m_ph) ;
  72 }
  73
  74 #if wxMAC_EXPERIMENTAL_DC
  75 class wxMacFastPortSetter
  76 {
  77 public :
  78     wxMacFastPortSetter( const wxDC *dc )
  79     {
  80         wxASSERT( dc->Ok() ) ;
  81         m_swapped = QDSwapPort( (GrafPtr) dc->m_macPort , &m_oldPort ) ;
  82         m_clipRgn = NewRgn() ;
  83         GetClip( m_clipRgn ) ;
  84         m_dc = dc ;
  85         dc->MacSetupPort( NULL ) ;
  86     }
  87
  88     ~wxMacFastPortSetter()
  89     {
  90         // SetPort( (GrafPtr) m_dc->m_macPort ) ;
  91         SetClip( m_clipRgn ) ;
  92         if ( m_swapped )
  93             SetPort( m_oldPort ) ;
  94         m_dc->MacCleanupPort( NULL ) ;
  95         DisposeRgn( m_clipRgn ) ;
  96     }
  97
  98 private :
  99     bool m_swapped ;
 100     RgnHandle m_clipRgn ;
 101     GrafPtr m_oldPort ;
 102     const wxDC*   m_dc ;
 103 } ;
 104
 105 #else
 106 typedef wxMacPortSetter wxMacFastPortSetter ;
 107 #endif
 108
 109 wxMacWindowClipper::wxMacWindowClipper( const wxWindow* win ) :
 110     wxMacPortSaver( (GrafPtr) GetWindowPort((WindowRef) win->MacGetTopLevelWindowRef()) )
 111 {
 112     m_newPort =(GrafPtr) GetWindowPort((WindowRef) win->MacGetTopLevelWindowRef()) ;
 113     m_formerClip = NewRgn() ;
 114     m_newClip = NewRgn() ;
 115     GetClip( m_formerClip ) ;
 116
 117     if ( win )
 118     {
 119         // guard against half constructed objects, this just leads to a empty clip
 120         if ( win->GetPeer() )
 121         {
 122             int x = 0 , y = 0;
 123             win->MacWindowToRootWindow( &x, &y ) ;
 124
 125             // get area including focus rect
 126             CopyRgn( (RgnHandle) ((wxWindow*)win)->MacGetVisibleRegion(true).GetWXHRGN() , m_newClip ) ;
 127             if ( !EmptyRgn( m_newClip ) )
 128                 OffsetRgn( m_newClip , x , y ) ;
 129         }
 130
 131         SetClip( m_newClip ) ;
 132     }
 133 }
 134
 135 wxMacWindowClipper::~wxMacWindowClipper()
 136 {
 137     SetPort( m_newPort ) ;
 138     SetClip( m_formerClip ) ;
 139     DisposeRgn( m_newClip ) ;
 140     DisposeRgn( m_formerClip ) ;
 141 }
 142
 143 wxMacWindowStateSaver::wxMacWindowStateSaver( const wxWindow* win ) :
 144     wxMacWindowClipper( win )
 145 {
 146     // the port is already set at this point
 147     m_newPort = (GrafPtr) GetWindowPort((WindowRef) win->MacGetTopLevelWindowRef()) ;
 148     GetThemeDrawingState( &m_themeDrawingState ) ;
 149 }
 150
 151 wxMacWindowStateSaver::~wxMacWindowStateSaver()
 152 {
 153     SetPort( m_newPort ) ;
 154     SetThemeDrawingState( m_themeDrawingState , true ) ;
 155 }
 156
 157 //-----------------------------------------------------------------------------
 158 // Local functions
 159 //-----------------------------------------------------------------------------
 160 static inline double dmin(double a, double b) { return a < b ? a : b; }
 161 static inline double dmax(double a, double b) { return a > b ? a : b; }
 162 static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; }
 163
 164 //-----------------------------------------------------------------------------
 165 // wxDC
 166 //-----------------------------------------------------------------------------
 167 // this function emulates all wx colour manipulations, used to verify the implementation
 168 // by setting the mode in the blitting functions to kEmulatedMode
 169 void wxMacCalculateColour( int logical_func , const RGBColor &srcColor , RGBColor &dstColor ) ;
 170
 171 void wxMacCalculateColour( int logical_func , const RGBColor &srcColor , RGBColor &dstColor )
 172 {
 173     switch ( logical_func )
 174     {
 175         case wxAND:        // src AND dst
 176             dstColor.red = dstColor.red & srcColor.red ;
 177             dstColor.green = dstColor.green & srcColor.green ;
 178             dstColor.blue = dstColor.blue & srcColor.blue ;
 179             break ;
 180
 181         case wxAND_INVERT: // (NOT src) AND dst
 182             dstColor.red = dstColor.red & ~srcColor.red ;
 183             dstColor.green = dstColor.green & ~srcColor.green ;
 184             dstColor.blue = dstColor.blue & ~srcColor.blue ;
 185             break ;
 186
 187         case wxAND_REVERSE:// src AND (NOT dst)
 188             dstColor.red = ~dstColor.red & srcColor.red ;
 189             dstColor.green = ~dstColor.green & srcColor.green ;
 190             dstColor.blue = ~dstColor.blue & srcColor.blue ;
 191             break ;
 192
 193         case wxCLEAR:      // 0
 194             dstColor.red = 0 ;
 195             dstColor.green = 0 ;
 196             dstColor.blue = 0 ;
 197             break ;
 198
 199         case wxCOPY:       // src
 200             dstColor.red = srcColor.red ;
 201             dstColor.green = srcColor.green ;
 202             dstColor.blue = srcColor.blue ;
 203             break ;
 204
 205         case wxEQUIV:      // (NOT src) XOR dst
 206             dstColor.red = dstColor.red ^ ~srcColor.red ;
 207             dstColor.green = dstColor.green ^ ~srcColor.green ;
 208             dstColor.blue = dstColor.blue ^ ~srcColor.blue ;
 209             break ;
 210
 211         case wxINVERT:     // NOT dst
 212             dstColor.red = ~dstColor.red ;
 213             dstColor.green = ~dstColor.green ;
 214             dstColor.blue = ~dstColor.blue ;
 215             break ;
 216
 217         case wxNAND:       // (NOT src) OR (NOT dst)
 218             dstColor.red = ~dstColor.red | ~srcColor.red ;
 219             dstColor.green = ~dstColor.green | ~srcColor.green ;
 220             dstColor.blue = ~dstColor.blue | ~srcColor.blue ;
 221             break ;
 222
 223         case wxNOR:        // (NOT src) AND (NOT dst)
 224             dstColor.red = ~dstColor.red & ~srcColor.red ;
 225             dstColor.green = ~dstColor.green & ~srcColor.green ;
 226             dstColor.blue = ~dstColor.blue & ~srcColor.blue ;
 227             break ;
 228
 229         case wxOR:         // src OR dst
 230             dstColor.red = dstColor.red | srcColor.red ;
 231             dstColor.green = dstColor.green | srcColor.green ;
 232             dstColor.blue = dstColor.blue | srcColor.blue ;
 233             break ;
 234
 235         case wxOR_INVERT:  // (NOT src) OR dst
 236             dstColor.red = dstColor.red | ~srcColor.red ;
 237             dstColor.green = dstColor.green | ~srcColor.green ;
 238             dstColor.blue = dstColor.blue | ~srcColor.blue ;
 239             break ;
 240
 241         case wxOR_REVERSE: // src OR (NOT dst)
 242             dstColor.red = ~dstColor.red | srcColor.red ;
 243             dstColor.green = ~dstColor.green | srcColor.green ;
 244             dstColor.blue = ~dstColor.blue | srcColor.blue ;
 245             break ;
 246
 247         case wxSET:        // 1
 248             dstColor.red = 0xFFFF ;
 249             dstColor.green = 0xFFFF ;
 250             dstColor.blue = 0xFFFF ;
 251             break ;
 252
 253         case wxSRC_INVERT: // (NOT src)
 254             dstColor.red = ~srcColor.red ;
 255             dstColor.green = ~srcColor.green ;
 256             dstColor.blue = ~srcColor.blue ;
 257             break ;
 258
 259         case wxXOR:        // src XOR dst
 260             dstColor.red = dstColor.red ^ srcColor.red ;
 261             dstColor.green = dstColor.green ^ srcColor.green ;
 262             dstColor.blue = dstColor.blue ^ srcColor.blue ;
 263             break ;
 264
 265         case wxNO_OP:      // dst
 266         default:
 267             break ;
 268     }
 269 }
 270
 271 wxDC::wxDC()
 272 {
 273     m_ok = false;
 274     m_colour = true;
 275     m_mm_to_pix_x = mm2pt;
 276     m_mm_to_pix_y = mm2pt;
 277     m_internalDeviceOriginX = 0;
 278     m_internalDeviceOriginY = 0;
 279     m_externalDeviceOriginX = 0;
 280     m_externalDeviceOriginY = 0;
 281     m_logicalScaleX = 1.0;
 282     m_logicalScaleY = 1.0;
 283     m_userScaleX = 1.0;
 284     m_userScaleY = 1.0;
 285     m_scaleX = 1.0;
 286     m_scaleY = 1.0;
 287     m_needComputeScaleX = false;
 288     m_needComputeScaleY = false;
 289     m_macPort = NULL ;
 290     m_macMask = NULL ;
 291     m_macFontInstalled = false ;
 292     m_macBrushInstalled = false ;
 293     m_macPenInstalled = false ;
 294     m_macLocalOrigin.x = m_macLocalOrigin.y = 0 ;
 295     m_macBoundaryClipRgn = NewRgn() ;
 296     m_macCurrentClipRgn = NewRgn() ;
 297     SetRectRgn( (RgnHandle) m_macBoundaryClipRgn , -32000 , -32000 , 32000 , 32000 ) ;
 298     SetRectRgn( (RgnHandle) m_macCurrentClipRgn , -32000 , -32000 , 32000 , 32000 ) ;
 299     m_pen = *wxBLACK_PEN;
 300     m_font = *wxNORMAL_FONT;
 301     m_brush = *wxWHITE_BRUSH;
 302
 303 #ifdef __WXDEBUG__
 304     // needed to debug possible errors with two active drawing methods at the same time on
 305     // the same DC
 306     m_macCurrentPortStateHelper = NULL ;
 307 #endif
 308
 309     m_macATSUIStyle = NULL ;
 310     m_macAliasWasEnabled = false;
 311     m_macForegroundPixMap = NULL ;
 312     m_macBackgroundPixMap = NULL ;
 313 }
 314
 315 wxDC::~wxDC(void)
 316 {
 317     DisposeRgn( (RgnHandle) m_macBoundaryClipRgn ) ;
 318     DisposeRgn( (RgnHandle) m_macCurrentClipRgn ) ;
 319 }
 320
 321 void wxDC::MacSetupPort(wxMacPortStateHelper* help) const
 322 {
 323 #ifdef __WXDEBUG__
 324     wxASSERT( m_macCurrentPortStateHelper == NULL ) ;
 325     m_macCurrentPortStateHelper = help ;
 326 #endif
 327
 328     SetClip( (RgnHandle) m_macCurrentClipRgn);
 329
 330 #if ! wxMAC_EXPERIMENTAL_DC
 331     m_macFontInstalled = false ;
 332     m_macBrushInstalled = false ;
 333     m_macPenInstalled = false ;
 334 #endif
 335 }
 336
 337 void wxDC::MacCleanupPort(wxMacPortStateHelper* help) const
 338 {
 339 #ifdef __WXDEBUG__
 340     wxASSERT( m_macCurrentPortStateHelper == help ) ;
 341     m_macCurrentPortStateHelper = NULL ;
 342 #endif
 343
 344     if ( m_macATSUIStyle )
 345     {
 346         ::ATSUDisposeStyle((ATSUStyle)m_macATSUIStyle);
 347         m_macATSUIStyle = NULL ;
 348     }
 349
 350     if ( m_macAliasWasEnabled )
 351     {
 352         SetAntiAliasedTextEnabled(m_macFormerAliasState, m_macFormerAliasSize);
 353         m_macAliasWasEnabled = false ;
 354     }
 355
 356     if ( m_macForegroundPixMap )
 357     {
 358         Pattern blackColor ;
 359         ::PenPat(GetQDGlobalsBlack(&blackColor));
 360         DisposePixPat( (PixPatHandle) m_macForegroundPixMap ) ;
 361         m_macForegroundPixMap = NULL ;
 362     }
 363
 364     if ( m_macBackgroundPixMap )
 365     {
 366         Pattern whiteColor ;
 367         ::BackPat(GetQDGlobalsWhite(&whiteColor));
 368         DisposePixPat( (PixPatHandle) m_macBackgroundPixMap ) ;
 369         m_macBackgroundPixMap = NULL ;
 370     }
 371 }
 372
 373 void wxDC::DoDrawBitmap( const wxBitmap &bmp, wxCoord x, wxCoord y, bool useMask )
 374 {
 375      wxCHECK_RET( Ok(), wxT("wxDC::DoDrawBitmap - invalid DC") );
 376      wxCHECK_RET( bmp.Ok(), wxT("wxDC::DoDrawBitmap - invalid bitmap") );
 377
 378      wxMacFastPortSetter helper(this) ;
 379      wxCoord xx = XLOG2DEVMAC(x);
 380      wxCoord yy = YLOG2DEVMAC(y);
 381      wxCoord w = bmp.GetWidth();
 382      wxCoord h = bmp.GetHeight();
 383      wxCoord ww = XLOG2DEVREL(w);
 384      wxCoord hh = YLOG2DEVREL(h);
 385
 386      // Set up drawing mode
 387      short  mode = (m_logicalFunction == wxCOPY ? srcCopy :
 388                     //m_logicalFunction == wxCLEAR ? WHITENESS :
 389                     //m_logicalFunction == wxSET ? BLACKNESS :
 390                     m_logicalFunction == wxINVERT ? hilite :
 391                    //m_logicalFunction == wxAND ? MERGECOPY :
 392                     m_logicalFunction == wxOR ? srcOr :
 393                     m_logicalFunction == wxSRC_INVERT ? notSrcCopy :
 394                     m_logicalFunction == wxXOR ? srcXor :
 395                     m_logicalFunction == wxOR_REVERSE ? notSrcOr :
 396                     //m_logicalFunction == wxAND_REVERSE ? SRCERASE :
 397                     //m_logicalFunction == wxSRC_OR ? srcOr :
 398                     //m_logicalFunction == wxSRC_AND ? SRCAND :
 399                     srcCopy );
 400
 401      GWorldPtr maskworld = NULL ;
 402      GWorldPtr bmapworld = MAC_WXHBITMAP( bmp.GetHBITMAP((WXHBITMAP*)&maskworld) );
 403      PixMapHandle bmappixels ;
 404
 405      // Set foreground and background colours (for bitmaps depth = 1)
 406      if (bmp.GetDepth() == 1)
 407      {
 408          RGBColor fore = MAC_WXCOLORREF(m_textForegroundColour.GetPixel());
 409          RGBColor back = MAC_WXCOLORREF(m_textBackgroundColour.GetPixel());
 410          RGBForeColor(&fore);
 411          RGBBackColor(&back);
 412      }
 413      else
 414      {
 415          RGBColor white = { 0xFFFF, 0xFFFF, 0xFFFF } ;
 416          RGBColor black = { 0, 0, 0 } ;
 417          RGBForeColor( &black ) ;
 418          RGBBackColor( &white ) ;
 419      }
 420      bmappixels = GetGWorldPixMap( bmapworld ) ;
 421
 422      wxCHECK_RET(LockPixels(bmappixels),
 423                  wxT("wxDC::DoDrawBitmap - failed to lock pixels"));
 424
 425      Rect source = { 0, 0, h, w };
 426      Rect dest   = { yy, xx, yy + hh, xx + ww };
 427      if ( useMask && maskworld )
 428      {
 429          if ( LockPixels(GetGWorldPixMap(MAC_WXHBITMAP(maskworld))))
 430          {
 431              CopyDeepMask
 432                  (
 433                   GetPortBitMapForCopyBits(bmapworld),
 434                   GetPortBitMapForCopyBits(MAC_WXHBITMAP(maskworld)),
 435                   GetPortBitMapForCopyBits( MAC_WXHBITMAP(m_macPort) ),
 436                   &source, &source, &dest, mode, NULL
 437                   );
 438              UnlockPixels(GetGWorldPixMap(MAC_WXHBITMAP(maskworld)));
 439          }
 440      }
 441      else
 442      {
 443          CopyBits( GetPortBitMapForCopyBits( bmapworld ),
 444                    GetPortBitMapForCopyBits( MAC_WXHBITMAP(m_macPort) ),
 445                    &source, &dest, mode, NULL ) ;
 446      }
 447      UnlockPixels( bmappixels ) ;
 448
 449      m_macPenInstalled = false ;
 450      m_macBrushInstalled = false ;
 451      m_macFontInstalled = false ;
 452 }
 453
 454 void wxDC::DoDrawIcon( const wxIcon &icon, wxCoord x, wxCoord y )
 455 {
 456     wxCHECK_RET(Ok(), wxT("wxDC::DoDrawIcon - invalid DC"));
 457     wxCHECK_RET(icon.Ok(), wxT("wxDC::DoDrawIcon - invalid icon"));
 458
 459     wxMacFastPortSetter helper(this) ;
 460
 461     wxCoord xx = XLOG2DEVMAC(x);
 462     wxCoord yy = YLOG2DEVMAC(y);
 463     wxCoord w = icon.GetWidth();
 464     wxCoord h = icon.GetHeight();
 465     wxCoord ww = XLOG2DEVREL(w);
 466     wxCoord hh = YLOG2DEVREL(h);
 467
 468     Rect r = { yy , xx, yy + hh, xx + ww } ;
 469     PlotIconRef( &r , kAlignNone , kTransformNone , kPlotIconRefNormalFlags , MAC_WXHICON( icon.GetHICON() ) ) ;
 470 }
 471
 472 void wxDC::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
 473 {
 474     wxCHECK_RET(Ok(), wxT("wxDC::DoSetClippingRegion - invalid DC"));
 475
 476     wxCoord xx, yy, ww, hh;
 477     xx = XLOG2DEVMAC(x);
 478     yy = YLOG2DEVMAC(y);
 479     ww = XLOG2DEVREL(width);
 480     hh = YLOG2DEVREL(height);
 481
 482     SetRectRgn( (RgnHandle) m_macCurrentClipRgn , xx , yy , xx + ww , yy + hh ) ;
 483     SectRgn( (RgnHandle) m_macCurrentClipRgn , (RgnHandle) m_macBoundaryClipRgn , (RgnHandle) m_macCurrentClipRgn ) ;
 484     if ( m_clipping )
 485     {
 486         m_clipX1 = wxMax( m_clipX1 , xx );
 487         m_clipY1 = wxMax( m_clipY1 , yy );
 488         m_clipX2 = wxMin( m_clipX2, (xx + ww) );
 489         m_clipY2 = wxMin( m_clipY2, (yy + hh) );
 490     }
 491     else
 492     {
 493         m_clipping = true;
 494         m_clipX1 = xx;
 495         m_clipY1 = yy;
 496         m_clipX2 = xx + ww;
 497         m_clipY2 = yy + hh;
 498     }
 499 }
 500
 501 void wxDC::DoSetClippingRegionAsRegion( const wxRegion &region )
 502 {
 503     wxCHECK_RET(Ok(), wxT("wxDC::DoSetClippingRegionAsRegion - invalid DC"));
 504
 505     wxMacFastPortSetter helper(this) ;
 506     wxCoord x, y, w, h;
 507     region.GetBox( x, y, w, h );
 508     wxCoord xx, yy, ww, hh;
 509     xx = XLOG2DEVMAC(x);
 510     yy = YLOG2DEVMAC(y);
 511     ww = XLOG2DEVREL(w);
 512     hh = YLOG2DEVREL(h);
 513
 514     // if we have a scaling that we cannot map onto native regions
 515     // we must use the box
 516     if ( ww != w || hh != h )
 517     {
 518         wxDC::DoSetClippingRegion( x, y, w, h );
 519     }
 520     else
 521     {
 522         CopyRgn( (RgnHandle) region.GetWXHRGN() , (RgnHandle) m_macCurrentClipRgn ) ;
 523         if ( xx != x || yy != y )
 524             OffsetRgn( (RgnHandle) m_macCurrentClipRgn , xx - x , yy - y ) ;
 525
 526         SectRgn( (RgnHandle) m_macCurrentClipRgn , (RgnHandle) m_macBoundaryClipRgn , (RgnHandle) m_macCurrentClipRgn ) ;
 527         if ( m_clipping )
 528         {
 529             m_clipX1 = wxMax( m_clipX1 , xx );
 530             m_clipY1 = wxMax( m_clipY1 , yy );
 531             m_clipX2 = wxMin( m_clipX2, (xx + ww) );
 532             m_clipY2 = wxMin( m_clipY2, (yy + hh) );
 533         }
 534         else
 535         {
 536             m_clipping = true;
 537             m_clipX1 = xx;
 538             m_clipY1 = yy;
 539             m_clipX2 = xx + ww;
 540             m_clipY2 = yy + hh;
 541         }
 542     }
 543 }
 544
 545 void wxDC::DestroyClippingRegion()
 546 {
 547     wxMacFastPortSetter helper(this) ;
 548
 549     CopyRgn( (RgnHandle) m_macBoundaryClipRgn , (RgnHandle) m_macCurrentClipRgn ) ;
 550     ResetClipping();
 551 }
 552
 553 void wxDC::DoGetSizeMM( int* width, int* height ) const
 554 {
 555     int w = 0, h = 0;
 556
 557     GetSize( &w, &h );
 558     if (width)
 559         *width = long( double(w) / (m_scaleX * m_mm_to_pix_x) );
 560     if (height)
 561         *height = long( double(h) / (m_scaleY * m_mm_to_pix_y) );
 562 }
 563
 564 void wxDC::SetTextForeground( const wxColour &col )
 565 {
 566     wxCHECK_RET(Ok(), wxT("wxDC::SetTextForeground - invalid DC"));
 567
 568     m_textForegroundColour = col;
 569     m_macFontInstalled = false ;
 570 }
 571
 572 void wxDC::SetTextBackground( const wxColour &col )
 573 {
 574     wxCHECK_RET(Ok(), wxT("wxDC::SetTextBackground - invalid DC"));
 575
 576     m_textBackgroundColour = col;
 577     m_macFontInstalled = false ;
 578 }
 579
 580 void wxDC::SetMapMode( int mode )
 581 {
 582     switch (mode)
 583     {
 584     case wxMM_TWIPS:
 585         SetLogicalScale( twips2mm * m_mm_to_pix_x, twips2mm * m_mm_to_pix_y );
 586         break;
 587
 588     case wxMM_POINTS:
 589         SetLogicalScale( pt2mm * m_mm_to_pix_x, pt2mm * m_mm_to_pix_y );
 590         break;
 591
 592     case wxMM_METRIC:
 593         SetLogicalScale( m_mm_to_pix_x, m_mm_to_pix_y );
 594         break;
 595
 596     case wxMM_LOMETRIC:
 597         SetLogicalScale( m_mm_to_pix_x / 10.0, m_mm_to_pix_y / 10.0 );
 598         break;
 599
 600     default:
 601     case wxMM_TEXT:
 602         SetLogicalScale( 1.0, 1.0 );
 603         break;
 604     }
 605
 606     if (mode != wxMM_TEXT)
 607     {
 608         m_needComputeScaleX = true;
 609         m_needComputeScaleY = true;
 610     }
 611 }
 612
 613 void wxDC::SetUserScale( double x, double y )
 614 {
 615     // allow negative ? -> no
 616     m_userScaleX = x;
 617     m_userScaleY = y;
 618     ComputeScaleAndOrigin();
 619 }
 620
 621 void wxDC::SetLogicalScale( double x, double y )
 622 {
 623     // allow negative ?
 624     m_logicalScaleX = x;
 625     m_logicalScaleY = y;
 626     ComputeScaleAndOrigin();
 627 }
 628
 629 void wxDC::SetLogicalOrigin( wxCoord x, wxCoord y )
 630 {
 631     // is this still correct ?
 632     m_logicalOriginX = x * m_signX;
 633     m_logicalOriginY = y * m_signY;
 634     ComputeScaleAndOrigin();
 635 }
 636
 637 void wxDC::SetDeviceOrigin( wxCoord x, wxCoord y )
 638 {
 639     m_externalDeviceOriginX = x;
 640     m_externalDeviceOriginY = y;
 641     ComputeScaleAndOrigin();
 642 }
 643
 644 void wxDC::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
 645 {
 646     m_signX = (xLeftRight ?  1 : -1);
 647     m_signY = (yBottomUp  ? -1 :  1);
 648     ComputeScaleAndOrigin();
 649 }
 650
 651 wxSize wxDC::GetPPI() const
 652 {
 653     return wxSize(72, 72);
 654 }
 655
 656 int wxDC::GetDepth() const
 657 {
 658     if ( IsPortColor( (CGrafPtr) m_macPort ) )
 659         return ( (**GetPortPixMap( (CGrafPtr) m_macPort)).pixelSize ) ;
 660
 661     return 1 ;
 662 }
 663
 664 void wxDC::ComputeScaleAndOrigin()
 665 {
 666     // CMB: copy scale to see if it changes
 667     double origScaleX = m_scaleX;
 668     double origScaleY = m_scaleY;
 669     m_scaleX = m_logicalScaleX * m_userScaleX;
 670     m_scaleY = m_logicalScaleY * m_userScaleY;
 671     m_deviceOriginX = m_internalDeviceOriginX + m_externalDeviceOriginX;
 672     m_deviceOriginY = m_internalDeviceOriginY + m_externalDeviceOriginY;
 673
 674     // CMB: if scale has changed call SetPen to recalulate the line width
 675     if (m_scaleX != origScaleX || m_scaleY != origScaleY)
 676     {
 677         // this is a bit artificial, but we need to force wxDC to think
 678         // the pen has changed
 679         wxPen pen(GetPen());
 680         m_pen = wxNullPen;
 681         SetPen(pen);
 682     }
 683 }
 684
 685 void wxDC::SetPalette( const wxPalette& palette )
 686 {
 687 }
 688
 689 void wxDC::SetBackgroundMode( int mode )
 690 {
 691     m_backgroundMode = mode ;
 692 }
 693
 694 void wxDC::SetFont( const wxFont &font )
 695 {
 696     m_font = font;
 697     m_macFontInstalled = false ;
 698 }
 699
 700 void wxDC::SetPen( const wxPen &pen )
 701 {
 702     if ( m_pen == pen )
 703         return ;
 704
 705     m_pen = pen;
 706     m_macPenInstalled = false ;
 707 }
 708
 709 void wxDC::SetBrush( const wxBrush &brush )
 710 {
 711     if (m_brush == brush)
 712         return;
 713
 714     m_brush = brush;
 715     m_macBrushInstalled = false ;
 716 }
 717
 718 void wxDC::SetBackground( const wxBrush &brush )
 719 {
 720     if (m_backgroundBrush == brush)
 721         return;
 722
 723     m_backgroundBrush = brush;
 724     if (m_backgroundBrush.Ok())
 725         m_macBrushInstalled = false ;
 726 }
 727
 728 void wxDC::SetLogicalFunction( int function )
 729 {
 730     if (m_logicalFunction == function)
 731         return;
 732
 733     m_logicalFunction = function ;
 734     m_macFontInstalled = false ;
 735     m_macBrushInstalled = false ;
 736     m_macPenInstalled = false ;
 737 }
 738
 739 extern bool wxDoFloodFill(wxDC *dc, wxCoord x, wxCoord y,
 740                           const wxColour & col, int style);
 741
 742 bool wxDC::DoFloodFill(wxCoord x, wxCoord y,
 743                        const wxColour& col, int style)
 744 {
 745     return wxDoFloodFill(this, x, y, col, style);
 746 }
 747
 748 bool wxDC::DoGetPixel( wxCoord x, wxCoord y, wxColour *col ) const
 749 {
 750     wxCHECK_MSG( Ok(), false, wxT("wxDC::DoGetPixel - invalid DC") );
 751
 752     wxMacFastPortSetter helper(this) ;
 753
 754     // NOTE: Get/SetCPixel are slow!
 755     RGBColor colour;
 756     GetCPixel( XLOG2DEVMAC(x), YLOG2DEVMAC(y), &colour );
 757
 758     // convert from Mac colour to wx
 759     col->Set( colour.red >> 8, colour.green >> 8, colour.blue >> 8);
 760
 761     return true ;
 762 }
 763
 764 void wxDC::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 )
 765 {
 766     wxCHECK_RET(Ok(), wxT("wxDC::DoDrawLine - invalid DC"));
 767
 768     wxMacFastPortSetter helper(this) ;
 769
 770     if (m_pen.GetStyle() != wxTRANSPARENT)
 771     {
 772         MacInstallPen() ;
 773         wxCoord offset = ( (m_pen.GetWidth() == 0 ? 1 :
 774             m_pen.GetWidth() ) * (wxCoord)m_scaleX - 1) / 2;
 775         wxCoord xx1 = XLOG2DEVMAC(x1) - offset;
 776         wxCoord yy1 = YLOG2DEVMAC(y1) - offset;
 777         wxCoord xx2 = XLOG2DEVMAC(x2) - offset;
 778         wxCoord yy2 = YLOG2DEVMAC(y2) - offset;
 779
 780         if ((m_pen.GetCap() == wxCAP_ROUND) &&
 781             (m_pen.GetWidth() <= 1))
 782         {
 783             // Implement LAST_NOT for MAC at least for
 784             // orthogonal lines. RR.
 785             if (xx1 == xx2)
 786             {
 787                 if (yy1 < yy2)
 788                     yy2--;
 789                 if (yy1 > yy2)
 790                     yy2++;
 791             }
 792
 793             if (yy1 == yy2)
 794             {
 795                 if (xx1 < xx2)
 796                     xx2--;
 797                 if (xx1 > xx2)
 798                     xx2++;
 799             }
 800         }
 801
 802         ::MoveTo(xx1, yy1);
 803         ::LineTo(xx2, yy2);
 804     }
 805 }
 806
 807 void wxDC::DoCrossHair( wxCoord x, wxCoord y )
 808 {
 809     wxCHECK_RET(Ok(), wxT("wxDC::DoCrossHair - invalid DC"));
 810
 811     wxMacFastPortSetter helper(this) ;
 812
 813     if (m_pen.GetStyle() != wxTRANSPARENT)
 814     {
 815         int w = 0, h = 0;
 816
 817         GetSize( &w, &h );
 818         wxCoord xx = XLOG2DEVMAC(x);
 819         wxCoord yy = YLOG2DEVMAC(y);
 820
 821         MacInstallPen();
 822         ::MoveTo( XLOG2DEVMAC(0), yy );
 823         ::LineTo( XLOG2DEVMAC(w), yy );
 824         ::MoveTo( xx, YLOG2DEVMAC(0) );
 825         ::LineTo( xx, YLOG2DEVMAC(h) );
 826         CalcBoundingBox(x, y);
 827         CalcBoundingBox(x + w, y + h);
 828     }
 829 }
 830
 831 /*
 832 * To draw arcs properly the angles need to be converted from the WX style:
 833 * Angles start on the +ve X axis and go anti-clockwise (As you would draw on
 834 * a normal axis on paper).
 835 * TO
 836 * the Mac style:
 837 * Angles start on the +ve y axis and go clockwise.
 838 */
 839
 840 static double wxConvertWXangleToMACangle(double angle)
 841 {
 842     double newAngle = 90 - angle ;
 843
 844     while ( newAngle > 360 )
 845         newAngle -= 360 ;
 846     while ( newAngle < 0 )
 847         newAngle += 360 ;
 848
 849     return newAngle ;
 850 }
 851
 852 void wxDC::DoDrawArc( wxCoord x1, wxCoord y1,
 853                       wxCoord x2, wxCoord y2,
 854                       wxCoord xc, wxCoord yc )
 855 {
 856     wxCHECK_RET(Ok(), wxT("wxDC::DoDrawArc - invalid DC"));
 857
 858     wxMacFastPortSetter helper(this) ;
 859
 860     wxCoord xx1 = XLOG2DEVMAC(x1);
 861     wxCoord yy1 = YLOG2DEVMAC(y1);
 862     wxCoord xx2 = XLOG2DEVMAC(x2);
 863     wxCoord yy2 = YLOG2DEVMAC(y2);
 864     wxCoord xxc = XLOG2DEVMAC(xc);
 865     wxCoord yyc = YLOG2DEVMAC(yc);
 866
 867     double dx = xx1 - xxc;
 868     double dy = yy1 - yyc;
 869     double radius = sqrt((double)(dx * dx + dy * dy));
 870     wxCoord rad = (wxCoord)radius;
 871     double radius1, radius2;
 872
 873     if (xx1 == xx2 && yy1 == yy2)
 874     {
 875         radius1 = 0.0;
 876         radius2 = 360.0;
 877     }
 878     else if (radius == 0.0)
 879     {
 880         radius1 = radius2 = 0.0;
 881     }
 882     else
 883     {
 884         radius1 = (xx1 - xxc == 0) ?
 885             (yy1 - yyc < 0) ? 90.0 : -90.0 :
 886         -atan2(double(yy1 - yyc), double(xx1 - xxc)) * RAD2DEG;
 887         radius2 = (xx2 - xxc == 0) ?
 888             (yy2 - yyc < 0) ? 90.0 : -90.0 :
 889         -atan2(double(yy2 - yyc), double(xx2 - xxc)) * RAD2DEG;
 890     }
 891
 892     wxCoord alpha2 = wxCoord(radius2 - radius1);
 893     wxCoord alpha1 = wxCoord(wxConvertWXangleToMACangle(radius1));
 894     while ( alpha2 < 0 )
 895         alpha2 += 360 ;
 896     alpha2 = -alpha2 ;
 897     Rect r = { yyc - rad, xxc - rad, yyc + rad, xxc + rad };
 898
 899     if (m_brush.GetStyle() != wxTRANSPARENT)
 900     {
 901         MacInstallBrush();
 902         PaintArc(&r, alpha1, alpha2);
 903     }
 904
 905     if (m_pen.GetStyle() != wxTRANSPARENT)
 906     {
 907         MacInstallPen();
 908         FrameArc(&r, alpha1, alpha2);
 909     }
 910 }
 911
 912 void wxDC::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord w, wxCoord h,
 913                               double sa, double ea )
 914 {
 915     wxCHECK_RET(Ok(), wxT("wxDC::DoDrawEllepticArc - invalid DC"));
 916     wxMacFastPortSetter helper(this) ;
 917     Rect r;
 918
 919     // Order important Mac in opposite direction to wx
 920     // we have to make sure that the filling is always counter-clockwise
 921     double angle = sa - ea;
 922     if ( angle > 0 )
 923         angle -= 360 ;
 924
 925     wxCoord xx = XLOG2DEVMAC(x);
 926     wxCoord yy = YLOG2DEVMAC(y);
 927     wxCoord ww = m_signX * XLOG2DEVREL(w);
 928     wxCoord hh = m_signY * YLOG2DEVREL(h);
 929
 930     // handle -ve width and/or height
 931     if (ww < 0)
 932     {
 933         ww = -ww;
 934         xx = xx - ww;
 935     }
 936
 937     if (hh < 0)
 938     {
 939         hh = -hh;
 940         yy = yy - hh;
 941     }
 942
 943     sa = wxConvertWXangleToMACangle(sa);
 944     r.top    = yy;
 945     r.left   = xx;
 946     r.bottom = yy + hh;
 947     r.right  = xx + ww;
 948
 949     if (m_brush.GetStyle() != wxTRANSPARENT)
 950     {
 951         MacInstallBrush();
 952         PaintArc(&r, (short)sa, (short)angle);
 953     }
 954
 955     if (m_pen.GetStyle() != wxTRANSPARENT)
 956     {
 957         MacInstallPen();
 958         FrameArc(&r, (short)sa, (short)angle);
 959     }
 960 }
 961
 962 void wxDC::DoDrawPoint( wxCoord x, wxCoord y )
 963 {
 964     wxCHECK_RET(Ok(), wxT("wxDC::DoDrawPoint - invalid DC"));
 965
 966     wxMacFastPortSetter helper(this) ;
 967
 968     if (m_pen.GetStyle() != wxTRANSPARENT)
 969     {
 970         wxCoord xx1 = XLOG2DEVMAC(x);
 971         wxCoord yy1 = YLOG2DEVMAC(y);
 972         RGBColor pencolor = MAC_WXCOLORREF( m_pen.GetColour().GetPixel());
 973
 974         // NOTE: Get/SetCPixel are slow!
 975         ::SetCPixel( xx1, yy1, &pencolor) ;
 976         CalcBoundingBox(x, y);
 977     }
 978 }
 979
 980 void wxDC::DoDrawLines(int n, wxPoint points[],
 981                         wxCoord xoffset, wxCoord yoffset)
 982 {
 983     wxCHECK_RET(Ok(), wxT("wxDC::DoDrawLines - invalid DC"));
 984
 985     if (m_pen.GetStyle() == wxTRANSPARENT)
 986         return;
 987
 988     wxMacFastPortSetter helper(this) ;
 989
 990     MacInstallPen() ;
 991     wxCoord offset = ( (m_pen.GetWidth() == 0 ? 1 :
 992     m_pen.GetWidth() ) * (wxCoord)m_scaleX - 1) / 2 ;
 993
 994     wxCoord x1, x2 , y1 , y2 ;
 995     x1 = XLOG2DEVMAC(points[0].x + xoffset);
 996     y1 = YLOG2DEVMAC(points[0].y + yoffset);
 997
 998     ::MoveTo( x1 - offset, y1 - offset );
 999     for (int i = 0; i < n-1; i++)
1000     {
1001         x2 = XLOG2DEVMAC(points[i + 1].x + xoffset);
1002         y2 = YLOG2DEVMAC(points[i + 1].y + yoffset);
1003         ::LineTo( x2 - offset, y2 - offset );
1004     }
1005 }
1006
1007 void wxDC::DoDrawPolygon(int n, wxPoint points[],
1008                           wxCoord xoffset, wxCoord yoffset,
1009                           int fillStyle )
1010 {
1011     wxCHECK_RET(Ok(), wxT("wxDC::DoDrawPolygon - invalid DC"));
1012
1013     if ( m_brush.GetStyle() == wxTRANSPARENT && m_pen.GetStyle() == wxTRANSPARENT )
1014         return ;
1015
1016     wxMacFastPortSetter helper(this) ;
1017
1018     wxCoord x1, x2 , y1 , y2 ;
1019     PolyHandle polygon = OpenPoly();
1020     x2 = x1 = XLOG2DEVMAC(points[0].x + xoffset);
1021     y2 = y1 = YLOG2DEVMAC(points[0].y + yoffset);
1022
1023     ::MoveTo(x1, y1);
1024     for (int i = 1; i < n; i++)
1025     {
1026         x2 = XLOG2DEVMAC(points[i].x + xoffset);
1027         y2 = YLOG2DEVMAC(points[i].y + yoffset);
1028         ::LineTo(x2, y2);
1029     }
1030
1031     // close the polyline if necessary
1032     if ( x1 != x2 || y1 != y2 )
1033         ::LineTo( x1, y1 ) ;
1034     ClosePoly();
1035
1036     if (m_brush.GetStyle() != wxTRANSPARENT)
1037     {
1038         MacInstallBrush();
1039         ::PaintPoly( polygon );
1040     }
1041
1042     if (m_pen.GetStyle() != wxTRANSPARENT)
1043     {
1044         MacInstallPen() ;
1045         ::FramePoly( polygon ) ;
1046     }
1047
1048     KillPoly( polygon );
1049 }
1050
1051 void wxDC::DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
1052 {
1053     wxCHECK_RET(Ok(), wxT("wxDC::DoDrawRectangle - invalid DC"));
1054
1055     wxMacFastPortSetter helper(this) ;
1056
1057     wxCoord xx = XLOG2DEVMAC(x);
1058     wxCoord yy = YLOG2DEVMAC(y);
1059     wxCoord ww = m_signX * XLOG2DEVREL(width);
1060     wxCoord hh = m_signY * YLOG2DEVREL(height);
1061
1062     // CMB: draw nothing if transformed w or h is 0
1063     if (ww == 0 || hh == 0)
1064         return;
1065
1066     // CMB: handle -ve width and/or height
1067     if (ww < 0)
1068     {
1069         ww = -ww;
1070         xx = xx - ww;
1071     }
1072
1073     if (hh < 0)
1074     {
1075         hh = -hh;
1076         yy = yy - hh;
1077     }
1078
1079     Rect rect = { yy , xx , yy + hh , xx + ww } ;
1080
1081     if (m_brush.GetStyle() != wxTRANSPARENT)
1082     {
1083         MacInstallBrush() ;
1084         ::PaintRect( &rect ) ;
1085     }
1086
1087     if (m_pen.GetStyle() != wxTRANSPARENT)
1088     {
1089         MacInstallPen() ;
1090         ::FrameRect( &rect ) ;
1091     }
1092 }
1093
1094 void wxDC::DoDrawRoundedRectangle(wxCoord x, wxCoord y,
1095                                    wxCoord width, wxCoord height,
1096                                    double radius)
1097 {
1098     wxCHECK_RET(Ok(), wxT("wxDC::DoDrawRoundedRectangle - invalid DC"));
1099
1100     wxMacFastPortSetter helper(this) ;
1101     if (radius < 0.0)
1102         radius = - radius * ((width < height) ? width : height);
1103     wxCoord xx = XLOG2DEVMAC(x);
1104     wxCoord yy = YLOG2DEVMAC(y);
1105     wxCoord ww = m_signX * XLOG2DEVREL(width);
1106     wxCoord hh = m_signY * YLOG2DEVREL(height);
1107
1108     // CMB: draw nothing if transformed w or h is 0
1109     if (ww == 0 || hh == 0)
1110         return;
1111
1112     // CMB: handle -ve width and/or height
1113     if (ww < 0)
1114     {
1115         ww = -ww;
1116         xx = xx - ww;
1117     }
1118
1119     if (hh < 0)
1120     {
1121         hh = -hh;
1122         yy = yy - hh;
1123     }
1124
1125     Rect rect = { yy , xx , yy + hh , xx + ww } ;
1126
1127     if (m_brush.GetStyle() != wxTRANSPARENT)
1128     {
1129         MacInstallBrush() ;
1130         ::PaintRoundRect( &rect , int(radius * 2) , int(radius * 2) ) ;
1131     }
1132
1133     if (m_pen.GetStyle() != wxTRANSPARENT)
1134     {
1135         MacInstallPen() ;
1136         ::FrameRoundRect( &rect , int(radius * 2) , int(radius * 2) ) ;
1137     }
1138 }
1139
1140 void wxDC::DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
1141 {
1142     wxCHECK_RET(Ok(), wxT("wxDC::DoDrawEllipse - invalid DC"));
1143
1144     wxMacFastPortSetter helper(this) ;
1145
1146     wxCoord xx = XLOG2DEVMAC(x);
1147     wxCoord yy = YLOG2DEVMAC(y);
1148     wxCoord ww = m_signX * XLOG2DEVREL(width);
1149     wxCoord hh = m_signY * YLOG2DEVREL(height);
1150
1151     // CMB: draw nothing if transformed w or h is 0
1152     if (ww == 0 || hh == 0)
1153         return;
1154
1155     // CMB: handle -ve width and/or height
1156     if (ww < 0)
1157     {
1158         ww = -ww;
1159         xx = xx - ww;
1160     }
1161
1162     if (hh < 0)
1163     {
1164         hh = -hh;
1165         yy = yy - hh;
1166     }
1167
1168     Rect rect = { yy , xx , yy + hh , xx + ww } ;
1169
1170     if (m_brush.GetStyle() != wxTRANSPARENT)
1171     {
1172         MacInstallBrush() ;
1173         ::PaintOval( &rect ) ;
1174     }
1175
1176     if (m_pen.GetStyle() != wxTRANSPARENT)
1177     {
1178         MacInstallPen() ;
1179         ::FrameOval( &rect ) ;
1180     }
1181 }
1182
1183 bool wxDC::CanDrawBitmap(void) const
1184 {
1185     return true ;
1186 }
1187
1188 bool wxDC::DoBlit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
1189                    wxDC *source, wxCoord xsrc, wxCoord ysrc, int logical_func , bool useMask,
1190                    wxCoord xsrcMask, wxCoord ysrcMask )
1191 {
1192     wxCHECK_MSG(Ok(), false, wxT("wxDC::DoBlit - invalid DC"));
1193     wxCHECK_MSG(source->Ok(), false, wxT("wxDC::DoBlit - invalid source DC"));
1194
1195     if ( logical_func == wxNO_OP )
1196         return true ;
1197
1198     if (xsrcMask == -1 && ysrcMask == -1)
1199     {
1200         xsrcMask = xsrc;
1201         ysrcMask = ysrc;
1202     }
1203
1204     // correct the parameter in case this dc does not have a mask at all
1205     if ( useMask && !source->m_macMask )
1206         useMask = false ;
1207
1208     Rect srcrect , dstrect ;
1209     srcrect.top = source->YLOG2DEVMAC(ysrc) ;
1210     srcrect.left = source->XLOG2DEVMAC(xsrc)  ;
1211     srcrect.right = source->XLOG2DEVMAC(xsrc + width ) ;
1212     srcrect.bottom = source->YLOG2DEVMAC(ysrc + height) ;
1213     dstrect.top = YLOG2DEVMAC(ydest) ;
1214     dstrect.left = XLOG2DEVMAC(xdest) ;
1215     dstrect.bottom = YLOG2DEVMAC(ydest + height )  ;
1216     dstrect.right = XLOG2DEVMAC(xdest + width ) ;
1217     short mode = kUnsupportedMode ;
1218     bool invertDestinationFirst = false ;
1219
1220     switch ( logical_func )
1221     {
1222     case wxAND:        // src AND dst
1223         mode = adMin ; // ok
1224         break ;
1225
1226     case wxAND_INVERT: // (NOT src) AND dst
1227         mode = notSrcOr  ; // ok
1228         break ;
1229
1230     case wxAND_REVERSE:// src AND (NOT dst)
1231         invertDestinationFirst = true ;
1232         mode = srcOr ;
1233         break ;
1234
1235     case wxCLEAR:      // 0
1236         mode = kEmulatedMode ;
1237         break ;
1238
1239     case wxCOPY:       // src
1240         mode = srcCopy ; // ok
1241         break ;
1242
1243     case wxEQUIV:      // (NOT src) XOR dst
1244         mode = srcXor ; // ok
1245         break ;
1246
1247     case wxINVERT:     // NOT dst
1248         mode = kEmulatedMode ; //or hilite ;
1249         break ;
1250
1251     case wxNAND:       // (NOT src) OR (NOT dst)
1252         invertDestinationFirst = true ;
1253         mode = srcBic ;
1254         break ;
1255
1256     case wxNOR:        // (NOT src) AND (NOT dst)
1257         invertDestinationFirst = true ;
1258         mode = notSrcOr ;
1259         break ;
1260
1261     case wxNO_OP:      // dst
1262         mode = kEmulatedMode ; // this has already been handled upon entry
1263         break ;
1264
1265     case wxOR:         // src OR dst
1266         mode = notSrcBic ;
1267         break ;
1268
1269     case wxOR_INVERT:  // (NOT src) OR dst
1270         mode = srcBic ;
1271         break ;
1272
1273     case wxOR_REVERSE: // src OR (NOT dst)
1274         invertDestinationFirst = true ;
1275         mode = notSrcBic ;
1276         break ;
1277
1278     case wxSET:        // 1
1279         mode = kEmulatedMode ;
1280         break ;
1281
1282     case wxSRC_INVERT: // (NOT src)
1283         mode = notSrcCopy ; // ok
1284         break ;
1285
1286     case wxXOR:        // src XOR dst
1287         mode = notSrcXor ; // ok
1288         break ;
1289
1290     default :
1291         break ;
1292     }
1293
1294     if ( mode == kUnsupportedMode )
1295     {
1296         wxFAIL_MSG(wxT("unsupported blitting mode" ));
1297
1298         return false ;
1299     }
1300
1301     CGrafPtr            sourcePort = (CGrafPtr) source->m_macPort ;
1302     PixMapHandle    bmappixels =  GetGWorldPixMap( sourcePort ) ;
1303     if ( LockPixels(bmappixels) )
1304     {
1305         wxMacFastPortSetter helper(this) ;
1306
1307         if ( source->GetDepth() == 1 )
1308         {
1309             RGBForeColor( &MAC_WXCOLORREF(m_textForegroundColour.GetPixel()) ) ;
1310             RGBBackColor( &MAC_WXCOLORREF(m_textBackgroundColour.GetPixel()) ) ;
1311         }
1312         else
1313         {
1314             // the modes need this, otherwise we'll end up having really nice colors...
1315             RGBColor white = { 0xFFFF, 0xFFFF, 0xFFFF } ;
1316             RGBColor black = { 0, 0, 0 } ;
1317
1318             RGBForeColor( &black ) ;
1319             RGBBackColor( &white ) ;
1320         }
1321
1322         if ( useMask && source->m_macMask )
1323         {
1324             if ( mode == srcCopy )
1325             {
1326                 if ( LockPixels( GetGWorldPixMap( MAC_WXHBITMAP(source->m_macMask) ) ) )
1327                 {
1328                     CopyMask( GetPortBitMapForCopyBits( sourcePort ) ,
1329                         GetPortBitMapForCopyBits( MAC_WXHBITMAP(source->m_macMask) ) ,
1330                         GetPortBitMapForCopyBits( MAC_WXHBITMAP(m_macPort) ) ,
1331                         &srcrect, &srcrect , &dstrect ) ;
1332                     UnlockPixels( GetGWorldPixMap( MAC_WXHBITMAP(source->m_macMask) )  ) ;
1333                 }
1334             }
1335             else
1336             {
1337                 RgnHandle clipRgn = NewRgn() ;
1338                 LockPixels( GetGWorldPixMap( MAC_WXHBITMAP(source->m_macMask) ) ) ;
1339                 BitMapToRegion( clipRgn , (BitMap*) *GetGWorldPixMap( MAC_WXHBITMAP(source->m_macMask) ) ) ;
1340                 UnlockPixels( GetGWorldPixMap( MAC_WXHBITMAP(source->m_macMask) ) ) ;
1341                 OffsetRgn( clipRgn , -srcrect.left + dstrect.left, -srcrect.top +  dstrect.top ) ;
1342
1343                 if ( mode == kEmulatedMode )
1344                 {
1345                     Pattern pat ;
1346
1347                     ::PenPat(GetQDGlobalsBlack(&pat));
1348                     if ( logical_func == wxSET )
1349                     {
1350                         RGBColor col= { 0xFFFF, 0xFFFF, 0xFFFF } ;
1351                         ::RGBForeColor( &col  ) ;
1352                         ::PaintRgn( clipRgn ) ;
1353                     }
1354                     else if ( logical_func == wxCLEAR )
1355                     {
1356                         RGBColor col= { 0x0000, 0x0000, 0x0000 } ;
1357                         ::RGBForeColor( &col  ) ;
1358                         ::PaintRgn( clipRgn ) ;
1359                     }
1360                     else if ( logical_func == wxINVERT )
1361                     {
1362                         MacInvertRgn( clipRgn ) ;
1363                     }
1364                     else
1365                     {
1366                         for ( int y = 0 ; y < srcrect.right - srcrect.left ; ++y )
1367                         {
1368                             for ( int x = 0 ; x < srcrect.bottom - srcrect.top ; ++x )
1369                             {
1370                                 Point dstPoint = { dstrect.top + y , dstrect.left + x } ;
1371                                 Point srcPoint = { srcrect.top + y , srcrect.left + x } ;
1372                                 if ( PtInRgn( dstPoint , clipRgn ) )
1373                                 {
1374                                     RGBColor srcColor, dstColor ;
1375
1376                                     // NOTE: Get/SetCPixel are slow!
1377                                     SetPort( (GrafPtr) sourcePort ) ;
1378                                     GetCPixel( srcPoint.h , srcPoint.v , &srcColor ) ;
1379                                     SetPort( (GrafPtr) m_macPort ) ;
1380                                     GetCPixel( dstPoint.h , dstPoint.v , &dstColor ) ;
1381                                     wxMacCalculateColour( logical_func , srcColor , dstColor ) ;
1382                                     SetCPixel( dstPoint.h , dstPoint.v , &dstColor ) ;
1383                                 }
1384                             }
1385                         }
1386                     }
1387                 }
1388                 else
1389                 {
1390                     if ( invertDestinationFirst )
1391                         MacInvertRgn( clipRgn ) ;
1392
1393                     CopyBits( GetPortBitMapForCopyBits( sourcePort ) ,
1394                         GetPortBitMapForCopyBits( MAC_WXHBITMAP(m_macPort) ) ,
1395                         &srcrect, &dstrect, mode, clipRgn ) ;
1396                 }
1397
1398                 DisposeRgn( clipRgn ) ;
1399             }
1400         }
1401         else
1402         {
1403             RgnHandle clipRgn = NewRgn() ;
1404             SetRectRgn( clipRgn , dstrect.left , dstrect.top , dstrect.right , dstrect.bottom ) ;
1405
1406             if ( mode == kEmulatedMode )
1407             {
1408                 Pattern pat ;
1409
1410                 ::PenPat(GetQDGlobalsBlack(&pat));
1411                 if ( logical_func == wxSET )
1412                 {
1413                     RGBColor col= { 0xFFFF, 0xFFFF, 0xFFFF } ;
1414                     ::RGBForeColor( &col  ) ;
1415                     ::PaintRgn( clipRgn ) ;
1416                 }
1417                 else if ( logical_func == wxCLEAR )
1418                 {
1419                     RGBColor col = { 0x0000, 0x0000, 0x0000 } ;
1420
1421                     ::RGBForeColor( &col  ) ;
1422                     ::PaintRgn( clipRgn ) ;
1423                 }
1424                 else if ( logical_func == wxINVERT )
1425                 {
1426                     MacInvertRgn( clipRgn ) ;
1427                 }
1428                 else
1429                 {
1430                     for ( int y = 0 ; y < srcrect.right - srcrect.left ; ++y )
1431                     {
1432                         for ( int x = 0 ; x < srcrect.bottom - srcrect.top ; ++x )
1433                         {
1434                             Point dstPoint = { dstrect.top + y , dstrect.left + x } ;
1435                             Point srcPoint = { srcrect.top + y , srcrect.left + x } ;
1436                             {
1437                                 RGBColor srcColor, dstColor ;
1438
1439                                 // NOTE: Get/SetCPixel are slow!
1440                                 SetPort( (GrafPtr) sourcePort ) ;
1441                                 GetCPixel( srcPoint.h , srcPoint.v , &srcColor) ;
1442                                 SetPort( (GrafPtr) m_macPort ) ;
1443                                 GetCPixel( dstPoint.h , dstPoint.v , &dstColor ) ;
1444                                 wxMacCalculateColour( logical_func , srcColor , dstColor ) ;
1445                                 SetCPixel( dstPoint.h , dstPoint.v , &dstColor ) ;
1446                             }
1447                         }
1448                     }
1449                 }
1450             }
1451             else
1452             {
1453                 if ( invertDestinationFirst )
1454                     MacInvertRgn( clipRgn ) ;
1455
1456                 CopyBits( GetPortBitMapForCopyBits( sourcePort ) ,
1457                     GetPortBitMapForCopyBits( MAC_WXHBITMAP(m_macPort) ) ,
1458                     &srcrect, &dstrect, mode, NULL ) ;
1459             }
1460
1461             DisposeRgn( clipRgn ) ;
1462         }
1463
1464         UnlockPixels( bmappixels ) ;
1465     }
1466
1467     m_macPenInstalled = false ;
1468     m_macBrushInstalled = false ;
1469     m_macFontInstalled = false ;
1470
1471     return true;
1472 }
1473
1474 void wxDC::DoDrawRotatedText(const wxString& str, wxCoord x, wxCoord y,
1475                               double angle)
1476 {
1477     // TODO: support text background color (only possible by hand, ATSUI does not support it)
1478     wxCHECK_RET( Ok(), wxT("wxDC::DoDrawRotatedText - invalid DC") );
1479
1480     if ( str.empty() )
1481         return ;
1482
1483     wxMacFastPortSetter helper(this) ;
1484     MacInstallFont() ;
1485
1486 #if 0
1487     if ( 0 )
1488     {
1489         m_macFormerAliasState = IsAntiAliasedTextEnabled(&m_macFormerAliasSize);
1490         SetAntiAliasedTextEnabled(true, SInt16(m_scaleY * m_font.MacGetFontSize()));
1491         m_macAliasWasEnabled = true ;
1492     }
1493 #endif
1494
1495     OSStatus status = noErr ;
1496     ATSUTextLayout atsuLayout ;
1497     UniCharCount chars = str.length() ;
1498     UniChar* ubuf = NULL ;
1499
1500 #if SIZEOF_WCHAR_T == 4
1501     wxMBConvUTF16 converter ;
1502 #if wxUSE_UNICODE
1503     size_t unicharlen = converter.WC2MB( NULL , str.wc_str() , 0 ) ;
1504     ubuf = (UniChar*) malloc( unicharlen + 2 ) ;
1505     converter.WC2MB( (char*) ubuf , str.wc_str(), unicharlen + 2 ) ;
1506 #else
1507     const wxWCharBuffer wchar = str.wc_str( wxConvLocal ) ;
1508     size_t unicharlen = converter.WC2MB( NULL , wchar.data() , 0 ) ;
1509     ubuf = (UniChar*) malloc( unicharlen + 2 ) ;
1510     converter.WC2MB( (char*) ubuf , wchar.data() , unicharlen + 2 ) ;
1511 #endif
1512     chars = unicharlen / 2 ;
1513 #else
1514 #if wxUSE_UNICODE
1515     ubuf = (UniChar*) str.wc_str() ;
1516 #else
1517     wxWCharBuffer wchar = str.wc_str( wxConvLocal ) ;
1518     chars = wxWcslen( wchar.data() ) ;
1519     ubuf = (UniChar*) wchar.data() ;
1520 #endif
1521 #endif
1522
1523     status = ::ATSUCreateTextLayoutWithTextPtr( (UniCharArrayPtr) ubuf , 0 , chars , chars , 1 ,
1524         &chars , (ATSUStyle*) &m_macATSUIStyle , &atsuLayout ) ;
1525
1526     wxASSERT_MSG( status == noErr , wxT("couldn't create the layout of the rotated text") );
1527
1528     status = ::ATSUSetTransientFontMatching( atsuLayout , true ) ;
1529     wxASSERT_MSG( status == noErr , wxT("couldn't setup transient font matching") );
1530
1531     int iAngle = int( angle );
1532     int drawX = XLOG2DEVMAC(x) ;
1533     int drawY = YLOG2DEVMAC(y) ;
1534
1535     ATSUTextMeasurement textBefore, textAfter ;
1536     ATSUTextMeasurement ascent, descent ;
1537
1538     if ( abs(iAngle) > 0 )
1539     {
1540         Fixed atsuAngle = IntToFixed( iAngle ) ;
1541
1542         ATSUAttributeTag atsuTags[] =
1543         {
1544             kATSULineRotationTag ,
1545         } ;
1546         ByteCount atsuSizes[sizeof(atsuTags)/sizeof(ATSUAttributeTag)] =
1547         {
1548             sizeof( Fixed ) ,
1549         } ;
1550         ATSUAttributeValuePtr    atsuValues[sizeof(atsuTags)/sizeof(ATSUAttributeTag)] =
1551         {
1552             &atsuAngle ,
1553         } ;
1554
1555         status = ::ATSUSetLayoutControls(atsuLayout , sizeof(atsuTags)/sizeof(ATSUAttributeTag),
1556             atsuTags, atsuSizes, atsuValues ) ;
1557     }
1558
1559     status = ::ATSUMeasureText( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd,
1560         &textBefore , &textAfter, &ascent , &descent );
1561
1562     drawX += (int)(sin(angle / RAD2DEG) * FixedToInt(ascent));
1563     drawY += (int)(cos(angle / RAD2DEG) * FixedToInt(ascent));
1564     status = ::ATSUDrawText( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd,
1565         IntToFixed(drawX) , IntToFixed(drawY) );
1566
1567     wxASSERT_MSG( status == noErr , wxT("couldn't draw the rotated text") );
1568
1569     Rect rect ;
1570     status = ::ATSUMeasureTextImage( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd,
1571         IntToFixed(drawX) , IntToFixed(drawY) , &rect );
1572     wxASSERT_MSG( status == noErr , wxT("couldn't measure the rotated text") );
1573
1574     OffsetRect( &rect , -m_macLocalOrigin.x , -m_macLocalOrigin.y ) ;
1575     CalcBoundingBox(XDEV2LOG(rect.left), YDEV2LOG(rect.top) );
1576     CalcBoundingBox(XDEV2LOG(rect.right), YDEV2LOG(rect.bottom) );
1577     ::ATSUDisposeTextLayout(atsuLayout);
1578
1579 #if SIZEOF_WCHAR_T == 4
1580     free( ubuf ) ;
1581 #endif
1582 }
1583
1584 void wxDC::DoDrawText(const wxString& strtext, wxCoord x, wxCoord y)
1585 {
1586     wxCHECK_RET(Ok(), wxT("wxDC::DoDrawText - invalid DC"));
1587
1588     wxMacFastPortSetter helper(this) ;
1589     long xx = XLOG2DEVMAC(x);
1590     long yy = YLOG2DEVMAC(y);
1591
1592 #if TARGET_CARBON
1593     bool useDrawThemeText = ( DrawThemeTextBox != (void*) kUnresolvedCFragSymbolAddress ) ;
1594     if ( UMAGetSystemVersion() < 0x1000 || IsKindOf(CLASSINFO( wxPrinterDC ) ) || m_font.GetNoAntiAliasing() )
1595         useDrawThemeText = false ;
1596 #endif
1597
1598     MacInstallFont() ;
1599
1600     FontInfo fi ;
1601     ::GetFontInfo( &fi ) ;
1602
1603 #if TARGET_CARBON
1604     if ( !useDrawThemeText )
1605         yy += fi.ascent ;
1606 #else
1607     yy += fi.ascent ;
1608 #endif
1609
1610     ::TextMode( (m_backgroundMode == wxTRANSPARENT) ? srcOr : srcCopy ) ;
1611     ::MoveTo( xx , yy );
1612
1613     int line = 0 ;
1614     {
1615         wxString linetext = strtext ;
1616
1617 #if TARGET_CARBON
1618         if ( useDrawThemeText )
1619         {
1620             Rect frame = {
1621                 yy + line*(fi.descent + fi.ascent + fi.leading), xx ,
1622                 yy + (line+1)*(fi.descent + fi.ascent + fi.leading) , xx + 10000 } ;
1623             wxMacCFStringHolder mString( linetext , m_font.GetEncoding()) ;
1624
1625             if ( m_backgroundMode != wxTRANSPARENT )
1626             {
1627                 Point bounds = {0, 0} ;
1628                 Rect background = frame ;
1629                 SInt16 baseline ;
1630                 ::GetThemeTextDimensions( mString,
1631                     m_font.MacGetThemeFontID() ,
1632                     kThemeStateActive,
1633                     false,
1634                     &bounds,
1635                     &baseline );
1636                 background.right = background.left + bounds.h ;
1637                 background.bottom = background.top + bounds.v ;
1638                 ::EraseRect( &background ) ;
1639             }
1640
1641             ::DrawThemeTextBox( mString,
1642                 m_font.MacGetThemeFontID() ,
1643                 kThemeStateActive,
1644                 false,
1645                 &frame,
1646                 teJustLeft,
1647                 NULL );
1648         }
1649         else
1650 #endif
1651         {
1652             wxCharBuffer text = linetext.mb_str(wxConvLocal) ;
1653             ::DrawText( text , 0 , strlen(text) ) ;
1654          }
1655     }
1656
1657     ::TextMode( srcOr ) ;
1658 }
1659
1660 bool wxDC::CanGetTextExtent() const
1661 {
1662     wxCHECK_MSG(Ok(), false, wxT("wxDC::CanGetTextExtent - invalid DC"));
1663
1664     return true ;
1665 }
1666
1667 void wxDC::DoGetTextExtent( const wxString &strtext, wxCoord *width, wxCoord *height,
1668                             wxCoord *descent, wxCoord *externalLeading ,
1669                             wxFont *theFont ) const
1670 {
1671     wxCHECK_RET(Ok(), wxT("wxDC::DoGetTextExtent - invalid DC"));
1672
1673     wxMacFastPortSetter helper(this) ;
1674     wxFont formerFont = m_font ;
1675     if ( theFont )
1676     {
1677         // work around the constness
1678         *((wxFont*)(&m_font)) = *theFont ;
1679     }
1680
1681     MacInstallFont() ;
1682     FontInfo fi ;
1683     ::GetFontInfo( &fi ) ;
1684
1685 #if TARGET_CARBON
1686     bool useGetThemeText = ( GetThemeTextDimensions != (void*) kUnresolvedCFragSymbolAddress ) ;
1687     if ( UMAGetSystemVersion() < 0x1000 || IsKindOf(CLASSINFO( wxPrinterDC ) ) || ((wxFont*)&m_font)->GetNoAntiAliasing() )
1688         useGetThemeText = false ;
1689 #endif
1690
1691     if ( height )
1692         *height = YDEV2LOGREL( fi.descent + fi.ascent ) ;
1693     if ( descent )
1694         *descent =YDEV2LOGREL( fi.descent );
1695     if ( externalLeading )
1696         *externalLeading = YDEV2LOGREL( fi.leading ) ;
1697
1698     int curwidth = 0 ;
1699     if ( width )
1700     {
1701         *width = 0 ;
1702         wxString linetext = strtext ;
1703
1704         if ( useGetThemeText )
1705         {
1706             Point bounds = {0, 0} ;
1707             SInt16 baseline ;
1708             wxMacCFStringHolder mString( linetext , m_font.GetEncoding() ) ;
1709             ThemeFontID themeFont = m_font.MacGetThemeFontID() ;
1710             ::GetThemeTextDimensions( mString,
1711                 themeFont ,
1712                 kThemeStateActive,
1713                 false,
1714                 &bounds,
1715                 &baseline );
1716             curwidth = bounds.h ;
1717         }
1718         else
1719         {
1720             wxCharBuffer text = linetext.mb_str(wxConvLocal) ;
1721             curwidth = ::TextWidth( text , 0 , strlen(text) ) ;
1722         }
1723
1724         if ( curwidth > *width )
1725             *width = XDEV2LOGREL( curwidth ) ;
1726     }
1727
1728     if ( theFont )
1729     {
1730         // work around the constness
1731         *((wxFont*)(&m_font)) = formerFont ;
1732         m_macFontInstalled = false ;
1733     }
1734 }
1735
1736 bool wxDC::DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const
1737 {
1738     wxCHECK_MSG(Ok(), false, wxT("wxDC::DoGetPartialTextExtents - invalid DC"));
1739
1740     widths.Empty();
1741     widths.Add(0, text.length());
1742
1743     if (text.length() == 0)
1744         return false;
1745
1746     wxMacFastPortSetter helper(this) ;
1747     MacInstallFont() ;
1748
1749 #if TARGET_CARBON
1750     bool useGetThemeText = ( GetThemeTextDimensions != (void*) kUnresolvedCFragSymbolAddress ) ;
1751     if ( UMAGetSystemVersion() < 0x1000 || IsKindOf(CLASSINFO( wxPrinterDC ) ) || ((wxFont*)&m_font)->GetNoAntiAliasing() )
1752         useGetThemeText = false ;
1753
1754     if ( useGetThemeText )
1755     {
1756         // If anybody knows how to do this more efficiently yet still handle
1757         // the fractional glyph widths that may be present when using AA
1758         // fonts, please change it.  Currently it is measuring from the
1759         // beginning of the string for each succeeding substring, which is much
1760         // slower than this should be.
1761         for (size_t i=0; i<text.length(); i++)
1762         {
1763             wxString str(text.Left(i + 1));
1764             Point bounds = {0, 0};
1765             SInt16 baseline ;
1766             wxMacCFStringHolder mString(str, m_font.GetEncoding());
1767
1768             ::GetThemeTextDimensions( mString,
1769                                       m_font.MacGetThemeFontID(),
1770                                       kThemeStateActive,
1771                                       false,
1772                                       &bounds,
1773                                       &baseline );
1774             widths[i] = XDEV2LOGREL(bounds.h);
1775         }
1776     }
1777     else
1778 #endif
1779     {
1780         wxCharBuffer buff = text.mb_str(wxConvLocal);
1781         size_t len = strlen(buff);
1782         short* measurements = new short[len+1];
1783         MeasureText(len, buff.data(), measurements);
1784
1785         // Copy to widths, starting at measurements[1]
1786         // NOTE: this doesn't take into account any multi-byte characters
1787         // in buff, it probably should...
1788         for (size_t i=0; i<text.length(); i++)
1789             widths[i] = XDEV2LOGREL(measurements[i + 1]);
1790
1791         delete [] measurements;
1792     }
1793
1794     return true;
1795 }
1796
1797 wxCoord wxDC::GetCharWidth(void) const
1798 {
1799     wxCHECK_MSG(Ok(), 1, wxT("wxDC::GetCharWidth - invalid DC"));
1800
1801     wxMacFastPortSetter helper(this) ;
1802     int width = 0 ;
1803     const char text[] = "g" ;
1804
1805     MacInstallFont() ;
1806
1807 #if TARGET_CARBON
1808     bool useGetThemeText = ( GetThemeTextDimensions != (void*) kUnresolvedCFragSymbolAddress ) ;
1809     if ( UMAGetSystemVersion() < 0x1000 || ((wxFont*)&m_font)->GetNoAntiAliasing() )
1810         useGetThemeText = false ;
1811
1812     if ( useGetThemeText )
1813     {
1814         Point bounds = {0, 0} ;
1815         SInt16 baseline ;
1816         CFStringRef mString = CFStringCreateWithBytes( NULL , (UInt8*) text , 1 , CFStringGetSystemEncoding(), false ) ;
1817         ::GetThemeTextDimensions( mString,
1818             m_font.MacGetThemeFontID(),
1819             kThemeStateActive,
1820             false,
1821             &bounds,
1822             &baseline );
1823         CFRelease( mString ) ;
1824         width = bounds.h ;
1825     }
1826     else
1827 #endif
1828     {
1829         width = ::TextWidth( text , 0 , 1 ) ;
1830     }
1831
1832     return YDEV2LOGREL(width) ;
1833 }
1834
1835 wxCoord wxDC::GetCharHeight(void) const
1836 {
1837     wxCHECK_MSG(Ok(), 1, wxT("wxDC::GetCharHeight - invalid DC"));
1838
1839     wxMacFastPortSetter helper(this) ;
1840     MacInstallFont() ;
1841     FontInfo fi ;
1842     ::GetFontInfo( &fi ) ;
1843
1844     return YDEV2LOGREL( fi.descent + fi.ascent );
1845 }
1846
1847 void wxDC::Clear(void)
1848 {
1849     wxCHECK_RET(Ok(), wxT("wxDC::Clear - invalid DC"));
1850
1851     wxMacFastPortSetter helper(this) ;
1852     Rect rect = { -31000 , -31000 , 31000 , 31000 } ;
1853
1854     if ( m_backgroundBrush.Ok() && m_backgroundBrush.GetStyle() != wxTRANSPARENT)
1855     {
1856         ::PenNormal() ;
1857         MacSetupBackgroundForCurrentPort( m_backgroundBrush ) ;
1858         ::EraseRect( &rect ) ;
1859     }
1860 }
1861
1862 void wxDC::MacInstallFont() const
1863 {
1864     wxCHECK_RET(Ok(), wxT("Invalid DC"));
1865
1866     //    if ( m_macFontInstalled )
1867     //        return ;
1868
1869     Pattern blackColor ;
1870     MacSetupBackgroundForCurrentPort(m_backgroundBrush) ;
1871     if ( m_backgroundMode != wxTRANSPARENT )
1872     {
1873         Pattern whiteColor ;
1874         ::BackPat(GetQDGlobalsWhite(&whiteColor));
1875     }
1876
1877     wxASSERT( m_font.Ok() ) ;
1878
1879     ::TextFont( m_font.MacGetFontNum() ) ;
1880     ::TextSize( (short)(m_scaleY * m_font.MacGetFontSize()) ) ;
1881     ::TextFace( m_font.MacGetFontStyle() ) ;
1882     m_macFontInstalled = true ;
1883     m_macBrushInstalled = false ;
1884     m_macPenInstalled = false ;
1885     RGBColor forecolor = MAC_WXCOLORREF( m_textForegroundColour.GetPixel());
1886     RGBColor backcolor = MAC_WXCOLORREF( m_textBackgroundColour.GetPixel());
1887     ::RGBForeColor( &forecolor );
1888     ::RGBBackColor( &backcolor );
1889
1890     // TODO:
1891     short mode = patCopy ;
1892     switch ( m_logicalFunction )
1893     {
1894     case wxCOPY:       // src
1895         mode = patCopy ;
1896         break ;
1897
1898     case wxINVERT:     // NOT dst
1899         ::PenPat(GetQDGlobalsBlack(&blackColor));
1900         mode = patXor ;
1901         break ;
1902
1903     case wxXOR:        // src XOR dst
1904         mode = patXor ;
1905         break ;
1906
1907     case wxOR_REVERSE: // src OR (NOT dst)
1908         mode = notPatOr ;
1909         break ;
1910
1911     case wxSRC_INVERT: // (NOT src)
1912         mode = notPatCopy ;
1913         break ;
1914
1915     case wxAND: // src AND dst
1916         mode = adMin ;
1917         break ;
1918
1919     // TODO: unsupported
1920     case wxCLEAR:      // 0
1921     case wxAND_REVERSE:// src AND (NOT dst)
1922     case wxAND_INVERT: // (NOT src) AND dst
1923     case wxNO_OP:      // dst
1924     case wxNOR:        // (NOT src) AND (NOT dst)
1925     case wxEQUIV:      // (NOT src) XOR dst
1926     case wxOR_INVERT:  // (NOT src) OR dst
1927     case wxNAND:       // (NOT src) OR (NOT dst)
1928     case wxOR:         // src OR dst
1929     case wxSET:        // 1
1930         //        case wxSRC_OR:     // source _bitmap_ OR destination
1931         //        case wxSRC_AND:     // source _bitmap_ AND destination
1932         break ;
1933
1934     default:
1935         break ;
1936     }
1937
1938     ::PenMode( mode ) ;
1939     OSStatus status = noErr ;
1940     status = ATSUCreateAndCopyStyle( (ATSUStyle) m_font.MacGetATSUStyle() , (ATSUStyle*) &m_macATSUIStyle ) ;
1941     wxASSERT_MSG( status == noErr , wxT("couldn't set create ATSU style") ) ;
1942
1943     Fixed atsuSize = IntToFixed( int(m_scaleY * m_font.MacGetFontSize()) ) ;
1944     ATSUAttributeTag atsuTags[] =
1945     {
1946             kATSUSizeTag ,
1947     } ;
1948     ByteCount atsuSizes[sizeof(atsuTags)/sizeof(ATSUAttributeTag)] =
1949     {
1950             sizeof( Fixed ) ,
1951     } ;
1952     ATSUAttributeValuePtr    atsuValues[sizeof(atsuTags)/sizeof(ATSUAttributeTag)] =
1953     {
1954             &atsuSize ,
1955     } ;
1956
1957     status = ::ATSUSetAttributes((ATSUStyle)m_macATSUIStyle, sizeof(atsuTags)/sizeof(ATSUAttributeTag) ,
1958         atsuTags, atsuSizes, atsuValues);
1959
1960     wxASSERT_MSG( status == noErr , wxT("couldn't modify ATSU style") ) ;
1961 }
1962
1963 Pattern gPatterns[] =
1964 {
1965     // hatch patterns
1966     { { 0xFF , 0xFF , 0xFF , 0xFF , 0xFF , 0xFF , 0xFF , 0xFF } } ,
1967     { { 0x01 , 0x02 , 0x04 , 0x08 , 0x10 , 0x20 , 0x40 , 0x80 } } ,
1968     { { 0x80 , 0x40 , 0x20 , 0x10 , 0x08 , 0x04 , 0x02 , 0x01 } } ,
1969     { { 0x10 , 0x10 , 0x10 , 0xFF , 0x10 , 0x10 , 0x10 , 0x10 } } ,
1970     { { 0x00 , 0x00 , 0x00 , 0xFF , 0x00 , 0x00 , 0x00 , 0x00 } } ,
1971     { { 0x10 , 0x10 , 0x10 , 0x10 , 0x10 , 0x10 , 0x10 , 0x10 } } ,
1972     { { 0x81 , 0x42 , 0x24 , 0x18 , 0x18 , 0x24 , 0x42 , 0x81 } } ,
1973
1974     // dash patterns
1975     { { 0xCC , 0x99 , 0x33 , 0x66 , 0xCC , 0x99 , 0x33 , 0x66 } } , // DOT
1976     { { 0xFE , 0xFD , 0xFB , 0xF7 , 0xEF , 0xDF , 0xBF , 0x7F } } , // LONG_DASH
1977     { { 0xEE , 0xDD , 0xBB , 0x77 , 0xEE , 0xDD , 0xBB , 0x77 } } , // SHORT_DASH
1978     { { 0xDE , 0xBD , 0x7B , 0xF6 , 0xED , 0xDB , 0xB7 , 0x6F } } , // DOT_DASH
1979 } ;
1980
1981 static void wxMacGetPattern(int penStyle, Pattern *pattern)
1982 {
1983     int index = 0;  // solid pattern by default
1984     switch (penStyle)
1985     {
1986         // hatches
1987         case wxBDIAGONAL_HATCH:     index = 1; break;
1988         case wxFDIAGONAL_HATCH:     index = 2; break;
1989         case wxCROSS_HATCH:         index = 3; break;
1990         case wxHORIZONTAL_HATCH:    index = 4; break;
1991         case wxVERTICAL_HATCH:      index = 5; break;
1992         case wxCROSSDIAG_HATCH:     index = 6; break;
1993
1994         // dashes
1995         case wxDOT:                 index = 7; break;
1996         case wxLONG_DASH:           index = 8; break;
1997         case wxSHORT_DASH:          index = 9; break;
1998         case wxDOT_DASH:            index = 10; break;
1999
2000         default:
2001             break;
2002     }
2003
2004     *pattern = gPatterns[index];
2005 }
2006
2007 void wxDC::MacInstallPen() const
2008 {
2009     wxCHECK_RET(Ok(), wxT("wxDC::MacInstallPen - invalid DC"));
2010
2011     //Pattern     blackColor;
2012     //    if ( m_macPenInstalled )
2013     //        return ;
2014
2015     RGBColor forecolor = MAC_WXCOLORREF( m_pen.GetColour().GetPixel());
2016     RGBColor backcolor = MAC_WXCOLORREF( m_backgroundBrush.GetColour().GetPixel());
2017     ::RGBForeColor( &forecolor );
2018     ::RGBBackColor( &backcolor );
2019     ::PenNormal() ;
2020
2021     // null means only one pixel, at whatever resolution
2022     int penWidth = (int) (m_pen.GetWidth() * m_scaleX) ;
2023     if ( penWidth == 0 )
2024         penWidth = 1 ;
2025     ::PenSize(penWidth, penWidth);
2026
2027     Pattern pat;
2028     int penStyle = m_pen.GetStyle();
2029     if (penStyle == wxUSER_DASH)
2030     {
2031         // FIXME: there should be exactly 8 items in the dash
2032         wxDash* dash ;
2033         int number = m_pen.GetDashes(&dash) ;
2034         int index = 0;
2035         for ( int i = 0 ; i < 8 ; ++i )
2036         {
2037             pat.pat[i] = dash[index] ;
2038             if (index < number - 1)
2039                 index++;
2040         }
2041     }
2042     else
2043     {
2044         wxMacGetPattern(penStyle, &pat);
2045     }
2046     ::PenPat(&pat);
2047
2048     // TODO:
2049     short mode = patCopy ;
2050     switch ( m_logicalFunction )
2051     {
2052     case wxCOPY:       // only foreground color, leave background (thus not patCopy)
2053         mode = patOr ;
2054         break ;
2055
2056     case wxINVERT:     // NOT dst
2057         //            ::PenPat(GetQDGlobalsBlack(&blackColor));
2058         mode = patXor ;
2059         break ;
2060
2061     case wxXOR:        // src XOR dst
2062         mode = patXor ;
2063         break ;
2064
2065     case wxOR_REVERSE: // src OR (NOT dst)
2066         mode = notPatOr ;
2067         break ;
2068
2069     case wxSRC_INVERT: // (NOT src)
2070         mode = notPatCopy ;
2071         break ;
2072
2073     case wxAND: // src AND dst
2074         mode = adMin ;
2075         break ;
2076
2077     // TODO: unsupported
2078     case wxCLEAR:      // 0
2079     case wxAND_REVERSE:// src AND (NOT dst)
2080     case wxAND_INVERT: // (NOT src) AND dst
2081     case wxNO_OP:      // dst
2082     case wxNOR:        // (NOT src) AND (NOT dst)
2083     case wxEQUIV:      // (NOT src) XOR dst
2084     case wxOR_INVERT:  // (NOT src) OR dst
2085     case wxNAND:       // (NOT src) OR (NOT dst)
2086     case wxOR:         // src OR dst
2087     case wxSET:        // 1
2088         //        case wxSRC_OR:     // source _bitmap_ OR destination
2089         //        case wxSRC_AND:     // source _bitmap_ AND destination
2090         break ;
2091
2092     default:
2093         break ;
2094     }
2095
2096     ::PenMode( mode ) ;
2097     m_macPenInstalled = true ;
2098     m_macBrushInstalled = false ;
2099     m_macFontInstalled = false ;
2100 }
2101
2102 void wxDC::MacSetupBackgroundForCurrentPort(const wxBrush& background )
2103 {
2104     Pattern whiteColor ;
2105
2106     if ( background.Ok() )
2107     {
2108         switch ( background.MacGetBrushKind() )
2109         {
2110             case kwxMacBrushTheme :
2111                 ::SetThemeBackground( background.MacGetTheme() , wxDisplayDepth() , true ) ;
2112                 break ;
2113
2114             case kwxMacBrushThemeBackground :
2115             {
2116                 Rect extent ;
2117                 ThemeBackgroundKind bg = background.MacGetThemeBackground( &extent ) ;
2118                 ::ApplyThemeBackground( bg , &extent, kThemeStateActive , wxDisplayDepth() , true ) ;
2119             }
2120                 break ;
2121
2122             case kwxMacBrushColour :
2123             {
2124                 ::RGBBackColor( &MAC_WXCOLORREF( background.GetColour().GetPixel()) );
2125                 int brushStyle = background.GetStyle();
2126                 if (brushStyle == wxSOLID)
2127                     ::BackPat(GetQDGlobalsWhite(&whiteColor));
2128                 else if (background.IsHatch())
2129                 {
2130                     Pattern pat ;
2131                     wxMacGetPattern(brushStyle, &pat);
2132                     ::BackPat(&pat);
2133                 }
2134                 else
2135                 {
2136                     ::BackPat(GetQDGlobalsWhite(&whiteColor));
2137                 }
2138             }
2139                 break ;
2140
2141             default:
2142                 break ;
2143         }
2144     }
2145 }
2146
2147 void wxDC::MacInstallBrush() const
2148 {
2149     wxCHECK_RET(Ok(), wxT("Invalid DC"));
2150
2151     //    if ( m_macBrushInstalled )
2152     //        return ;
2153
2154     Pattern     blackColor ;
2155     bool backgroundTransparent = (GetBackgroundMode() == wxTRANSPARENT) ;
2156     ::RGBForeColor( &MAC_WXCOLORREF( m_brush.GetColour().GetPixel()) );
2157     ::RGBBackColor( &MAC_WXCOLORREF( m_backgroundBrush.GetColour().GetPixel()) );
2158
2159     int brushStyle = m_brush.GetStyle();
2160     if (brushStyle == wxSOLID)
2161     {
2162         switch ( m_brush.MacGetBrushKind() )
2163         {
2164             case kwxMacBrushTheme :
2165                 {
2166                     Pattern whiteColor ;
2167                     ::BackPat(GetQDGlobalsWhite(&whiteColor));
2168                     ::SetThemePen( m_brush.MacGetTheme() , wxDisplayDepth() , true ) ;
2169                 }
2170             break ;
2171
2172             default :
2173                 ::PenPat(GetQDGlobalsBlack(&blackColor));
2174                 break ;
2175
2176         }
2177     }
2178     else if (m_brush.IsHatch())
2179     {
2180         Pattern pat ;
2181
2182         wxMacGetPattern(brushStyle, &pat);
2183         ::PenPat(&pat);
2184     }
2185     else if ( m_brush.GetStyle() == wxSTIPPLE || m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE )
2186     {
2187         // we force this in order to be compliant with wxMSW
2188         backgroundTransparent = false ;
2189
2190         // for these the text fore (and back for MASK_OPAQUE) colors are used
2191         wxBitmap* bitmap = m_brush.GetStipple() ;
2192         int width = bitmap->GetWidth() ;
2193         int height = bitmap->GetHeight() ;
2194         GWorldPtr gw = NULL ;
2195
2196         if ( m_brush.GetStyle() == wxSTIPPLE )
2197             gw = MAC_WXHBITMAP(bitmap->GetHBITMAP(NULL))  ;
2198         else
2199             gw = MAC_WXHBITMAP(bitmap->GetMask()->GetHBITMAP()) ;
2200
2201         PixMapHandle gwpixmaphandle = GetGWorldPixMap( gw ) ;
2202         LockPixels( gwpixmaphandle ) ;
2203         bool isMonochrome = !IsPortColor( gw ) ;
2204         if ( !isMonochrome )
2205         {
2206             if ( (**gwpixmaphandle).pixelSize == 1 )
2207                 isMonochrome = true ;
2208         }
2209
2210         if ( isMonochrome && width == 8 && height == 8 )
2211         {
2212             ::RGBForeColor( &MAC_WXCOLORREF( m_textForegroundColour.GetPixel()) );
2213             ::RGBForeColor( &MAC_WXCOLORREF( m_textBackgroundColour.GetPixel()) );
2214             BitMap* gwbitmap = (BitMap*) *gwpixmaphandle ; // since the color depth is 1 it is a BitMap
2215             UInt8 *gwbits = (UInt8*) gwbitmap->baseAddr ;
2216             int alignment = gwbitmap->rowBytes & 0x7FFF ;
2217             Pattern pat ;
2218
2219             for ( int i = 0 ; i < 8 ; ++i )
2220             {
2221                 pat.pat[i] = gwbits[i * alignment + 0] ;
2222             }
2223
2224             UnlockPixels( GetGWorldPixMap( gw ) ) ;
2225             ::PenPat( &pat ) ;
2226         }
2227         else
2228         {
2229             // this will be the code to handle power of 2 patterns, we will have to arrive at a nice
2230             // caching scheme before putting this into production
2231             Handle      image;
2232             long        imageSize;
2233
2234             PixPatHandle pixpat = NewPixPat() ;
2235             CopyPixMap(gwpixmaphandle, (**pixpat).patMap);
2236             imageSize = GetPixRowBytes((**pixpat).patMap) *
2237                 ((**(**pixpat).patMap).bounds.bottom -
2238                 (**(**pixpat).patMap).bounds.top);
2239             PtrToHand( (**gwpixmaphandle).baseAddr, &image, imageSize );
2240             (**pixpat).patData = image;
2241
2242             if ( isMonochrome )
2243             {
2244                 CTabHandle ctable = ((**((**pixpat).patMap)).pmTable) ;
2245                 ColorSpecPtr ctspec = (ColorSpecPtr) &(**ctable).ctTable ;
2246                 if ( ctspec[0].rgb.red == 0x0000 )
2247                 {
2248                     ctspec[1].rgb = MAC_WXCOLORREF( m_textBackgroundColour.GetPixel()) ;
2249                     ctspec[0].rgb = MAC_WXCOLORREF( m_textForegroundColour.GetPixel()) ;
2250                 }
2251                 else
2252                 {
2253                     ctspec[0].rgb = MAC_WXCOLORREF( m_textBackgroundColour.GetPixel()) ;
2254                     ctspec[1].rgb = MAC_WXCOLORREF( m_textForegroundColour.GetPixel()) ;
2255                 }
2256                 ::CTabChanged( ctable ) ;
2257             }
2258
2259             ::PenPixPat(pixpat);
2260             m_macForegroundPixMap = pixpat ;
2261         }
2262
2263         UnlockPixels( gwpixmaphandle ) ;
2264     }
2265     else
2266     {
2267         ::PenPat(GetQDGlobalsBlack(&blackColor));
2268     }
2269
2270     short mode = patCopy ;
2271     switch ( m_logicalFunction )
2272     {
2273     case wxCOPY:       // src
2274         if ( backgroundTransparent )
2275             mode = patOr ;
2276         else
2277             mode = patCopy ;
2278         break ;
2279
2280     case wxINVERT:     // NOT dst
2281         if ( !backgroundTransparent )
2282             ::PenPat(GetQDGlobalsBlack(&blackColor));
2283         mode = patXor ;
2284         break ;
2285
2286     case wxXOR:        // src XOR dst
2287         mode = patXor ;
2288         break ;
2289
2290     case wxOR_REVERSE: // src OR (NOT dst)
2291         mode = notPatOr ;
2292         break ;
2293
2294     case wxSRC_INVERT: // (NOT src)
2295         mode = notPatCopy ;
2296         break ;
2297
2298     case wxAND: // src AND dst
2299         mode = adMin ;
2300         break ;
2301
2302     // TODO: unsupported
2303     case wxCLEAR:      // 0
2304     case wxAND_REVERSE:// src AND (NOT dst)
2305     case wxAND_INVERT: // (NOT src) AND dst
2306     case wxNO_OP:      // dst
2307     case wxNOR:        // (NOT src) AND (NOT dst)
2308     case wxEQUIV:      // (NOT src) XOR dst
2309     case wxOR_INVERT:  // (NOT src) OR dst
2310     case wxNAND:       // (NOT src) OR (NOT dst)
2311     case wxOR:         // src OR dst
2312     case wxSET:        // 1
2313         //        case wxSRC_OR:     // source _bitmap_ OR destination
2314         //        case wxSRC_AND:     // source _bitmap_ AND destination
2315         break ;
2316
2317     default:
2318         break ;
2319     }
2320
2321     ::PenMode( mode ) ;
2322     m_macBrushInstalled = true ;
2323     m_macPenInstalled = false ;
2324     m_macFontInstalled = false ;
2325 }
2326
2327 // ---------------------------------------------------------------------------
2328 // coordinates transformations
2329 // ---------------------------------------------------------------------------
2330
2331 wxCoord wxDCBase::DeviceToLogicalX(wxCoord x) const
2332 {
2333     return ((wxDC *)this)->XDEV2LOG(x);
2334 }
2335
2336 wxCoord wxDCBase::DeviceToLogicalY(wxCoord y) const
2337 {
2338     return ((wxDC *)this)->YDEV2LOG(y);
2339 }
2340
2341 wxCoord wxDCBase::DeviceToLogicalXRel(wxCoord x) const
2342 {
2343     return ((wxDC *)this)->XDEV2LOGREL(x);
2344 }
2345
2346 wxCoord wxDCBase::DeviceToLogicalYRel(wxCoord y) const
2347 {
2348     return ((wxDC *)this)->YDEV2LOGREL(y);
2349 }
2350
2351 wxCoord wxDCBase::LogicalToDeviceX(wxCoord x) const
2352 {
2353     return ((wxDC *)this)->XLOG2DEV(x);
2354 }
2355
2356 wxCoord wxDCBase::LogicalToDeviceY(wxCoord y) const
2357 {
2358     return ((wxDC *)this)->YLOG2DEV(y);
2359 }
2360
2361 wxCoord wxDCBase::LogicalToDeviceXRel(wxCoord x) const
2362 {
2363     return ((wxDC *)this)->XLOG2DEVREL(x);
2364 }
2365
2366 wxCoord wxDCBase::LogicalToDeviceYRel(wxCoord y) const
2367 {
2368     return ((wxDC *)this)->YLOG2DEVREL(y);
2369 }
2370
2371 #endif // !wxMAC_USE_CORE_GRAPHICS