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