src/mac/carbon/dc.cpp

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