1 /////////////////////////////////////////////////////////////////////////////
4 // Author: Stefan Csomor
8 // Copyright: (c) Stefan Csomor
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
13 #pragma implementation "dc.h"
18 #include "wx/mac/uma.h"
19 #include "wx/dcmemory.h"
20 #include "wx/dcprint.h"
21 #include "wx/region.h"
31 #include "wx/mac/private.h"
32 #include <ATSUnicode.h>
33 #include <TextCommon.h>
34 #include <TextEncodingConverter.h>
36 #if !USE_SHARED_LIBRARY
37 IMPLEMENT_ABSTRACT_CLASS(wxDC
, wxObject
)
40 //-----------------------------------------------------------------------------
42 //-----------------------------------------------------------------------------
44 #define mm2inches 0.0393700787402
45 #define inches2mm 25.4
46 #define mm2twips 56.6929133859
47 #define twips2mm 0.0176388888889
48 #define mm2pt 2.83464566929
49 #define pt2mm 0.352777777778
50 #if !defined( __DARWIN__ ) || defined(__MWERKS__)
52 const double M_PI
= 3.14159265358979 ;
55 const double RAD2DEG
= 180.0 / M_PI
;
56 const short kEmulatedMode
= -1 ;
57 const short kUnsupportedMode
= -2 ;
59 extern TECObjectRef s_TECNativeCToUnicode
;
61 // set to 0 if problems arise
62 #define wxMAC_EXPERIMENTAL_DC 1
64 wxMacPortSetter::wxMacPortSetter( const wxDC
* dc
) :
65 m_ph( (GrafPtr
) dc
->m_macPort
)
67 wxASSERT( dc
->Ok() ) ;
69 dc
->MacSetupPort(&m_ph
) ;
71 wxMacPortSetter::~wxMacPortSetter()
73 m_dc
->MacCleanupPort(&m_ph
) ;
76 #if wxMAC_EXPERIMENTAL_DC
77 class wxMacFastPortSetter
80 wxMacFastPortSetter( const wxDC
*dc
)
82 wxASSERT( dc
->Ok() ) ;
83 m_swapped
= QDSwapPort( (GrafPtr
) dc
->m_macPort
, &m_oldPort
) ;
84 m_clipRgn
= NewRgn() ;
85 GetClip( m_clipRgn
) ;
87 dc
->MacSetupPort( NULL
) ;
89 ~wxMacFastPortSetter()
91 // SetPort( (GrafPtr) m_dc->m_macPort ) ;
92 SetClip( m_clipRgn
) ;
94 SetPort( m_oldPort
) ;
95 m_dc
->MacCleanupPort( NULL
) ;
96 DisposeRgn( m_clipRgn
) ;
100 RgnHandle m_clipRgn
;
106 typedef wxMacPortSetter wxMacFastPortSetter
;
109 wxMacWindowClipper::wxMacWindowClipper( const wxWindow
* win
) :
110 wxMacPortSaver( (GrafPtr
) GetWindowPort((WindowRef
) win
->MacGetTopLevelWindowRef()) )
112 m_newPort
=(GrafPtr
) GetWindowPort((WindowRef
) win
->MacGetTopLevelWindowRef()) ;
113 m_formerClip
= NewRgn() ;
114 m_newClip
= NewRgn() ;
115 GetClip( m_formerClip
) ;
120 win
->MacWindowToRootWindow( &x
,&y
) ;
121 // get area including focus rect
122 CopyRgn( (RgnHandle
) ((wxWindow
*)win
)->MacGetVisibleRegion(true).GetWXHRGN() , m_newClip
) ;
123 if ( !EmptyRgn( m_newClip
) )
124 OffsetRgn( m_newClip
, x
, y
) ;
126 SetClip( m_newClip
) ;
130 wxMacWindowClipper::~wxMacWindowClipper()
132 SetPort( m_newPort
) ;
133 SetClip( m_formerClip
) ;
134 DisposeRgn( m_newClip
) ;
135 DisposeRgn( m_formerClip
) ;
138 wxMacWindowStateSaver::wxMacWindowStateSaver( const wxWindow
* win
) :
139 wxMacWindowClipper( win
)
141 // the port is already set at this point
142 m_newPort
=(GrafPtr
) GetWindowPort((WindowRef
) win
->MacGetTopLevelWindowRef()) ;
143 GetThemeDrawingState( &m_themeDrawingState
) ;
146 wxMacWindowStateSaver::~wxMacWindowStateSaver()
148 SetPort( m_newPort
) ;
149 SetThemeDrawingState( m_themeDrawingState
, true ) ;
152 //-----------------------------------------------------------------------------
154 //-----------------------------------------------------------------------------
155 static inline double dmin(double a
, double b
) { return a
< b
? a
: b
; }
156 static inline double dmax(double a
, double b
) { return a
> b
? a
: b
; }
157 static inline double DegToRad(double deg
) { return (deg
* M_PI
) / 180.0; }
159 //-----------------------------------------------------------------------------
161 //-----------------------------------------------------------------------------
162 // this function emulates all wx colour manipulations, used to verify the implementation
163 // by setting the mode in the blitting functions to kEmulatedMode
164 void wxMacCalculateColour( int logical_func
, const RGBColor
&srcColor
, RGBColor
&dstColor
) ;
166 void wxMacCalculateColour( int logical_func
, const RGBColor
&srcColor
, RGBColor
&dstColor
)
168 switch ( logical_func
)
170 case wxAND
: // src AND dst
171 dstColor
.red
= dstColor
.red
& srcColor
.red
;
172 dstColor
.green
= dstColor
.green
& srcColor
.green
;
173 dstColor
.blue
= dstColor
.blue
& srcColor
.blue
;
175 case wxAND_INVERT
: // (NOT src) AND dst
176 dstColor
.red
= dstColor
.red
& ~srcColor
.red
;
177 dstColor
.green
= dstColor
.green
& ~srcColor
.green
;
178 dstColor
.blue
= dstColor
.blue
& ~srcColor
.blue
;
180 case wxAND_REVERSE
:// src AND (NOT dst)
181 dstColor
.red
= ~dstColor
.red
& srcColor
.red
;
182 dstColor
.green
= ~dstColor
.green
& srcColor
.green
;
183 dstColor
.blue
= ~dstColor
.blue
& srcColor
.blue
;
191 dstColor
.red
= srcColor
.red
;
192 dstColor
.green
= srcColor
.green
;
193 dstColor
.blue
= srcColor
.blue
;
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
;
200 case wxINVERT
: // NOT dst
201 dstColor
.red
= ~dstColor
.red
;
202 dstColor
.green
= ~dstColor
.green
;
203 dstColor
.blue
= ~dstColor
.blue
;
205 case wxNAND
: // (NOT src) OR (NOT dst)
206 dstColor
.red
= ~dstColor
.red
| ~srcColor
.red
;
207 dstColor
.green
= ~dstColor
.green
| ~srcColor
.green
;
208 dstColor
.blue
= ~dstColor
.blue
| ~srcColor
.blue
;
210 case wxNOR
: // (NOT src) AND (NOT dst)
211 dstColor
.red
= ~dstColor
.red
& ~srcColor
.red
;
212 dstColor
.green
= ~dstColor
.green
& ~srcColor
.green
;
213 dstColor
.blue
= ~dstColor
.blue
& ~srcColor
.blue
;
217 case wxOR
: // src OR dst
218 dstColor
.red
= dstColor
.red
| srcColor
.red
;
219 dstColor
.green
= dstColor
.green
| srcColor
.green
;
220 dstColor
.blue
= dstColor
.blue
| srcColor
.blue
;
222 case wxOR_INVERT
: // (NOT src) OR dst
223 dstColor
.red
= dstColor
.red
| ~srcColor
.red
;
224 dstColor
.green
= dstColor
.green
| ~srcColor
.green
;
225 dstColor
.blue
= dstColor
.blue
| ~srcColor
.blue
;
227 case wxOR_REVERSE
: // src OR (NOT dst)
228 dstColor
.red
= ~dstColor
.red
| srcColor
.red
;
229 dstColor
.green
= ~dstColor
.green
| srcColor
.green
;
230 dstColor
.blue
= ~dstColor
.blue
| srcColor
.blue
;
233 dstColor
.red
= 0xFFFF ;
234 dstColor
.green
= 0xFFFF ;
235 dstColor
.blue
= 0xFFFF ;
237 case wxSRC_INVERT
: // (NOT src)
238 dstColor
.red
= ~srcColor
.red
;
239 dstColor
.green
= ~srcColor
.green
;
240 dstColor
.blue
= ~srcColor
.blue
;
242 case wxXOR
: // src XOR dst
243 dstColor
.red
= dstColor
.red
^ srcColor
.red
;
244 dstColor
.green
= dstColor
.green
^ srcColor
.green
;
245 dstColor
.blue
= dstColor
.blue
^ srcColor
.blue
;
254 m_mm_to_pix_x
= mm2pt
;
255 m_mm_to_pix_y
= mm2pt
;
256 m_internalDeviceOriginX
= 0;
257 m_internalDeviceOriginY
= 0;
258 m_externalDeviceOriginX
= 0;
259 m_externalDeviceOriginY
= 0;
260 m_logicalScaleX
= 1.0;
261 m_logicalScaleY
= 1.0;
266 m_needComputeScaleX
= false;
267 m_needComputeScaleY
= false;
271 m_macFontInstalled
= false ;
272 m_macBrushInstalled
= false ;
273 m_macPenInstalled
= false ;
274 m_macLocalOrigin
.x
= m_macLocalOrigin
.y
= 0 ;
275 m_macBoundaryClipRgn
= NewRgn() ;
276 m_macCurrentClipRgn
= NewRgn() ;
277 SetRectRgn( (RgnHandle
) m_macBoundaryClipRgn
, -32000 , -32000 , 32000 , 32000 ) ;
278 SetRectRgn( (RgnHandle
) m_macCurrentClipRgn
, -32000 , -32000 , 32000 , 32000 ) ;
279 m_pen
= *wxBLACK_PEN
;
280 m_font
= *wxNORMAL_FONT
;
281 m_brush
= *wxWHITE_BRUSH
;
283 // needed to debug possible errors with two active drawing methods at the same time on
285 m_macCurrentPortStateHelper
= NULL
;
287 m_macATSUIStyle
= NULL
;
288 m_macAliasWasEnabled
= false;
289 m_macForegroundPixMap
= NULL
;
290 m_macBackgroundPixMap
= NULL
;
295 DisposeRgn( (RgnHandle
) m_macBoundaryClipRgn
) ;
296 DisposeRgn( (RgnHandle
) m_macCurrentClipRgn
) ;
299 void wxDC::MacSetupPort(wxMacPortStateHelper
* help
) const
302 wxASSERT( m_macCurrentPortStateHelper
== NULL
) ;
303 m_macCurrentPortStateHelper
= help
;
305 SetClip( (RgnHandle
) m_macCurrentClipRgn
);
306 #if ! wxMAC_EXPERIMENTAL_DC
307 m_macFontInstalled
= false ;
308 m_macBrushInstalled
= false ;
309 m_macPenInstalled
= false ;
312 void wxDC::MacCleanupPort(wxMacPortStateHelper
* help
) const
315 wxASSERT( m_macCurrentPortStateHelper
== help
) ;
316 m_macCurrentPortStateHelper
= NULL
;
318 if( m_macATSUIStyle
)
320 ::ATSUDisposeStyle((ATSUStyle
)m_macATSUIStyle
);
321 m_macATSUIStyle
= NULL
;
323 if ( m_macAliasWasEnabled
)
325 SetAntiAliasedTextEnabled(m_macFormerAliasState
, m_macFormerAliasSize
);
326 m_macAliasWasEnabled
= false ;
328 if ( m_macForegroundPixMap
)
331 ::PenPat(GetQDGlobalsBlack(&blackColor
));
332 DisposePixPat( (PixPatHandle
) m_macForegroundPixMap
) ;
333 m_macForegroundPixMap
= NULL
;
335 if ( m_macBackgroundPixMap
)
338 ::BackPat(GetQDGlobalsWhite(&whiteColor
));
339 DisposePixPat( (PixPatHandle
) m_macBackgroundPixMap
) ;
340 m_macBackgroundPixMap
= NULL
;
344 void wxDC::DoDrawBitmap( const wxBitmap
&bmp
, wxCoord x
, wxCoord y
, bool useMask
)
346 wxCHECK_RET( Ok(), wxT("invalid window dc") );
347 wxCHECK_RET( bmp
.Ok(), wxT("invalid bitmap") );
348 wxMacFastPortSetter
helper(this) ;
349 wxCoord xx
= XLOG2DEVMAC(x
);
350 wxCoord yy
= YLOG2DEVMAC(y
);
351 wxCoord w
= bmp
.GetWidth();
352 wxCoord h
= bmp
.GetHeight();
353 wxCoord ww
= XLOG2DEVREL(w
);
354 wxCoord hh
= YLOG2DEVREL(h
);
355 // Set up drawing mode
356 short mode
= (m_logicalFunction
== wxCOPY
? srcCopy
:
357 //m_logicalFunction == wxCLEAR ? WHITENESS :
358 //m_logicalFunction == wxSET ? BLACKNESS :
359 m_logicalFunction
== wxINVERT
? hilite
:
360 //m_logicalFunction == wxAND ? MERGECOPY :
361 m_logicalFunction
== wxOR
? srcOr
:
362 m_logicalFunction
== wxSRC_INVERT
? notSrcCopy
:
363 m_logicalFunction
== wxXOR
? srcXor
:
364 m_logicalFunction
== wxOR_REVERSE
? notSrcOr
:
365 //m_logicalFunction == wxAND_REVERSE ? SRCERASE :
366 //m_logicalFunction == wxSRC_OR ? srcOr :
367 //m_logicalFunction == wxSRC_AND ? SRCAND :
369 if ( bmp
.GetBitmapType() == kMacBitmapTypePict
) {
370 Rect bitmaprect
= { 0 , 0 , hh
, ww
};
371 ::OffsetRect( &bitmaprect
, xx
, yy
) ;
372 ::DrawPicture( (PicHandle
) bmp
.GetPict(), &bitmaprect
) ;
374 else if ( bmp
.GetBitmapType() == kMacBitmapTypeGrafWorld
)
376 GWorldPtr bmapworld
= MAC_WXHBITMAP( bmp
.GetHBITMAP() );
377 PixMapHandle bmappixels
;
378 // Set foreground and background colours (for bitmaps depth = 1)
379 if(bmp
.GetDepth() == 1)
381 RGBColor fore
= MAC_WXCOLORREF(m_textForegroundColour
.GetPixel());
382 RGBColor back
= MAC_WXCOLORREF(m_textBackgroundColour
.GetPixel());
388 RGBColor white
= { 0xFFFF, 0xFFFF,0xFFFF} ;
389 RGBColor black
= { 0,0,0} ;
390 RGBForeColor( &black
) ;
391 RGBBackColor( &white
) ;
393 bmappixels
= GetGWorldPixMap( bmapworld
) ;
394 wxCHECK_RET(LockPixels(bmappixels
),
395 wxT("DoDrawBitmap: Unable to lock pixels"));
396 Rect source
= { 0, 0, h
, w
};
397 Rect dest
= { yy
, xx
, yy
+ hh
, xx
+ ww
};
398 if ( useMask
&& bmp
.GetMask() )
400 if( LockPixels(GetGWorldPixMap(MAC_WXHBITMAP(bmp
.GetMask()->GetMaskBitmap()))))
404 GetPortBitMapForCopyBits(bmapworld
),
405 GetPortBitMapForCopyBits(MAC_WXHBITMAP(bmp
.GetMask()->GetMaskBitmap())),
406 GetPortBitMapForCopyBits( MAC_WXHBITMAP(m_macPort
) ),
407 &source
, &source
, &dest
, mode
, NULL
409 UnlockPixels(GetGWorldPixMap(MAC_WXHBITMAP(bmp
.GetMask()->GetMaskBitmap())));
413 CopyBits( GetPortBitMapForCopyBits( bmapworld
),
414 GetPortBitMapForCopyBits( MAC_WXHBITMAP(m_macPort
) ),
415 &source
, &dest
, mode
, NULL
) ;
417 UnlockPixels( bmappixels
) ;
419 else if ( bmp
.GetBitmapType() == kMacBitmapTypeIcon
)
421 Rect bitmaprect
= { 0 , 0 , bmp
.GetHeight(), bmp
.GetWidth() } ;
422 OffsetRect( &bitmaprect
, xx
, yy
) ;
423 PlotCIconHandle( &bitmaprect
, atNone
, ttNone
, MAC_WXHICON(bmp
.GetHICON()) ) ;
425 m_macPenInstalled
= false ;
426 m_macBrushInstalled
= false ;
427 m_macFontInstalled
= false ;
430 void wxDC::DoDrawIcon( const wxIcon
&icon
, wxCoord x
, wxCoord y
)
432 wxCHECK_RET(Ok(), wxT("Invalid dc wxDC::DoDrawIcon"));
433 wxCHECK_RET(icon
.Ok(), wxT("Invalid icon wxDC::DoDrawIcon"));
434 DoDrawBitmap( icon
, x
, y
, icon
.GetMask() != NULL
) ;
437 void wxDC::DoSetClippingRegion( wxCoord x
, wxCoord y
, wxCoord width
, wxCoord height
)
439 wxCHECK_RET(Ok(), wxT("wxDC::DoSetClippingRegion Invalid DC"));
440 wxCoord xx
, yy
, ww
, hh
;
443 ww
= XLOG2DEVREL(width
);
444 hh
= YLOG2DEVREL(height
);
445 SetRectRgn( (RgnHandle
) m_macCurrentClipRgn
, xx
, yy
, xx
+ ww
, yy
+ hh
) ;
446 SectRgn( (RgnHandle
) m_macCurrentClipRgn
, (RgnHandle
) m_macBoundaryClipRgn
, (RgnHandle
) m_macCurrentClipRgn
) ;
449 m_clipX1
= wxMax( m_clipX1
, xx
);
450 m_clipY1
= wxMax( m_clipY1
, yy
);
451 m_clipX2
= wxMin( m_clipX2
, (xx
+ ww
));
452 m_clipY2
= wxMin( m_clipY2
, (yy
+ hh
));
464 void wxDC::DoSetClippingRegionAsRegion( const wxRegion
®ion
)
466 wxCHECK_RET( Ok(), wxT("invalid window dc") ) ;
469 DestroyClippingRegion();
472 wxMacFastPortSetter
helper(this) ;
474 region
.GetBox( x
, y
, w
, h
);
475 wxCoord xx
, yy
, ww
, hh
;
480 // if we have a scaling that we cannot map onto native regions
481 // we must use the box
482 if ( ww
!= w
|| hh
!= h
)
484 wxDC::DoSetClippingRegion( x
, y
, w
, h
);
488 CopyRgn( (RgnHandle
) region
.GetWXHRGN() , (RgnHandle
) m_macCurrentClipRgn
) ;
489 if ( xx
!= x
|| yy
!= y
)
491 OffsetRgn( (RgnHandle
) m_macCurrentClipRgn
, xx
- x
, yy
- y
) ;
493 SectRgn( (RgnHandle
) m_macCurrentClipRgn
, (RgnHandle
) m_macBoundaryClipRgn
, (RgnHandle
) m_macCurrentClipRgn
) ;
496 m_clipX1
= wxMax( m_clipX1
, xx
);
497 m_clipY1
= wxMax( m_clipY1
, yy
);
498 m_clipX2
= wxMin( m_clipX2
, (xx
+ ww
));
499 m_clipY2
= wxMin( m_clipY2
, (yy
+ hh
));
512 void wxDC::DestroyClippingRegion()
514 wxMacFastPortSetter
helper(this) ;
515 CopyRgn( (RgnHandle
) m_macBoundaryClipRgn
, (RgnHandle
) m_macCurrentClipRgn
) ;
519 void wxDC::DoGetSizeMM( int* width
, int* height
) const
524 *width
= long( double(w
) / (m_scaleX
*m_mm_to_pix_x
) );
525 *height
= long( double(h
) / (m_scaleY
*m_mm_to_pix_y
) );
528 void wxDC::SetTextForeground( const wxColour
&col
)
530 wxCHECK_RET(Ok(), wxT("Invalid DC"));
531 m_textForegroundColour
= col
;
532 m_macFontInstalled
= false ;
535 void wxDC::SetTextBackground( const wxColour
&col
)
537 wxCHECK_RET(Ok(), wxT("Invalid DC"));
538 m_textBackgroundColour
= col
;
539 m_macFontInstalled
= false ;
542 void wxDC::SetMapMode( int mode
)
547 SetLogicalScale( twips2mm
*m_mm_to_pix_x
, twips2mm
*m_mm_to_pix_y
);
550 SetLogicalScale( pt2mm
*m_mm_to_pix_x
, pt2mm
*m_mm_to_pix_y
);
553 SetLogicalScale( m_mm_to_pix_x
, m_mm_to_pix_y
);
556 SetLogicalScale( m_mm_to_pix_x
/10.0, m_mm_to_pix_y
/10.0 );
560 SetLogicalScale( 1.0, 1.0 );
563 if (mode
!= wxMM_TEXT
)
565 m_needComputeScaleX
= true;
566 m_needComputeScaleY
= true;
570 void wxDC::SetUserScale( double x
, double y
)
572 // allow negative ? -> no
575 ComputeScaleAndOrigin();
578 void wxDC::SetLogicalScale( double x
, double y
)
583 ComputeScaleAndOrigin();
586 void wxDC::SetLogicalOrigin( wxCoord x
, wxCoord y
)
588 m_logicalOriginX
= x
* m_signX
; // is this still correct ?
589 m_logicalOriginY
= y
* m_signY
;
590 ComputeScaleAndOrigin();
593 void wxDC::SetDeviceOrigin( wxCoord x
, wxCoord y
)
595 m_externalDeviceOriginX
= x
;
596 m_externalDeviceOriginY
= y
;
597 ComputeScaleAndOrigin();
600 void wxDC::SetAxisOrientation( bool xLeftRight
, bool yBottomUp
)
602 m_signX
= (xLeftRight
? 1 : -1);
603 m_signY
= (yBottomUp
? -1 : 1);
604 ComputeScaleAndOrigin();
607 wxSize
wxDC::GetPPI() const
609 return wxSize(72, 72);
612 int wxDC::GetDepth() const
614 if ( IsPortColor( (CGrafPtr
) m_macPort
) )
616 return ( (**GetPortPixMap( (CGrafPtr
) m_macPort
)).pixelSize
) ;
621 void wxDC::ComputeScaleAndOrigin()
623 // CMB: copy scale to see if it changes
624 double origScaleX
= m_scaleX
;
625 double origScaleY
= m_scaleY
;
626 m_scaleX
= m_logicalScaleX
* m_userScaleX
;
627 m_scaleY
= m_logicalScaleY
* m_userScaleY
;
628 m_deviceOriginX
= m_internalDeviceOriginX
+ m_externalDeviceOriginX
;
629 m_deviceOriginY
= m_internalDeviceOriginY
+ m_externalDeviceOriginY
;
630 // CMB: if scale has changed call SetPen to recalulate the line width
631 if (m_scaleX
!= origScaleX
|| m_scaleY
!= origScaleY
)
633 // this is a bit artificial, but we need to force wxDC to think
634 // the pen has changed
641 void wxDC::SetPalette( const wxPalette
& palette
)
645 void wxDC::SetBackgroundMode( int mode
)
647 m_backgroundMode
= mode
;
650 void wxDC::SetFont( const wxFont
&font
)
653 m_macFontInstalled
= false ;
656 void wxDC::SetPen( const wxPen
&pen
)
661 m_macPenInstalled
= false ;
664 void wxDC::SetBrush( const wxBrush
&brush
)
666 if (m_brush
== brush
)
669 m_macBrushInstalled
= false ;
672 void wxDC::SetBackground( const wxBrush
&brush
)
674 if (m_backgroundBrush
== brush
)
676 m_backgroundBrush
= brush
;
677 if (!m_backgroundBrush
.Ok())
679 m_macBrushInstalled
= false ;
682 void wxDC::SetLogicalFunction( int function
)
684 if (m_logicalFunction
== function
)
686 m_logicalFunction
= function
;
687 m_macFontInstalled
= false ;
688 m_macBrushInstalled
= false ;
689 m_macPenInstalled
= false ;
692 extern bool wxDoFloodFill(wxDC
*dc
, wxCoord x
, wxCoord y
,
693 const wxColour
& col
, int style
);
695 bool wxDC::DoFloodFill(wxCoord x
, wxCoord y
,
696 const wxColour
& col
, int style
)
698 return wxDoFloodFill(this, x
, y
, col
, style
);
701 bool wxDC::DoGetPixel( wxCoord x
, wxCoord y
, wxColour
*col
) const
703 wxCHECK_MSG( Ok(), false, wxT("wxDC::DoGetPixel Invalid DC") );
704 wxMacFastPortSetter
helper(this) ;
706 GetCPixel( XLOG2DEVMAC(x
), YLOG2DEVMAC(y
), &colour
);
707 // Convert from Mac colour to wx
708 col
->Set( colour
.red
>> 8,
714 void wxDC::DoDrawLine( wxCoord x1
, wxCoord y1
, wxCoord x2
, wxCoord y2
)
716 wxCHECK_RET(Ok(), wxT("Invalid DC"));
717 wxMacFastPortSetter
helper(this) ;
718 if (m_pen
.GetStyle() != wxTRANSPARENT
)
721 wxCoord offset
= ( (m_pen
.GetWidth() == 0 ? 1 :
722 m_pen
.GetWidth() ) * (wxCoord
)m_scaleX
- 1) / 2;
723 wxCoord xx1
= XLOG2DEVMAC(x1
) - offset
;
724 wxCoord yy1
= YLOG2DEVMAC(y1
) - offset
;
725 wxCoord xx2
= XLOG2DEVMAC(x2
) - offset
;
726 wxCoord yy2
= YLOG2DEVMAC(y2
) - offset
;
727 if ((m_pen
.GetCap() == wxCAP_ROUND
) &&
728 (m_pen
.GetWidth() <= 1))
730 // Implement LAST_NOT for MAC at least for
731 // orthogonal lines. RR.
752 void wxDC::DoCrossHair( wxCoord x
, wxCoord y
)
754 wxCHECK_RET( Ok(), wxT("wxDC::DoCrossHair Invalid window dc") );
755 wxMacFastPortSetter
helper(this) ;
756 if (m_pen
.GetStyle() != wxTRANSPARENT
)
761 wxCoord xx
= XLOG2DEVMAC(x
);
762 wxCoord yy
= YLOG2DEVMAC(y
);
764 ::MoveTo( XLOG2DEVMAC(0), yy
);
765 ::LineTo( XLOG2DEVMAC(w
), yy
);
766 ::MoveTo( xx
, YLOG2DEVMAC(0) );
767 ::LineTo( xx
, YLOG2DEVMAC(h
) );
768 CalcBoundingBox(x
, y
);
769 CalcBoundingBox(x
+w
, y
+h
);
774 * To draw arcs properly the angles need to be converted from the WX style:
775 * Angles start on the +ve X axis and go anti-clockwise (As you would draw on
776 * a normal axis on paper).
779 * Angles start on the +ve y axis and go clockwise.
782 static double wxConvertWXangleToMACangle(double angle
)
784 double newAngle
= 90 - angle
;
785 while ( newAngle
> 360 ) newAngle
-= 360 ;
786 while ( newAngle
< 0 ) newAngle
+= 360 ;
790 void wxDC::DoDrawArc( wxCoord x1
, wxCoord y1
,
791 wxCoord x2
, wxCoord y2
,
792 wxCoord xc
, wxCoord yc
)
794 wxCHECK_RET(Ok(), wxT("wxDC::DoDrawArc Invalid DC"));
795 wxMacFastPortSetter
helper(this) ;
796 wxCoord xx1
= XLOG2DEVMAC(x1
);
797 wxCoord yy1
= YLOG2DEVMAC(y1
);
798 wxCoord xx2
= XLOG2DEVMAC(x2
);
799 wxCoord yy2
= YLOG2DEVMAC(y2
);
800 wxCoord xxc
= XLOG2DEVMAC(xc
);
801 wxCoord yyc
= YLOG2DEVMAC(yc
);
802 double dx
= xx1
- xxc
;
803 double dy
= yy1
- yyc
;
804 double radius
= sqrt((double)(dx
*dx
+dy
*dy
));
805 wxCoord rad
= (wxCoord
)radius
;
806 double radius1
, radius2
;
807 if (xx1
== xx2
&& yy1
== yy2
)
812 else if (radius
== 0.0)
814 radius1
= radius2
= 0.0;
818 radius1
= (xx1
- xxc
== 0) ?
819 (yy1
- yyc
< 0) ? 90.0 : -90.0 :
820 -atan2(double(yy1
-yyc
), double(xx1
-xxc
)) * RAD2DEG
;
821 radius2
= (xx2
- xxc
== 0) ?
822 (yy2
- yyc
< 0) ? 90.0 : -90.0 :
823 -atan2(double(yy2
-yyc
), double(xx2
-xxc
)) * RAD2DEG
;
825 wxCoord alpha2
= wxCoord(radius2
- radius1
);
826 wxCoord alpha1
= wxCoord(wxConvertWXangleToMACangle(radius1
));
827 while( alpha2
< 0 ) alpha2
+= 360 ;
829 Rect r
= { yyc
- rad
, xxc
- rad
, yyc
+ rad
, xxc
+ rad
};
830 if(m_brush
.GetStyle() != wxTRANSPARENT
) {
832 PaintArc(&r
, alpha1
, alpha2
);
834 if(m_pen
.GetStyle() != wxTRANSPARENT
) {
836 FrameArc(&r
, alpha1
, alpha2
);
840 void wxDC::DoDrawEllipticArc( wxCoord x
, wxCoord y
, wxCoord w
, wxCoord h
,
841 double sa
, double ea
)
843 wxCHECK_RET(Ok(), wxT("wxDC::DoDrawEllepticArc Invalid DC"));
844 wxMacFastPortSetter
helper(this) ;
846 double angle
= sa
- ea
; // Order important Mac in opposite direction to wx
847 // we have to make sure that the filling is always counter-clockwise
850 wxCoord xx
= XLOG2DEVMAC(x
);
851 wxCoord yy
= YLOG2DEVMAC(y
);
852 wxCoord ww
= m_signX
* XLOG2DEVREL(w
);
853 wxCoord hh
= m_signY
* YLOG2DEVREL(h
);
854 // handle -ve width and/or height
855 if (ww
< 0) { ww
= -ww
; xx
= xx
- ww
; }
856 if (hh
< 0) { hh
= -hh
; yy
= yy
- hh
; }
857 sa
= wxConvertWXangleToMACangle(sa
);
862 if(m_brush
.GetStyle() != wxTRANSPARENT
) {
864 PaintArc(&r
, (short)sa
, (short)angle
);
866 if(m_pen
.GetStyle() != wxTRANSPARENT
) {
868 FrameArc(&r
, (short)sa
, (short)angle
);
872 void wxDC::DoDrawPoint( wxCoord x
, wxCoord y
)
874 wxCHECK_RET(Ok(), wxT("Invalid DC"));
875 wxMacFastPortSetter
helper(this) ;
876 if (m_pen
.GetStyle() != wxTRANSPARENT
)
878 wxCoord xx1
= XLOG2DEVMAC(x
);
879 wxCoord yy1
= YLOG2DEVMAC(y
);
880 RGBColor pencolor
= MAC_WXCOLORREF( m_pen
.GetColour().GetPixel());
881 ::SetCPixel( xx1
,yy1
,&pencolor
) ;
882 CalcBoundingBox(x
, y
);
886 void wxDC::DoDrawLines(int n
, wxPoint points
[],
887 wxCoord xoffset
, wxCoord yoffset
)
889 wxCHECK_RET(Ok(), wxT("Invalid DC"));
890 wxMacFastPortSetter
helper(this) ;
891 if (m_pen
.GetStyle() == wxTRANSPARENT
)
894 wxCoord offset
= ( (m_pen
.GetWidth() == 0 ? 1 :
895 m_pen
.GetWidth() ) * (wxCoord
)m_scaleX
- 1) / 2 ;
896 wxCoord x1
, x2
, y1
, y2
;
897 x1
= XLOG2DEVMAC(points
[0].x
+ xoffset
);
898 y1
= YLOG2DEVMAC(points
[0].y
+ yoffset
);
899 ::MoveTo(x1
- offset
, y1
- offset
);
900 for (int i
= 0; i
< n
-1; i
++)
902 x2
= XLOG2DEVMAC(points
[i
+1].x
+ xoffset
);
903 y2
= YLOG2DEVMAC(points
[i
+1].y
+ yoffset
);
904 ::LineTo( x2
- offset
, y2
- offset
);
908 void wxDC::DoDrawPolygon(int n
, wxPoint points
[],
909 wxCoord xoffset
, wxCoord yoffset
,
912 wxCHECK_RET(Ok(), wxT("Invalid DC"));
913 wxMacFastPortSetter
helper(this) ;
914 wxCoord x1
, x2
, y1
, y2
;
915 if ( m_brush
.GetStyle() == wxTRANSPARENT
&& m_pen
.GetStyle() == wxTRANSPARENT
)
917 PolyHandle polygon
= OpenPoly();
918 x2
= x1
= XLOG2DEVMAC(points
[0].x
+ xoffset
);
919 y2
= y1
= YLOG2DEVMAC(points
[0].y
+ yoffset
);
921 for (int i
= 1; i
< n
; i
++)
923 x2
= XLOG2DEVMAC(points
[i
].x
+ xoffset
);
924 y2
= YLOG2DEVMAC(points
[i
].y
+ yoffset
);
927 // close the polyline if necessary
928 if ( x1
!= x2
|| y1
!= y2
)
933 if (m_brush
.GetStyle() != wxTRANSPARENT
)
936 ::PaintPoly( polygon
);
938 if (m_pen
.GetStyle() != wxTRANSPARENT
)
941 ::FramePoly( polygon
) ;
946 void wxDC::DoDrawRectangle(wxCoord x
, wxCoord y
, wxCoord width
, wxCoord height
)
948 wxCHECK_RET(Ok(), wxT("Invalid DC"));
949 wxMacFastPortSetter
helper(this) ;
950 wxCoord xx
= XLOG2DEVMAC(x
);
951 wxCoord yy
= YLOG2DEVMAC(y
);
952 wxCoord ww
= m_signX
* XLOG2DEVREL(width
);
953 wxCoord hh
= m_signY
* YLOG2DEVREL(height
);
954 // CMB: draw nothing if transformed w or h is 0
955 if (ww
== 0 || hh
== 0)
957 // CMB: handle -ve width and/or height
968 Rect rect
= { yy
, xx
, yy
+ hh
, xx
+ ww
} ;
969 if (m_brush
.GetStyle() != wxTRANSPARENT
)
972 ::PaintRect( &rect
) ;
974 if (m_pen
.GetStyle() != wxTRANSPARENT
)
977 ::FrameRect( &rect
) ;
981 void wxDC::DoDrawRoundedRectangle(wxCoord x
, wxCoord y
,
982 wxCoord width
, wxCoord height
,
985 wxCHECK_RET(Ok(), wxT("Invalid DC"));
986 wxMacFastPortSetter
helper(this) ;
988 radius
= - radius
* ((width
< height
) ? width
: height
);
989 wxCoord xx
= XLOG2DEVMAC(x
);
990 wxCoord yy
= YLOG2DEVMAC(y
);
991 wxCoord ww
= m_signX
* XLOG2DEVREL(width
);
992 wxCoord hh
= m_signY
* YLOG2DEVREL(height
);
993 // CMB: draw nothing if transformed w or h is 0
994 if (ww
== 0 || hh
== 0)
996 // CMB: handle -ve width and/or height
1007 Rect rect
= { yy
, xx
, yy
+ hh
, xx
+ ww
} ;
1008 if (m_brush
.GetStyle() != wxTRANSPARENT
)
1011 ::PaintRoundRect( &rect
, int(radius
* 2) , int(radius
* 2) ) ;
1013 if (m_pen
.GetStyle() != wxTRANSPARENT
)
1016 ::FrameRoundRect( &rect
, int(radius
* 2) , int(radius
* 2) ) ;
1020 void wxDC::DoDrawEllipse(wxCoord x
, wxCoord y
, wxCoord width
, wxCoord height
)
1022 wxCHECK_RET(Ok(), wxT("Invalid DC"));
1023 wxMacFastPortSetter
helper(this) ;
1024 wxCoord xx
= XLOG2DEVMAC(x
);
1025 wxCoord yy
= YLOG2DEVMAC(y
);
1026 wxCoord ww
= m_signX
* XLOG2DEVREL(width
);
1027 wxCoord hh
= m_signY
* YLOG2DEVREL(height
);
1028 // CMB: draw nothing if transformed w or h is 0
1029 if (ww
== 0 || hh
== 0)
1031 // CMB: handle -ve width and/or height
1042 Rect rect
= { yy
, xx
, yy
+ hh
, xx
+ ww
} ;
1043 if (m_brush
.GetStyle() != wxTRANSPARENT
)
1046 ::PaintOval( &rect
) ;
1048 if (m_pen
.GetStyle() != wxTRANSPARENT
)
1051 ::FrameOval( &rect
) ;
1055 bool wxDC::CanDrawBitmap(void) const
1060 bool wxDC::DoBlit(wxCoord xdest
, wxCoord ydest
, wxCoord width
, wxCoord height
,
1061 wxDC
*source
, wxCoord xsrc
, wxCoord ysrc
, int logical_func
, bool useMask
,
1062 wxCoord xsrcMask
, wxCoord ysrcMask
)
1064 wxCHECK_MSG(Ok(), false, wxT("wxDC::DoBlit Illegal dc"));
1065 wxCHECK_MSG(source
->Ok(), false, wxT("wxDC::DoBlit Illegal source DC"));
1066 if ( logical_func
== wxNO_OP
)
1068 if (xsrcMask
== -1 && ysrcMask
== -1)
1070 xsrcMask
= xsrc
; ysrcMask
= ysrc
;
1072 // correct the parameter in case this dc does not have a mask at all
1073 if ( useMask
&& !source
->m_macMask
)
1075 Rect srcrect
, dstrect
;
1076 srcrect
.top
= source
->YLOG2DEVMAC(ysrc
) ;
1077 srcrect
.left
= source
->XLOG2DEVMAC(xsrc
) ;
1078 srcrect
.right
= source
->XLOG2DEVMAC(xsrc
+ width
) ;
1079 srcrect
.bottom
= source
->YLOG2DEVMAC(ysrc
+ height
) ;
1080 dstrect
.top
= YLOG2DEVMAC(ydest
) ;
1081 dstrect
.left
= XLOG2DEVMAC(xdest
) ;
1082 dstrect
.bottom
= YLOG2DEVMAC(ydest
+ height
) ;
1083 dstrect
.right
= XLOG2DEVMAC(xdest
+ width
) ;
1084 short mode
= kUnsupportedMode
;
1085 bool invertDestinationFirst
= false ;
1086 switch ( logical_func
)
1088 case wxAND
: // src AND dst
1089 mode
= adMin
; // ok
1091 case wxAND_INVERT
: // (NOT src) AND dst
1092 mode
= notSrcOr
; // ok
1094 case wxAND_REVERSE
:// src AND (NOT dst)
1095 invertDestinationFirst
= true ;
1099 mode
= kEmulatedMode
;
1102 mode
= srcCopy
; // ok
1104 case wxEQUIV
: // (NOT src) XOR dst
1105 mode
= srcXor
; // ok
1107 case wxINVERT
: // NOT dst
1108 mode
= kEmulatedMode
; //or hilite ;
1110 case wxNAND
: // (NOT src) OR (NOT dst)
1111 invertDestinationFirst
= true ;
1114 case wxNOR
: // (NOT src) AND (NOT dst)
1115 invertDestinationFirst
= true ;
1118 case wxNO_OP
: // dst
1119 mode
= kEmulatedMode
; // this has already been handled upon entry
1121 case wxOR
: // src OR dst
1124 case wxOR_INVERT
: // (NOT src) OR dst
1127 case wxOR_REVERSE
: // src OR (NOT dst)
1128 invertDestinationFirst
= true ;
1132 mode
= kEmulatedMode
;
1134 case wxSRC_INVERT
: // (NOT src)
1135 mode
= notSrcCopy
; // ok
1137 case wxXOR
: // src XOR dst
1138 mode
= notSrcXor
; // ok
1143 if ( mode
== kUnsupportedMode
)
1145 wxFAIL_MSG(wxT("unsupported blitting mode" ));
1148 CGrafPtr sourcePort
= (CGrafPtr
) source
->m_macPort
;
1149 PixMapHandle bmappixels
= GetGWorldPixMap( sourcePort
) ;
1150 if ( LockPixels(bmappixels
) )
1152 wxMacFastPortSetter
helper(this) ;
1153 if ( source
->GetDepth() == 1 )
1155 RGBForeColor( &MAC_WXCOLORREF(m_textForegroundColour
.GetPixel()) ) ;
1156 RGBBackColor( &MAC_WXCOLORREF(m_textBackgroundColour
.GetPixel()) ) ;
1160 // the modes need this, otherwise we'll end up having really nice colors...
1161 RGBColor white
= { 0xFFFF, 0xFFFF,0xFFFF} ;
1162 RGBColor black
= { 0,0,0} ;
1163 RGBForeColor( &black
) ;
1164 RGBBackColor( &white
) ;
1166 if ( useMask
&& source
->m_macMask
)
1168 if ( mode
== srcCopy
)
1170 if ( LockPixels( GetGWorldPixMap( MAC_WXHBITMAP(source
->m_macMask
) ) ) )
1172 CopyMask( GetPortBitMapForCopyBits( sourcePort
) ,
1173 GetPortBitMapForCopyBits( MAC_WXHBITMAP(source
->m_macMask
) ) ,
1174 GetPortBitMapForCopyBits( MAC_WXHBITMAP(m_macPort
) ) ,
1175 &srcrect
, &srcrect
, &dstrect
) ;
1176 UnlockPixels( GetGWorldPixMap( MAC_WXHBITMAP(source
->m_macMask
) ) ) ;
1181 RgnHandle clipRgn
= NewRgn() ;
1182 LockPixels( GetGWorldPixMap( MAC_WXHBITMAP(source
->m_macMask
) ) ) ;
1183 BitMapToRegion( clipRgn
, (BitMap
*) *GetGWorldPixMap( MAC_WXHBITMAP(source
->m_macMask
) ) ) ;
1184 UnlockPixels( GetGWorldPixMap( MAC_WXHBITMAP(source
->m_macMask
) ) ) ;
1185 OffsetRgn( clipRgn
, -srcrect
.left
+ dstrect
.left
, -srcrect
.top
+ dstrect
.top
) ;
1186 if ( mode
== kEmulatedMode
)
1189 ::PenPat(GetQDGlobalsBlack(&pat
));
1190 if ( logical_func
== wxSET
)
1192 RGBColor col
= { 0xFFFF, 0xFFFF, 0xFFFF } ;
1193 ::RGBForeColor( &col
) ;
1194 ::PaintRgn( clipRgn
) ;
1196 else if ( logical_func
== wxCLEAR
)
1198 RGBColor col
= { 0x0000, 0x0000, 0x0000 } ;
1199 ::RGBForeColor( &col
) ;
1200 ::PaintRgn( clipRgn
) ;
1202 else if ( logical_func
== wxINVERT
)
1204 MacInvertRgn( clipRgn
) ;
1208 for ( int y
= 0 ; y
< srcrect
.right
- srcrect
.left
; ++y
)
1210 for ( int x
= 0 ; x
< srcrect
.bottom
- srcrect
.top
; ++x
)
1212 Point dstPoint
= { dstrect
.top
+ y
, dstrect
.left
+ x
} ;
1213 Point srcPoint
= { srcrect
.top
+ y
, srcrect
.left
+ x
} ;
1214 if ( PtInRgn( dstPoint
, clipRgn
) )
1218 SetPort( (GrafPtr
) sourcePort
) ;
1219 GetCPixel( srcPoint
.h
, srcPoint
.v
, &srcColor
) ;
1220 SetPort( (GrafPtr
) m_macPort
) ;
1221 GetCPixel( dstPoint
.h
, dstPoint
.v
, &dstColor
) ;
1222 wxMacCalculateColour( logical_func
, srcColor
, dstColor
) ;
1223 SetCPixel( dstPoint
.h
, dstPoint
.v
, &dstColor
) ;
1231 if ( invertDestinationFirst
)
1233 MacInvertRgn( clipRgn
) ;
1235 CopyBits( GetPortBitMapForCopyBits( sourcePort
) ,
1236 GetPortBitMapForCopyBits( MAC_WXHBITMAP(m_macPort
) ) ,
1237 &srcrect
, &dstrect
, mode
, clipRgn
) ;
1239 DisposeRgn( clipRgn
) ;
1244 RgnHandle clipRgn
= NewRgn() ;
1245 SetRectRgn( clipRgn
, dstrect
.left
, dstrect
.top
, dstrect
.right
, dstrect
.bottom
) ;
1246 if ( mode
== kEmulatedMode
)
1249 ::PenPat(GetQDGlobalsBlack(&pat
));
1250 if ( logical_func
== wxSET
)
1252 RGBColor col
= { 0xFFFF, 0xFFFF, 0xFFFF } ;
1253 ::RGBForeColor( &col
) ;
1254 ::PaintRgn( clipRgn
) ;
1256 else if ( logical_func
== wxCLEAR
)
1258 RGBColor col
= { 0x0000, 0x0000, 0x0000 } ;
1259 ::RGBForeColor( &col
) ;
1260 ::PaintRgn( clipRgn
) ;
1262 else if ( logical_func
== wxINVERT
)
1264 MacInvertRgn( clipRgn
) ;
1268 for ( int y
= 0 ; y
< srcrect
.right
- srcrect
.left
; ++y
)
1270 for ( int x
= 0 ; x
< srcrect
.bottom
- srcrect
.top
; ++x
)
1272 Point dstPoint
= { dstrect
.top
+ y
, dstrect
.left
+ x
} ;
1273 Point srcPoint
= { srcrect
.top
+ y
, srcrect
.left
+ x
} ;
1277 SetPort( (GrafPtr
) sourcePort
) ;
1278 GetCPixel( srcPoint
.h
, srcPoint
.v
, &srcColor
) ;
1279 SetPort( (GrafPtr
) m_macPort
) ;
1280 GetCPixel( dstPoint
.h
, dstPoint
.v
, &dstColor
) ;
1281 wxMacCalculateColour( logical_func
, srcColor
, dstColor
) ;
1282 SetCPixel( dstPoint
.h
, dstPoint
.v
, &dstColor
) ;
1290 if ( invertDestinationFirst
)
1292 MacInvertRgn( clipRgn
) ;
1294 CopyBits( GetPortBitMapForCopyBits( sourcePort
) ,
1295 GetPortBitMapForCopyBits( MAC_WXHBITMAP(m_macPort
) ) ,
1296 &srcrect
, &dstrect
, mode
, NULL
) ;
1298 DisposeRgn( clipRgn
) ;
1300 UnlockPixels( bmappixels
) ;
1302 m_macPenInstalled
= false ;
1303 m_macBrushInstalled
= false ;
1304 m_macFontInstalled
= false ;
1309 // as macro in FixMath.h for 10.3
1310 inline Fixed
IntToFixed( int inInt
)
1312 return (((SInt32
) inInt
) << 16);
1315 inline int FixedToInt( Fixed inFixed
)
1317 return (((SInt32
) inFixed
) >> 16);
1321 void wxDC::DoDrawRotatedText(const wxString
& str
, wxCoord x
, wxCoord y
,
1324 // TODO support text background color (only possible by hand, ATSUI does not support it)
1325 wxCHECK_RET( Ok(), wxT("wxDC::DoDrawRotatedText Invalid window dc") );
1327 if ( str
.Length() == 0 )
1330 wxMacFastPortSetter
helper(this) ;
1335 m_macFormerAliasState
= IsAntiAliasedTextEnabled(&m_macFormerAliasSize
);
1336 SetAntiAliasedTextEnabled(true, SInt16(m_scaleY
* m_font
.MacGetFontSize()));
1337 m_macAliasWasEnabled
= true ;
1339 OSStatus status
= noErr
;
1340 ATSUTextLayout atsuLayout
;
1341 UniCharCount chars
= str
.Length() ;
1342 UniChar
* ubuf
= NULL
;
1343 #if SIZEOF_WCHAR_T == 4
1344 wxMBConvUTF16BE converter
;
1346 size_t unicharlen
= converter
.WC2MB( NULL
, str
.wc_str() , 0 ) ;
1347 ubuf
= (UniChar
*) malloc( unicharlen
+ 2 ) ;
1348 converter
.WC2MB( (char*) ubuf
, str
.wc_str(), unicharlen
+ 2 ) ;
1350 const wxWCharBuffer wchar
= str
.wc_str( wxConvLocal
) ;
1351 size_t unicharlen
= converter
.WC2MB( NULL
, wchar
.data() , 0 ) ;
1352 ubuf
= (UniChar
*) malloc( unicharlen
+ 2 ) ;
1353 converter
.WC2MB( (char*) ubuf
, wchar
.data() , unicharlen
+ 2 ) ;
1355 chars
= unicharlen
/ 2 ;
1358 ubuf
= (UniChar
*) str
.wc_str() ;
1360 wxWCharBuffer wchar
= str
.wc_str( wxConvLocal
) ;
1361 chars
= wxWcslen( wchar
.data() ) ;
1362 ubuf
= (UniChar
*) wchar
.data() ;
1366 status
= ::ATSUCreateTextLayoutWithTextPtr( (UniCharArrayPtr
) ubuf
, 0 , chars
, chars
, 1 ,
1367 &chars
, (ATSUStyle
*) &m_macATSUIStyle
, &atsuLayout
) ;
1369 wxASSERT_MSG( status
== noErr
, wxT("couldn't create the layout of the rotated text") );
1370 int iAngle
= int( angle
);
1371 int drawX
= XLOG2DEVMAC(x
) ;
1372 int drawY
= YLOG2DEVMAC(y
) ;
1374 ATSUTextMeasurement textBefore
;
1375 ATSUTextMeasurement textAfter
;
1376 ATSUTextMeasurement ascent
;
1377 ATSUTextMeasurement descent
;
1380 if ( abs(iAngle
) > 0 )
1382 Fixed atsuAngle
= IntToFixed( iAngle
) ;
1383 ATSUAttributeTag atsuTags
[] =
1385 kATSULineRotationTag
,
1387 ByteCount atsuSizes
[sizeof(atsuTags
)/sizeof(ATSUAttributeTag
)] =
1391 ATSUAttributeValuePtr atsuValues
[sizeof(atsuTags
)/sizeof(ATSUAttributeTag
)] =
1395 status
= ::ATSUSetLayoutControls(atsuLayout
, sizeof(atsuTags
)/sizeof(ATSUAttributeTag
),
1396 atsuTags
, atsuSizes
, atsuValues
) ;
1398 status
= ::ATSUMeasureText( atsuLayout
, kATSUFromTextBeginning
, kATSUToTextEnd
,
1399 &textBefore
, &textAfter
, &ascent
, &descent
);
1401 drawX
+= (int)(sin(angle
/RAD2DEG
) * FixedToInt(ascent
));
1402 drawY
+= (int)(cos(angle
/RAD2DEG
) * FixedToInt(ascent
));
1403 status
= ::ATSUDrawText( atsuLayout
, kATSUFromTextBeginning
, kATSUToTextEnd
,
1404 IntToFixed(drawX
) , IntToFixed(drawY
) );
1405 wxASSERT_MSG( status
== noErr
, wxT("couldn't draw the rotated text") );
1407 status
= ::ATSUMeasureTextImage( atsuLayout
, kATSUFromTextBeginning
, kATSUToTextEnd
,
1408 IntToFixed(drawX
) , IntToFixed(drawY
) , &rect
);
1409 wxASSERT_MSG( status
== noErr
, wxT("couldn't measure the rotated text") );
1410 OffsetRect( &rect
, -m_macLocalOrigin
.x
, -m_macLocalOrigin
.y
) ;
1411 CalcBoundingBox(XDEV2LOG(rect
.left
), YDEV2LOG(rect
.top
) );
1412 CalcBoundingBox(XDEV2LOG(rect
.right
), YDEV2LOG(rect
.bottom
) );
1413 ::ATSUDisposeTextLayout(atsuLayout
);
1414 #if SIZEOF_WCHAR_T == 4
1419 void wxDC::DoDrawText(const wxString
& strtext
, wxCoord x
, wxCoord y
)
1421 wxCHECK_RET(Ok(), wxT("wxDC::DoDrawText Invalid DC"));
1423 wxMacFastPortSetter
helper(this) ;
1424 long xx
= XLOG2DEVMAC(x
);
1425 long yy
= YLOG2DEVMAC(y
);
1427 bool useDrawThemeText
= ( DrawThemeTextBox
!= (void*) kUnresolvedCFragSymbolAddress
) ;
1428 if ( UMAGetSystemVersion() < 0x1000 || IsKindOf(CLASSINFO( wxPrinterDC
) ) || m_font
.GetNoAntiAliasing() )
1429 useDrawThemeText
= false ;
1434 ::GetFontInfo( &fi
) ;
1436 if ( !useDrawThemeText
)
1439 ::MoveTo( xx
, yy
);
1440 if ( m_backgroundMode
== wxTRANSPARENT
)
1442 ::TextMode( srcOr
) ;
1446 ::TextMode( srcCopy
) ;
1450 wxString linetext
= strtext
;
1452 if ( useDrawThemeText
)
1454 Rect frame
= { yy
+ line
*(fi
.descent
+ fi
.ascent
+ fi
.leading
) ,xx
, yy
+ (line
+1)*(fi
.descent
+ fi
.ascent
+ fi
.leading
) , xx
+ 10000 } ;
1455 wxMacCFStringHolder
mString( linetext
, m_font
.GetEncoding()) ;
1457 if ( m_backgroundMode
!= wxTRANSPARENT
)
1459 Point bounds
={0,0} ;
1460 Rect background
= frame
;
1462 ::GetThemeTextDimensions( mString
,
1463 m_font
.MacGetThemeFontID() ,
1468 background
.right
= background
.left
+ bounds
.h
;
1469 background
.bottom
= background
.top
+ bounds
.v
;
1470 ::EraseRect( &background
) ;
1472 ::DrawThemeTextBox( mString
,
1473 m_font
.MacGetThemeFontID() ,
1483 wxCharBuffer text
= linetext
.mb_str(wxConvLocal
) ;
1484 ::DrawText( text
, 0 , strlen(text
) ) ;
1487 ::TextMode( srcOr
) ;
1490 bool wxDC::CanGetTextExtent() const
1492 wxCHECK_MSG(Ok(), false, wxT("Invalid DC"));
1496 void wxDC::DoGetTextExtent( const wxString
&strtext
, wxCoord
*width
, wxCoord
*height
,
1497 wxCoord
*descent
, wxCoord
*externalLeading
,
1498 wxFont
*theFont
) const
1500 wxCHECK_RET(Ok(), wxT("Invalid DC"));
1501 wxMacFastPortSetter
helper(this) ;
1502 wxFont formerFont
= m_font
;
1505 // work around the constness
1506 *((wxFont
*)(&m_font
)) = *theFont
;
1510 ::GetFontInfo( &fi
) ;
1512 bool useGetThemeText
= ( GetThemeTextDimensions
!= (void*) kUnresolvedCFragSymbolAddress
) ;
1513 if ( UMAGetSystemVersion() < 0x1000 || IsKindOf(CLASSINFO( wxPrinterDC
) ) || ((wxFont
*)&m_font
)->GetNoAntiAliasing() )
1514 useGetThemeText
= false ;
1517 *height
= YDEV2LOGREL( fi
.descent
+ fi
.ascent
) ;
1519 *descent
=YDEV2LOGREL( fi
.descent
);
1520 if ( externalLeading
)
1521 *externalLeading
= YDEV2LOGREL( fi
.leading
) ;
1527 wxString linetext
= strtext
;
1529 if ( useGetThemeText
)
1531 Point bounds
={0,0} ;
1533 wxMacCFStringHolder
mString( linetext
, m_font
.GetEncoding() ) ;
1534 ThemeFontID themeFont
= m_font
.MacGetThemeFontID() ;
1535 ::GetThemeTextDimensions( mString
,
1541 curwidth
= bounds
.h
;
1545 wxCharBuffer text
= linetext
.mb_str(wxConvLocal
) ;
1546 curwidth
= ::TextWidth( text
, 0 , strlen(text
) ) ;
1548 if ( curwidth
> *width
)
1549 *width
= XDEV2LOGREL( curwidth
) ;
1553 // work around the constness
1554 *((wxFont
*)(&m_font
)) = formerFont
;
1555 m_macFontInstalled
= false ;
1560 bool wxDC::DoGetPartialTextExtents(const wxString
& text
, wxArrayInt
& widths
) const
1562 wxCHECK_MSG(Ok(), false, wxT("Invalid DC"));
1565 widths
.Add(0, text
.Length());
1567 if (text
.Length() == 0)
1570 wxMacFastPortSetter
helper(this) ;
1573 bool useGetThemeText
= ( GetThemeTextDimensions
!= (void*) kUnresolvedCFragSymbolAddress
) ;
1574 if ( UMAGetSystemVersion() < 0x1000 || IsKindOf(CLASSINFO( wxPrinterDC
) ) || ((wxFont
*)&m_font
)->GetNoAntiAliasing() )
1575 useGetThemeText
= false ;
1577 if ( useGetThemeText
)
1579 // If anybody knows how to do this more efficiently yet still handle
1580 // the fractional glyph widths that may be present when using AA
1581 // fonts, please change it. Currently it is measuring from the
1582 // begining of the string for each succeding substring, which is much
1583 // slower than this should be.
1584 for (size_t i
=0; i
<text
.Length(); i
++)
1586 wxString
str(text
.Left(i
+1));
1587 Point bounds
= {0,0};
1589 wxMacCFStringHolder
mString(str
, m_font
.GetEncoding());
1590 ::GetThemeTextDimensions( mString
,
1591 m_font
.MacGetThemeFontID(),
1596 widths
[i
] = XDEV2LOGREL(bounds
.h
);
1602 wxCharBuffer buff
= text
.mb_str(wxConvLocal
);
1603 size_t len
= strlen(buff
);
1604 short* measurements
= new short[len
+1];
1605 MeasureText(len
, buff
.data(), measurements
);
1607 // Copy to widths, starting at measurements[1]
1608 // NOTE: this doesn't take into account any multi-byte characters
1609 // in buff, it probabkly should...
1610 for (size_t i
=0; i
<text
.Length(); i
++)
1611 widths
[i
] = XDEV2LOGREL(measurements
[i
+1]);
1613 delete [] measurements
;
1621 wxCoord
wxDC::GetCharWidth(void) const
1623 wxCHECK_MSG(Ok(), 1, wxT("Invalid DC"));
1624 wxMacFastPortSetter
helper(this) ;
1628 bool useGetThemeText
= ( GetThemeTextDimensions
!= (void*) kUnresolvedCFragSymbolAddress
) ;
1629 if ( UMAGetSystemVersion() < 0x1000 || ((wxFont
*)&m_font
)->GetNoAntiAliasing() )
1630 useGetThemeText
= false ;
1634 if ( useGetThemeText
)
1636 Point bounds
={0,0} ;
1638 CFStringRef mString
= CFStringCreateWithBytes( NULL
, (UInt8
*) text
, 1 , CFStringGetSystemEncoding(), false ) ;
1639 ::GetThemeTextDimensions( mString
,
1640 m_font
.MacGetThemeFontID(),
1645 CFRelease( mString
) ;
1651 width
= ::TextWidth( text
, 0 , 1 ) ;
1653 return YDEV2LOGREL(width
) ;
1656 wxCoord
wxDC::GetCharHeight(void) const
1658 wxCHECK_MSG(Ok(), 1, wxT("Invalid DC"));
1659 wxMacFastPortSetter
helper(this) ;
1662 ::GetFontInfo( &fi
) ;
1663 return YDEV2LOGREL( fi
.descent
+ fi
.ascent
);
1666 void wxDC::Clear(void)
1668 wxCHECK_RET(Ok(), wxT("Invalid DC"));
1669 wxMacFastPortSetter
helper(this) ;
1670 Rect rect
= { -31000 , -31000 , 31000 , 31000 } ;
1671 if ( m_backgroundBrush
.Ok() && m_backgroundBrush
.GetStyle() != wxTRANSPARENT
)
1674 MacSetupBackgroundForCurrentPort( m_backgroundBrush
) ;
1675 ::EraseRect( &rect
) ;
1679 void wxDC::MacInstallFont() const
1681 wxCHECK_RET(Ok(), wxT("Invalid DC"));
1682 // if ( m_macFontInstalled )
1684 Pattern blackColor
;
1685 MacSetupBackgroundForCurrentPort(m_backgroundBrush
) ;
1686 if ( m_backgroundMode
!= wxTRANSPARENT
)
1688 Pattern whiteColor
;
1689 ::BackPat(GetQDGlobalsWhite(&whiteColor
));
1693 ::TextFont( m_font
.MacGetFontNum() ) ;
1694 ::TextSize( (short)(m_scaleY
* m_font
.MacGetFontSize()) ) ;
1695 ::TextFace( m_font
.MacGetFontStyle() ) ;
1696 m_macFontInstalled
= true ;
1697 m_macBrushInstalled
= false ;
1698 m_macPenInstalled
= false ;
1699 RGBColor forecolor
= MAC_WXCOLORREF( m_textForegroundColour
.GetPixel());
1700 RGBColor backcolor
= MAC_WXCOLORREF( m_textBackgroundColour
.GetPixel());
1701 ::RGBForeColor( &forecolor
);
1702 ::RGBBackColor( &backcolor
);
1706 FontFamilyID fontId
;
1710 GetThemeFont(kThemeSmallSystemFont
, GetApplicationScript() , fontName
, &fontSize
, &fontStyle
) ;
1711 GetFNum( fontName
, &fontId
);
1712 ::TextFont( fontId
) ;
1713 ::TextSize( short(m_scaleY
* fontSize
) ) ;
1714 ::TextFace( fontStyle
) ;
1715 // todo reset after spacing changes - or store the current spacing somewhere
1716 m_macFontInstalled
= true ;
1717 m_macBrushInstalled
= false ;
1718 m_macPenInstalled
= false ;
1719 RGBColor forecolor
= MAC_WXCOLORREF( m_textForegroundColour
.GetPixel());
1720 RGBColor backcolor
= MAC_WXCOLORREF( m_textBackgroundColour
.GetPixel());
1721 ::RGBForeColor( &forecolor
);
1722 ::RGBBackColor( &backcolor
);
1724 short mode
= patCopy
;
1726 switch( m_logicalFunction
)
1731 case wxINVERT
: // NOT dst
1732 ::PenPat(GetQDGlobalsBlack(&blackColor
));
1735 case wxXOR
: // src XOR dst
1738 case wxOR_REVERSE
: // src OR (NOT dst)
1741 case wxSRC_INVERT
: // (NOT src)
1744 case wxAND
: // src AND dst
1749 case wxAND_REVERSE
:// src AND (NOT dst)
1750 case wxAND_INVERT
: // (NOT src) AND dst
1751 case wxNO_OP
: // dst
1752 case wxNOR
: // (NOT src) AND (NOT dst)
1753 case wxEQUIV
: // (NOT src) XOR dst
1754 case wxOR_INVERT
: // (NOT src) OR dst
1755 case wxNAND
: // (NOT src) OR (NOT dst)
1756 case wxOR
: // src OR dst
1758 // case wxSRC_OR: // source _bitmap_ OR destination
1759 // case wxSRC_AND: // source _bitmap_ AND destination
1763 OSStatus status
= noErr
;
1764 Fixed atsuSize
= IntToFixed( int(m_scaleY
* m_font
.MacGetFontSize()) ) ;
1765 Style qdStyle
= m_font
.MacGetATSUAdditionalQDStyles() ;
1766 ATSUFontID atsuFont
= m_font
.MacGetATSUFontID() ;
1767 status
= ::ATSUCreateStyle((ATSUStyle
*)&m_macATSUIStyle
) ;
1768 wxASSERT_MSG( status
== noErr
, wxT("couldn't create ATSU style") ) ;
1769 ATSUAttributeTag atsuTags
[] =
1774 // kATSUBaselineClassTag ,
1775 kATSUVerticalCharacterTag
,
1776 kATSUQDBoldfaceTag
,
1778 kATSUQDUnderlineTag
,
1779 kATSUQDCondensedTag
,
1780 kATSUQDExtendedTag
,
1782 ByteCount atsuSizes
[sizeof(atsuTags
)/sizeof(ATSUAttributeTag
)] =
1784 sizeof( ATSUFontID
) ,
1786 // sizeof( RGBColor ) ,
1787 // sizeof( BslnBaselineClass ) ,
1788 sizeof( ATSUVerticalCharacterType
),
1795 Boolean kTrue
= true ;
1796 Boolean kFalse
= false ;
1797 //BslnBaselineClass kBaselineDefault = kBSLNHangingBaseline ;
1798 ATSUVerticalCharacterType kHorizontal
= kATSUStronglyHorizontal
;
1799 ATSUAttributeValuePtr atsuValues
[sizeof(atsuTags
)/sizeof(ATSUAttributeTag
)] =
1803 // &MAC_WXCOLORREF( m_textForegroundColour.GetPixel() ) ,
1804 // &kBaselineDefault ,
1806 (qdStyle
& bold
) ? &kTrue
: &kFalse
,
1807 (qdStyle
& italic
) ? &kTrue
: &kFalse
,
1808 (qdStyle
& underline
) ? &kTrue
: &kFalse
,
1809 (qdStyle
& condense
) ? &kTrue
: &kFalse
,
1810 (qdStyle
& extend
) ? &kTrue
: &kFalse
,
1812 status
= ::ATSUSetAttributes((ATSUStyle
)m_macATSUIStyle
, sizeof(atsuTags
)/sizeof(ATSUAttributeTag
) ,
1813 atsuTags
, atsuSizes
, atsuValues
);
1814 wxASSERT_MSG( status
== noErr
, wxT("couldn't set create ATSU style") ) ;
1817 Pattern gPatterns
[] =
1819 { { 0xFF , 0xFF , 0xFF , 0xFF , 0xFF , 0xFF , 0xFF , 0xFF } } ,
1820 { { 0x01 , 0x02 , 0x04 , 0x08 , 0x10 , 0x20 , 0x40 , 0x80 } } ,
1821 { { 0x80 , 0x40 , 0x20 , 0x10 , 0x08 , 0x04 , 0x02 , 0x01 } } ,
1822 { { 0x10 , 0x10 , 0x10 , 0xFF , 0x10 , 0x10 , 0x10 , 0x10 } } ,
1823 { { 0x00 , 0x00 , 0x00 , 0xFF , 0x00 , 0x00 , 0x00 , 0x00 } } ,
1824 { { 0x10 , 0x10 , 0x10 , 0x10 , 0x10 , 0x10 , 0x10 , 0x10 } } ,
1825 { { 0x81 , 0x42 , 0x24 , 0x18 , 0x18 , 0x24 , 0x42 , 0x81 } } ,
1827 { { 0xCC , 0x99 , 0x33 , 0x66 , 0xCC , 0x99 , 0x33 , 0x66 } } , // DOT
1828 { { 0xFE , 0xFD , 0xFB , 0xF7 , 0xEF , 0xDF , 0xBF , 0x7F } } , // LONG_DASH
1829 { { 0xEE , 0xDD , 0xBB , 0x77 , 0xEE , 0xDD , 0xBB , 0x77 } } , // SHORT_DASH
1830 { { 0xDE , 0xBD , 0x7B , 0xF6 , 0xED , 0xDB , 0xB7 , 0x6F } } , // DOT_DASH
1833 static void wxMacGetPattern(int penStyle
, Pattern
*pattern
)
1835 int index
= 0; // solid pattern by default
1839 case wxBDIAGONAL_HATCH
: index
= 1; break;
1840 case wxFDIAGONAL_HATCH
: index
= 2; break;
1841 case wxCROSS_HATCH
: index
= 3; break;
1842 case wxHORIZONTAL_HATCH
: index
= 4; break;
1843 case wxVERTICAL_HATCH
: index
= 5; break;
1844 case wxCROSSDIAG_HATCH
: index
= 6; break;
1846 case wxDOT
: index
= 7; break;
1847 case wxLONG_DASH
: index
= 8; break;
1848 case wxSHORT_DASH
: index
= 9; break;
1849 case wxDOT_DASH
: index
= 10; break;
1851 *pattern
= gPatterns
[index
];
1854 void wxDC::MacInstallPen() const
1856 wxCHECK_RET(Ok(), wxT("Invalid DC"));
1857 //Pattern blackColor;
1858 // if ( m_macPenInstalled )
1860 RGBColor forecolor
= MAC_WXCOLORREF( m_pen
.GetColour().GetPixel());
1861 RGBColor backcolor
= MAC_WXCOLORREF( m_backgroundBrush
.GetColour().GetPixel());
1862 ::RGBForeColor( &forecolor
);
1863 ::RGBBackColor( &backcolor
);
1865 int penWidth
= (int) (m_pen
.GetWidth() * m_scaleX
) ; ;
1866 // null means only one pixel, at whatever resolution
1867 if ( penWidth
== 0 )
1869 ::PenSize(penWidth
, penWidth
);
1871 int penStyle
= m_pen
.GetStyle();
1873 if (penStyle
== wxUSER_DASH
)
1875 // FIXME: there should be exactly 8 items in the dash
1877 int number
= m_pen
.GetDashes(&dash
) ;
1879 for ( int i
= 0 ; i
< 8 ; ++i
)
1881 pat
.pat
[i
] = dash
[index
] ;
1882 if (index
< number
- 1)
1888 wxMacGetPattern(penStyle
, &pat
);
1892 short mode
= patCopy
;
1894 switch( m_logicalFunction
)
1896 case wxCOPY
: // only foreground color, leave background (thus not patCopy)
1899 case wxINVERT
: // NOT dst
1900 // ::PenPat(GetQDGlobalsBlack(&blackColor));
1903 case wxXOR
: // src XOR dst
1906 case wxOR_REVERSE
: // src OR (NOT dst)
1909 case wxSRC_INVERT
: // (NOT src)
1912 case wxAND
: // src AND dst
1917 case wxAND_REVERSE
:// src AND (NOT dst)
1918 case wxAND_INVERT
: // (NOT src) AND dst
1919 case wxNO_OP
: // dst
1920 case wxNOR
: // (NOT src) AND (NOT dst)
1921 case wxEQUIV
: // (NOT src) XOR dst
1922 case wxOR_INVERT
: // (NOT src) OR dst
1923 case wxNAND
: // (NOT src) OR (NOT dst)
1924 case wxOR
: // src OR dst
1926 // case wxSRC_OR: // source _bitmap_ OR destination
1927 // case wxSRC_AND: // source _bitmap_ AND destination
1931 m_macPenInstalled
= true ;
1932 m_macBrushInstalled
= false ;
1933 m_macFontInstalled
= false ;
1936 void wxDC::MacSetupBackgroundForCurrentPort(const wxBrush
& background
)
1938 Pattern whiteColor
;
1939 if ( background
.Ok() )
1941 switch( background
.MacGetBrushKind() )
1943 case kwxMacBrushTheme
:
1945 ::SetThemeBackground( background
.MacGetTheme() , wxDisplayDepth() , true ) ;
1948 case kwxMacBrushThemeBackground
:
1951 ThemeBackgroundKind bg
= background
.MacGetThemeBackground( &extent
) ;
1952 ::ApplyThemeBackground( bg
, &extent
,kThemeStateActive
, wxDisplayDepth() , true ) ;
1955 case kwxMacBrushColour
:
1957 ::RGBBackColor( &MAC_WXCOLORREF( background
.GetColour().GetPixel()) );
1958 int brushStyle
= background
.GetStyle();
1959 if (brushStyle
== wxSOLID
)
1960 ::BackPat(GetQDGlobalsWhite(&whiteColor
));
1961 else if (background
.IsHatch())
1964 wxMacGetPattern(brushStyle
, &pat
);
1969 ::BackPat(GetQDGlobalsWhite(&whiteColor
));
1977 void wxDC::MacInstallBrush() const
1979 wxCHECK_RET(Ok(), wxT("Invalid DC"));
1980 Pattern blackColor
;
1981 // if ( m_macBrushInstalled )
1984 bool backgroundTransparent
= (GetBackgroundMode() == wxTRANSPARENT
) ;
1985 ::RGBForeColor( &MAC_WXCOLORREF( m_brush
.GetColour().GetPixel()) );
1986 ::RGBBackColor( &MAC_WXCOLORREF( m_backgroundBrush
.GetColour().GetPixel()) );
1987 int brushStyle
= m_brush
.GetStyle();
1988 if (brushStyle
== wxSOLID
)
1990 ::PenPat(GetQDGlobalsBlack(&blackColor
));
1992 else if (m_brush
.IsHatch())
1995 wxMacGetPattern(brushStyle
, &pat
);
1998 else if ( m_brush
.GetStyle() == wxSTIPPLE
|| m_brush
.GetStyle() == wxSTIPPLE_MASK_OPAQUE
)
2000 // we force this in order to be compliant with wxMSW
2001 backgroundTransparent
= false ;
2002 // for these the text fore (and back for MASK_OPAQUE) colors are used
2003 wxBitmap
* bitmap
= m_brush
.GetStipple() ;
2004 int width
= bitmap
->GetWidth() ;
2005 int height
= bitmap
->GetHeight() ;
2006 GWorldPtr gw
= NULL
;
2007 if ( m_brush
.GetStyle() == wxSTIPPLE
)
2008 gw
= MAC_WXHBITMAP(bitmap
->GetHBITMAP()) ;
2010 gw
= MAC_WXHBITMAP(bitmap
->GetMask()->GetMaskBitmap()) ;
2011 PixMapHandle gwpixmaphandle
= GetGWorldPixMap( gw
) ;
2012 LockPixels( gwpixmaphandle
) ;
2013 bool isMonochrome
= !IsPortColor( gw
) ;
2014 if ( !isMonochrome
)
2016 if ( (**gwpixmaphandle
).pixelSize
== 1 )
2017 isMonochrome
= true ;
2019 if ( isMonochrome
&& width
== 8 && height
== 8 )
2021 ::RGBForeColor( &MAC_WXCOLORREF( m_textForegroundColour
.GetPixel()) );
2022 ::RGBForeColor( &MAC_WXCOLORREF( m_textBackgroundColour
.GetPixel()) );
2023 BitMap
* gwbitmap
= (BitMap
*) *gwpixmaphandle
; // since the color depth is 1 it is a BitMap
2024 UInt8
*gwbits
= (UInt8
*) gwbitmap
->baseAddr
;
2025 int alignment
= gwbitmap
->rowBytes
& 0x7FFF ;
2027 for ( int i
= 0 ; i
< 8 ; ++i
)
2029 pat
.pat
[i
] = gwbits
[i
*alignment
+0] ;
2031 UnlockPixels( GetGWorldPixMap( gw
) ) ;
2036 // this will be the code to handle power of 2 patterns, we will have to arrive at a nice
2037 // caching scheme before putting this into production
2040 PixPatHandle pixpat
= NewPixPat() ;
2041 CopyPixMap(gwpixmaphandle
, (**pixpat
).patMap
);
2042 imageSize
= GetPixRowBytes((**pixpat
).patMap
) *
2043 ((**(**pixpat
).patMap
).bounds
.bottom
-
2044 (**(**pixpat
).patMap
).bounds
.top
);
2045 PtrToHand( (**gwpixmaphandle
).baseAddr
, &image
, imageSize
);
2046 (**pixpat
).patData
= image
;
2049 CTabHandle ctable
= ((**((**pixpat
).patMap
)).pmTable
) ;
2050 ColorSpecPtr ctspec
= (ColorSpecPtr
) &(**ctable
).ctTable
;
2051 if ( ctspec
[0].rgb
.red
== 0x0000 )
2053 ctspec
[1].rgb
= MAC_WXCOLORREF( m_textBackgroundColour
.GetPixel()) ;
2054 ctspec
[0].rgb
= MAC_WXCOLORREF( m_textForegroundColour
.GetPixel()) ;
2058 ctspec
[0].rgb
= MAC_WXCOLORREF( m_textBackgroundColour
.GetPixel()) ;
2059 ctspec
[1].rgb
= MAC_WXCOLORREF( m_textForegroundColour
.GetPixel()) ;
2061 ::CTabChanged( ctable
) ;
2063 ::PenPixPat(pixpat
);
2064 m_macForegroundPixMap
= pixpat
;
2066 UnlockPixels( gwpixmaphandle
) ;
2070 ::PenPat(GetQDGlobalsBlack(&blackColor
));
2072 short mode
= patCopy
;
2073 switch( m_logicalFunction
)
2076 if ( backgroundTransparent
)
2081 case wxINVERT
: // NOT dst
2082 if ( !backgroundTransparent
)
2084 ::PenPat(GetQDGlobalsBlack(&blackColor
));
2088 case wxXOR
: // src XOR dst
2091 case wxOR_REVERSE
: // src OR (NOT dst)
2094 case wxSRC_INVERT
: // (NOT src)
2097 case wxAND
: // src AND dst
2102 case wxAND_REVERSE
:// src AND (NOT dst)
2103 case wxAND_INVERT
: // (NOT src) AND dst
2104 case wxNO_OP
: // dst
2105 case wxNOR
: // (NOT src) AND (NOT dst)
2106 case wxEQUIV
: // (NOT src) XOR dst
2107 case wxOR_INVERT
: // (NOT src) OR dst
2108 case wxNAND
: // (NOT src) OR (NOT dst)
2109 case wxOR
: // src OR dst
2111 // case wxSRC_OR: // source _bitmap_ OR destination
2112 // case wxSRC_AND: // source _bitmap_ AND destination
2116 m_macBrushInstalled
= true ;
2117 m_macPenInstalled
= false ;
2118 m_macFontInstalled
= false ;
2121 // ---------------------------------------------------------------------------
2122 // coordinates transformations
2123 // ---------------------------------------------------------------------------
2125 wxCoord
wxDCBase::DeviceToLogicalX(wxCoord x
) const
2127 return ((wxDC
*)this)->XDEV2LOG(x
);
2130 wxCoord
wxDCBase::DeviceToLogicalY(wxCoord y
) const
2132 return ((wxDC
*)this)->YDEV2LOG(y
);
2135 wxCoord
wxDCBase::DeviceToLogicalXRel(wxCoord x
) const
2137 return ((wxDC
*)this)->XDEV2LOGREL(x
);
2140 wxCoord
wxDCBase::DeviceToLogicalYRel(wxCoord y
) const
2142 return ((wxDC
*)this)->YDEV2LOGREL(y
);
2145 wxCoord
wxDCBase::LogicalToDeviceX(wxCoord x
) const
2147 return ((wxDC
*)this)->XLOG2DEV(x
);
2150 wxCoord
wxDCBase::LogicalToDeviceY(wxCoord y
) const
2152 return ((wxDC
*)this)->YLOG2DEV(y
);
2155 wxCoord
wxDCBase::LogicalToDeviceXRel(wxCoord x
) const
2157 return ((wxDC
*)this)->XLOG2DEVREL(x
);
2160 wxCoord
wxDCBase::LogicalToDeviceYRel(wxCoord y
) const
2162 return ((wxDC
*)this)->YLOG2DEVREL(y
);