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"
30 #include "wx/mac/private.h"
31 #include <ATSUnicode.h>
32 #include <TextCommon.h>
33 #include <TextEncodingConverter.h>
35 #if !USE_SHARED_LIBRARY
36 IMPLEMENT_ABSTRACT_CLASS(wxDC
, wxObject
)
39 //-----------------------------------------------------------------------------
41 //-----------------------------------------------------------------------------
43 #define mm2inches 0.0393700787402
44 #define inches2mm 25.4
45 #define mm2twips 56.6929133859
46 #define twips2mm 0.0176388888889
47 #define mm2pt 2.83464566929
48 #define pt2mm 0.352777777778
49 #if !defined( __DARWIN__ ) || defined(__MWERKS__)
51 const double M_PI
= 3.14159265358979 ;
54 const double RAD2DEG
= 180.0 / M_PI
;
55 const short kEmulatedMode
= -1 ;
56 const short kUnsupportedMode
= -2 ;
58 extern TECObjectRef s_TECNativeCToUnicode
;
60 // set to 0 if problems arise
61 #define wxMAC_EXPERIMENTAL_DC 1
63 wxMacPortSetter::wxMacPortSetter( const wxDC
* dc
) :
64 m_ph( (GrafPtr
) dc
->m_macPort
)
66 wxASSERT( dc
->Ok() ) ;
68 dc
->MacSetupPort(&m_ph
) ;
70 wxMacPortSetter::~wxMacPortSetter()
72 m_dc
->MacCleanupPort(&m_ph
) ;
75 #if wxMAC_EXPERIMENTAL_DC
76 class wxMacFastPortSetter
79 wxMacFastPortSetter( const wxDC
*dc
)
81 wxASSERT( dc
->Ok() ) ;
82 m_swapped
= QDSwapPort( (GrafPtr
) dc
->m_macPort
, &m_oldPort
) ;
83 m_clipRgn
= NewRgn() ;
84 GetClip( m_clipRgn
) ;
86 dc
->MacSetupPort( NULL
) ;
88 ~wxMacFastPortSetter()
90 // SetPort( (GrafPtr) m_dc->m_macPort ) ;
91 SetClip( m_clipRgn
) ;
93 SetPort( m_oldPort
) ;
94 m_dc
->MacCleanupPort( NULL
) ;
95 DisposeRgn( m_clipRgn
) ;
105 typedef wxMacPortSetter wxMacFastPortSetter
;
108 wxMacWindowClipper::wxMacWindowClipper( const wxWindow
* win
) :
109 wxMacPortSaver( (GrafPtr
) GetWindowPort((WindowRef
) win
->MacGetTopLevelWindowRef()) )
111 m_newPort
=(GrafPtr
) GetWindowPort((WindowRef
) win
->MacGetTopLevelWindowRef()) ;
112 m_formerClip
= NewRgn() ;
113 m_newClip
= NewRgn() ;
114 GetClip( m_formerClip
) ;
119 win
->MacWindowToRootWindow( &x
,&y
) ;
120 // get area including focus rect
121 CopyRgn( (RgnHandle
) ((wxWindow
*)win
)->MacGetVisibleRegion(true).GetWXHRGN() , m_newClip
) ;
122 if ( !EmptyRgn( m_newClip
) )
123 OffsetRgn( m_newClip
, x
, y
) ;
125 SetClip( m_newClip
) ;
129 wxMacWindowClipper::~wxMacWindowClipper()
131 SetPort( m_newPort
) ;
132 SetClip( m_formerClip
) ;
133 DisposeRgn( m_newClip
) ;
134 DisposeRgn( m_formerClip
) ;
137 wxMacWindowStateSaver::wxMacWindowStateSaver( const wxWindow
* win
) :
138 wxMacWindowClipper( win
)
140 // the port is already set at this point
141 m_newPort
=(GrafPtr
) GetWindowPort((WindowRef
) win
->MacGetTopLevelWindowRef()) ;
142 GetThemeDrawingState( &m_themeDrawingState
) ;
145 wxMacWindowStateSaver::~wxMacWindowStateSaver()
147 SetPort( m_newPort
) ;
148 SetThemeDrawingState( m_themeDrawingState
, true ) ;
151 //-----------------------------------------------------------------------------
153 //-----------------------------------------------------------------------------
154 static inline double dmin(double a
, double b
) { return a
< b
? a
: b
; }
155 static inline double dmax(double a
, double b
) { return a
> b
? a
: b
; }
156 static inline double DegToRad(double deg
) { return (deg
* M_PI
) / 180.0; }
158 //-----------------------------------------------------------------------------
160 //-----------------------------------------------------------------------------
161 // this function emulates all wx colour manipulations, used to verify the implementation
162 // by setting the mode in the blitting functions to kEmulatedMode
163 void wxMacCalculateColour( int logical_func
, const RGBColor
&srcColor
, RGBColor
&dstColor
) ;
165 void wxMacCalculateColour( int logical_func
, const RGBColor
&srcColor
, RGBColor
&dstColor
)
167 switch ( logical_func
)
169 case wxAND
: // src AND dst
170 dstColor
.red
= dstColor
.red
& srcColor
.red
;
171 dstColor
.green
= dstColor
.green
& srcColor
.green
;
172 dstColor
.blue
= dstColor
.blue
& srcColor
.blue
;
174 case wxAND_INVERT
: // (NOT src) AND dst
175 dstColor
.red
= dstColor
.red
& ~srcColor
.red
;
176 dstColor
.green
= dstColor
.green
& ~srcColor
.green
;
177 dstColor
.blue
= dstColor
.blue
& ~srcColor
.blue
;
179 case wxAND_REVERSE
:// src AND (NOT dst)
180 dstColor
.red
= ~dstColor
.red
& srcColor
.red
;
181 dstColor
.green
= ~dstColor
.green
& srcColor
.green
;
182 dstColor
.blue
= ~dstColor
.blue
& srcColor
.blue
;
190 dstColor
.red
= srcColor
.red
;
191 dstColor
.green
= srcColor
.green
;
192 dstColor
.blue
= srcColor
.blue
;
194 case wxEQUIV
: // (NOT src) XOR dst
195 dstColor
.red
= dstColor
.red
^ ~srcColor
.red
;
196 dstColor
.green
= dstColor
.green
^ ~srcColor
.green
;
197 dstColor
.blue
= dstColor
.blue
^ ~srcColor
.blue
;
199 case wxINVERT
: // NOT dst
200 dstColor
.red
= ~dstColor
.red
;
201 dstColor
.green
= ~dstColor
.green
;
202 dstColor
.blue
= ~dstColor
.blue
;
204 case wxNAND
: // (NOT src) OR (NOT dst)
205 dstColor
.red
= ~dstColor
.red
| ~srcColor
.red
;
206 dstColor
.green
= ~dstColor
.green
| ~srcColor
.green
;
207 dstColor
.blue
= ~dstColor
.blue
| ~srcColor
.blue
;
209 case wxNOR
: // (NOT src) AND (NOT dst)
210 dstColor
.red
= ~dstColor
.red
& ~srcColor
.red
;
211 dstColor
.green
= ~dstColor
.green
& ~srcColor
.green
;
212 dstColor
.blue
= ~dstColor
.blue
& ~srcColor
.blue
;
216 case wxOR
: // src OR dst
217 dstColor
.red
= dstColor
.red
| srcColor
.red
;
218 dstColor
.green
= dstColor
.green
| srcColor
.green
;
219 dstColor
.blue
= dstColor
.blue
| srcColor
.blue
;
221 case wxOR_INVERT
: // (NOT src) OR dst
222 dstColor
.red
= dstColor
.red
| ~srcColor
.red
;
223 dstColor
.green
= dstColor
.green
| ~srcColor
.green
;
224 dstColor
.blue
= dstColor
.blue
| ~srcColor
.blue
;
226 case wxOR_REVERSE
: // src OR (NOT dst)
227 dstColor
.red
= ~dstColor
.red
| srcColor
.red
;
228 dstColor
.green
= ~dstColor
.green
| srcColor
.green
;
229 dstColor
.blue
= ~dstColor
.blue
| srcColor
.blue
;
232 dstColor
.red
= 0xFFFF ;
233 dstColor
.green
= 0xFFFF ;
234 dstColor
.blue
= 0xFFFF ;
236 case wxSRC_INVERT
: // (NOT src)
237 dstColor
.red
= ~srcColor
.red
;
238 dstColor
.green
= ~srcColor
.green
;
239 dstColor
.blue
= ~srcColor
.blue
;
241 case wxXOR
: // src XOR dst
242 dstColor
.red
= dstColor
.red
^ srcColor
.red
;
243 dstColor
.green
= dstColor
.green
^ srcColor
.green
;
244 dstColor
.blue
= dstColor
.blue
^ srcColor
.blue
;
253 m_mm_to_pix_x
= mm2pt
;
254 m_mm_to_pix_y
= mm2pt
;
255 m_internalDeviceOriginX
= 0;
256 m_internalDeviceOriginY
= 0;
257 m_externalDeviceOriginX
= 0;
258 m_externalDeviceOriginY
= 0;
259 m_logicalScaleX
= 1.0;
260 m_logicalScaleY
= 1.0;
265 m_needComputeScaleX
= FALSE
;
266 m_needComputeScaleY
= FALSE
;
270 m_macFontInstalled
= false ;
271 m_macBrushInstalled
= false ;
272 m_macPenInstalled
= false ;
273 m_macLocalOrigin
.x
= m_macLocalOrigin
.y
= 0 ;
274 m_macBoundaryClipRgn
= NewRgn() ;
275 m_macCurrentClipRgn
= NewRgn() ;
276 SetRectRgn( (RgnHandle
) m_macBoundaryClipRgn
, -32000 , -32000 , 32000 , 32000 ) ;
277 SetRectRgn( (RgnHandle
) m_macCurrentClipRgn
, -32000 , -32000 , 32000 , 32000 ) ;
278 m_pen
= *wxBLACK_PEN
;
279 m_font
= *wxNORMAL_FONT
;
280 m_brush
= *wxWHITE_BRUSH
;
282 // needed to debug possible errors with two active drawing methods at the same time on
284 m_macCurrentPortStateHelper
= NULL
;
286 m_macATSUIStyle
= NULL
;
287 m_macAliasWasEnabled
= false;
288 m_macForegroundPixMap
= NULL
;
289 m_macBackgroundPixMap
= NULL
;
294 DisposeRgn( (RgnHandle
) m_macBoundaryClipRgn
) ;
295 DisposeRgn( (RgnHandle
) m_macCurrentClipRgn
) ;
298 void wxDC::MacSetupPort(wxMacPortStateHelper
* help
) const
301 wxASSERT( m_macCurrentPortStateHelper
== NULL
) ;
302 m_macCurrentPortStateHelper
= help
;
304 SetClip( (RgnHandle
) m_macCurrentClipRgn
);
305 #if ! wxMAC_EXPERIMENTAL_DC
306 m_macFontInstalled
= false ;
307 m_macBrushInstalled
= false ;
308 m_macPenInstalled
= false ;
311 void wxDC::MacCleanupPort(wxMacPortStateHelper
* help
) const
314 wxASSERT( m_macCurrentPortStateHelper
== help
) ;
315 m_macCurrentPortStateHelper
= NULL
;
317 if( m_macATSUIStyle
)
319 ::ATSUDisposeStyle((ATSUStyle
)m_macATSUIStyle
);
320 m_macATSUIStyle
= NULL
;
322 if ( m_macAliasWasEnabled
)
324 SetAntiAliasedTextEnabled(m_macFormerAliasState
, m_macFormerAliasSize
);
325 m_macAliasWasEnabled
= false ;
327 if ( m_macForegroundPixMap
)
330 ::PenPat(GetQDGlobalsBlack(&blackColor
));
331 DisposePixPat( (PixPatHandle
) m_macForegroundPixMap
) ;
332 m_macForegroundPixMap
= NULL
;
334 if ( m_macBackgroundPixMap
)
337 ::BackPat(GetQDGlobalsWhite(&whiteColor
));
338 DisposePixPat( (PixPatHandle
) m_macBackgroundPixMap
) ;
339 m_macBackgroundPixMap
= NULL
;
343 void wxDC::DoDrawBitmap( const wxBitmap
&bmp
, wxCoord x
, wxCoord y
, bool useMask
)
345 wxCHECK_RET( Ok(), wxT("invalid window dc") );
346 wxCHECK_RET( bmp
.Ok(), wxT("invalid bitmap") );
347 wxMacFastPortSetter
helper(this) ;
348 wxCoord xx
= XLOG2DEVMAC(x
);
349 wxCoord yy
= YLOG2DEVMAC(y
);
350 wxCoord w
= bmp
.GetWidth();
351 wxCoord h
= bmp
.GetHeight();
352 wxCoord ww
= XLOG2DEVREL(w
);
353 wxCoord hh
= YLOG2DEVREL(h
);
354 // Set up drawing mode
355 short mode
= (m_logicalFunction
== wxCOPY
? srcCopy
:
356 //m_logicalFunction == wxCLEAR ? WHITENESS :
357 //m_logicalFunction == wxSET ? BLACKNESS :
358 m_logicalFunction
== wxINVERT
? hilite
:
359 //m_logicalFunction == wxAND ? MERGECOPY :
360 m_logicalFunction
== wxOR
? srcOr
:
361 m_logicalFunction
== wxSRC_INVERT
? notSrcCopy
:
362 m_logicalFunction
== wxXOR
? srcXor
:
363 m_logicalFunction
== wxOR_REVERSE
? notSrcOr
:
364 //m_logicalFunction == wxAND_REVERSE ? SRCERASE :
365 //m_logicalFunction == wxSRC_OR ? srcOr :
366 //m_logicalFunction == wxSRC_AND ? SRCAND :
368 if ( bmp
.GetBitmapType() == kMacBitmapTypePict
) {
369 Rect bitmaprect
= { 0 , 0 , hh
, ww
};
370 ::OffsetRect( &bitmaprect
, xx
, yy
) ;
371 ::DrawPicture( (PicHandle
) bmp
.GetPict(), &bitmaprect
) ;
373 else if ( bmp
.GetBitmapType() == kMacBitmapTypeGrafWorld
)
375 GWorldPtr bmapworld
= MAC_WXHBITMAP( bmp
.GetHBITMAP() );
376 PixMapHandle bmappixels
;
377 // Set foreground and background colours (for bitmaps depth = 1)
378 if(bmp
.GetDepth() == 1)
380 RGBColor fore
= MAC_WXCOLORREF(m_textForegroundColour
.GetPixel());
381 RGBColor back
= MAC_WXCOLORREF(m_textBackgroundColour
.GetPixel());
387 RGBColor white
= { 0xFFFF, 0xFFFF,0xFFFF} ;
388 RGBColor black
= { 0,0,0} ;
389 RGBForeColor( &black
) ;
390 RGBBackColor( &white
) ;
392 bmappixels
= GetGWorldPixMap( bmapworld
) ;
393 wxCHECK_RET(LockPixels(bmappixels
),
394 wxT("DoDrawBitmap: Unable to lock pixels"));
395 Rect source
= { 0, 0, h
, w
};
396 Rect dest
= { yy
, xx
, yy
+ hh
, xx
+ ww
};
397 if ( useMask
&& bmp
.GetMask() )
399 if( LockPixels(GetGWorldPixMap(MAC_WXHBITMAP(bmp
.GetMask()->GetMaskBitmap()))))
403 GetPortBitMapForCopyBits(bmapworld
),
404 GetPortBitMapForCopyBits(MAC_WXHBITMAP(bmp
.GetMask()->GetMaskBitmap())),
405 GetPortBitMapForCopyBits( MAC_WXHBITMAP(m_macPort
) ),
406 &source
, &source
, &dest
, mode
, NULL
408 UnlockPixels(GetGWorldPixMap(MAC_WXHBITMAP(bmp
.GetMask()->GetMaskBitmap())));
412 CopyBits( GetPortBitMapForCopyBits( bmapworld
),
413 GetPortBitMapForCopyBits( MAC_WXHBITMAP(m_macPort
) ),
414 &source
, &dest
, mode
, NULL
) ;
416 UnlockPixels( bmappixels
) ;
418 else if ( bmp
.GetBitmapType() == kMacBitmapTypeIcon
)
420 Rect bitmaprect
= { 0 , 0 , bmp
.GetHeight(), bmp
.GetWidth() } ;
421 OffsetRect( &bitmaprect
, xx
, yy
) ;
422 PlotCIconHandle( &bitmaprect
, atNone
, ttNone
, MAC_WXHICON(bmp
.GetHICON()) ) ;
424 m_macPenInstalled
= false ;
425 m_macBrushInstalled
= false ;
426 m_macFontInstalled
= false ;
429 void wxDC::DoDrawIcon( const wxIcon
&icon
, wxCoord x
, wxCoord y
)
431 wxCHECK_RET(Ok(), wxT("Invalid dc wxDC::DoDrawIcon"));
432 wxCHECK_RET(icon
.Ok(), wxT("Invalid icon wxDC::DoDrawIcon"));
433 DoDrawBitmap( icon
, x
, y
, icon
.GetMask() != NULL
) ;
436 void wxDC::DoSetClippingRegion( wxCoord x
, wxCoord y
, wxCoord width
, wxCoord height
)
438 wxCHECK_RET(Ok(), wxT("wxDC::DoSetClippingRegion Invalid DC"));
439 wxCoord xx
, yy
, ww
, hh
;
442 ww
= XLOG2DEVREL(width
);
443 hh
= YLOG2DEVREL(height
);
444 SetRectRgn( (RgnHandle
) m_macCurrentClipRgn
, xx
, yy
, xx
+ ww
, yy
+ hh
) ;
445 SectRgn( (RgnHandle
) m_macCurrentClipRgn
, (RgnHandle
) m_macBoundaryClipRgn
, (RgnHandle
) m_macCurrentClipRgn
) ;
448 m_clipX1
= wxMax( m_clipX1
, xx
);
449 m_clipY1
= wxMax( m_clipY1
, yy
);
450 m_clipX2
= wxMin( m_clipX2
, (xx
+ ww
));
451 m_clipY2
= wxMin( m_clipY2
, (yy
+ hh
));
463 void wxDC::DoSetClippingRegionAsRegion( const wxRegion
®ion
)
465 wxCHECK_RET( Ok(), wxT("invalid window dc") ) ;
468 DestroyClippingRegion();
471 wxMacFastPortSetter
helper(this) ;
473 region
.GetBox( x
, y
, w
, h
);
474 wxCoord xx
, yy
, ww
, hh
;
479 // if we have a scaling that we cannot map onto native regions
480 // we must use the box
481 if ( ww
!= w
|| hh
!= h
)
483 wxDC::DoSetClippingRegion( x
, y
, w
, h
);
487 CopyRgn( (RgnHandle
) region
.GetWXHRGN() , (RgnHandle
) m_macCurrentClipRgn
) ;
488 if ( xx
!= x
|| yy
!= y
)
490 OffsetRgn( (RgnHandle
) m_macCurrentClipRgn
, xx
- x
, yy
- y
) ;
492 SectRgn( (RgnHandle
) m_macCurrentClipRgn
, (RgnHandle
) m_macBoundaryClipRgn
, (RgnHandle
) m_macCurrentClipRgn
) ;
495 m_clipX1
= wxMax( m_clipX1
, xx
);
496 m_clipY1
= wxMax( m_clipY1
, yy
);
497 m_clipX2
= wxMin( m_clipX2
, (xx
+ ww
));
498 m_clipY2
= wxMin( m_clipY2
, (yy
+ hh
));
511 void wxDC::DestroyClippingRegion()
513 wxMacFastPortSetter
helper(this) ;
514 CopyRgn( (RgnHandle
) m_macBoundaryClipRgn
, (RgnHandle
) m_macCurrentClipRgn
) ;
518 void wxDC::DoGetSizeMM( int* width
, int* height
) const
523 *width
= long( double(w
) / (m_scaleX
*m_mm_to_pix_x
) );
524 *height
= long( double(h
) / (m_scaleY
*m_mm_to_pix_y
) );
527 void wxDC::SetTextForeground( const wxColour
&col
)
529 wxCHECK_RET(Ok(), wxT("Invalid DC"));
530 m_textForegroundColour
= col
;
531 m_macFontInstalled
= false ;
534 void wxDC::SetTextBackground( const wxColour
&col
)
536 wxCHECK_RET(Ok(), wxT("Invalid DC"));
537 m_textBackgroundColour
= col
;
538 m_macFontInstalled
= false ;
541 void wxDC::SetMapMode( int mode
)
546 SetLogicalScale( twips2mm
*m_mm_to_pix_x
, twips2mm
*m_mm_to_pix_y
);
549 SetLogicalScale( pt2mm
*m_mm_to_pix_x
, pt2mm
*m_mm_to_pix_y
);
552 SetLogicalScale( m_mm_to_pix_x
, m_mm_to_pix_y
);
555 SetLogicalScale( m_mm_to_pix_x
/10.0, m_mm_to_pix_y
/10.0 );
559 SetLogicalScale( 1.0, 1.0 );
562 if (mode
!= wxMM_TEXT
)
564 m_needComputeScaleX
= TRUE
;
565 m_needComputeScaleY
= TRUE
;
569 void wxDC::SetUserScale( double x
, double y
)
571 // allow negative ? -> no
574 ComputeScaleAndOrigin();
577 void wxDC::SetLogicalScale( double x
, double y
)
582 ComputeScaleAndOrigin();
585 void wxDC::SetLogicalOrigin( wxCoord x
, wxCoord y
)
587 m_logicalOriginX
= x
* m_signX
; // is this still correct ?
588 m_logicalOriginY
= y
* m_signY
;
589 ComputeScaleAndOrigin();
592 void wxDC::SetDeviceOrigin( wxCoord x
, wxCoord y
)
594 m_externalDeviceOriginX
= x
;
595 m_externalDeviceOriginY
= y
;
596 ComputeScaleAndOrigin();
599 void wxDC::SetAxisOrientation( bool xLeftRight
, bool yBottomUp
)
601 m_signX
= (xLeftRight
? 1 : -1);
602 m_signY
= (yBottomUp
? -1 : 1);
603 ComputeScaleAndOrigin();
606 wxSize
wxDC::GetPPI() const
608 return wxSize(72, 72);
611 int wxDC::GetDepth() const
613 if ( IsPortColor( (CGrafPtr
) m_macPort
) )
615 return ( (**GetPortPixMap( (CGrafPtr
) m_macPort
)).pixelSize
) ;
620 void wxDC::ComputeScaleAndOrigin()
622 // CMB: copy scale to see if it changes
623 double origScaleX
= m_scaleX
;
624 double origScaleY
= m_scaleY
;
625 m_scaleX
= m_logicalScaleX
* m_userScaleX
;
626 m_scaleY
= m_logicalScaleY
* m_userScaleY
;
627 m_deviceOriginX
= m_internalDeviceOriginX
+ m_externalDeviceOriginX
;
628 m_deviceOriginY
= m_internalDeviceOriginY
+ m_externalDeviceOriginY
;
629 // CMB: if scale has changed call SetPen to recalulate the line width
630 if (m_scaleX
!= origScaleX
|| m_scaleY
!= origScaleY
)
632 // this is a bit artificial, but we need to force wxDC to think
633 // the pen has changed
634 wxPen
* pen
= & GetPen();
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
;
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 if( (xx1
> xx2
) || (yy1
> yy2
) ) {
830 Rect r
= { yyc
- rad
, xxc
- rad
, yyc
+ rad
, xxc
+ rad
};
831 if(m_brush
.GetStyle() != wxTRANSPARENT
) {
833 PaintArc(&r
, alpha1
, alpha2
);
835 if(m_pen
.GetStyle() != wxTRANSPARENT
) {
837 FrameArc(&r
, alpha1
, alpha2
);
841 void wxDC::DoDrawEllipticArc( wxCoord x
, wxCoord y
, wxCoord w
, wxCoord h
,
842 double sa
, double ea
)
844 wxCHECK_RET(Ok(), wxT("wxDC::DoDrawEllepticArc Invalid DC"));
845 wxMacFastPortSetter
helper(this) ;
847 double angle
= sa
- ea
; // Order important Mac in opposite direction to wx
848 // we have to make sure that the filling is always counter-clockwise
851 wxCoord xx
= XLOG2DEVMAC(x
);
852 wxCoord yy
= YLOG2DEVMAC(y
);
853 wxCoord ww
= m_signX
* XLOG2DEVREL(w
);
854 wxCoord hh
= m_signY
* YLOG2DEVREL(h
);
855 // handle -ve width and/or height
856 if (ww
< 0) { ww
= -ww
; xx
= xx
- ww
; }
857 if (hh
< 0) { hh
= -hh
; yy
= yy
- hh
; }
858 sa
= wxConvertWXangleToMACangle(sa
);
863 if(m_brush
.GetStyle() != wxTRANSPARENT
) {
865 PaintArc(&r
, (short)sa
, (short)angle
);
867 if(m_pen
.GetStyle() != wxTRANSPARENT
) {
869 FrameArc(&r
, (short)sa
, (short)angle
);
873 void wxDC::DoDrawPoint( wxCoord x
, wxCoord y
)
875 wxCHECK_RET(Ok(), wxT("Invalid DC"));
876 wxMacFastPortSetter
helper(this) ;
877 if (m_pen
.GetStyle() != wxTRANSPARENT
)
879 wxCoord xx1
= XLOG2DEVMAC(x
);
880 wxCoord yy1
= YLOG2DEVMAC(y
);
881 RGBColor pencolor
= MAC_WXCOLORREF( m_pen
.GetColour().GetPixel());
882 ::SetCPixel( xx1
,yy1
,&pencolor
) ;
883 CalcBoundingBox(x
, y
);
887 void wxDC::DoDrawLines(int n
, wxPoint points
[],
888 wxCoord xoffset
, wxCoord yoffset
)
890 wxCHECK_RET(Ok(), wxT("Invalid DC"));
891 wxMacFastPortSetter
helper(this) ;
892 if (m_pen
.GetStyle() == wxTRANSPARENT
)
895 wxCoord offset
= ( (m_pen
.GetWidth() == 0 ? 1 :
896 m_pen
.GetWidth() ) * (wxCoord
)m_scaleX
- 1) / 2 ;
897 wxCoord x1
, x2
, y1
, y2
;
898 x1
= XLOG2DEVMAC(points
[0].x
+ xoffset
);
899 y1
= YLOG2DEVMAC(points
[0].y
+ yoffset
);
900 ::MoveTo(x1
- offset
, y1
- offset
);
901 for (int i
= 0; i
< n
-1; i
++)
903 x2
= XLOG2DEVMAC(points
[i
+1].x
+ xoffset
);
904 y2
= YLOG2DEVMAC(points
[i
+1].y
+ yoffset
);
905 ::LineTo( x2
- offset
, y2
- offset
);
909 void wxDC::DoDrawPolygon(int n
, wxPoint points
[],
910 wxCoord xoffset
, wxCoord yoffset
,
913 wxCHECK_RET(Ok(), wxT("Invalid DC"));
914 wxMacFastPortSetter
helper(this) ;
915 wxCoord x1
, x2
, y1
, y2
;
916 if ( m_brush
.GetStyle() == wxTRANSPARENT
&& m_pen
.GetStyle() == wxTRANSPARENT
)
918 PolyHandle polygon
= OpenPoly();
919 x2
= x1
= XLOG2DEVMAC(points
[0].x
+ xoffset
);
920 y2
= y1
= YLOG2DEVMAC(points
[0].y
+ yoffset
);
922 for (int i
= 1; i
< n
; i
++)
924 x2
= XLOG2DEVMAC(points
[i
].x
+ xoffset
);
925 y2
= YLOG2DEVMAC(points
[i
].y
+ yoffset
);
928 // close the polyline if necessary
929 if ( x1
!= x2
|| y1
!= y2
)
934 if (m_brush
.GetStyle() != wxTRANSPARENT
)
937 ::PaintPoly( polygon
);
939 if (m_pen
.GetStyle() != wxTRANSPARENT
)
942 ::FramePoly( polygon
) ;
947 void wxDC::DoDrawRectangle(wxCoord x
, wxCoord y
, wxCoord width
, wxCoord height
)
949 wxCHECK_RET(Ok(), wxT("Invalid DC"));
950 wxMacFastPortSetter
helper(this) ;
951 wxCoord xx
= XLOG2DEVMAC(x
);
952 wxCoord yy
= YLOG2DEVMAC(y
);
953 wxCoord ww
= m_signX
* XLOG2DEVREL(width
);
954 wxCoord hh
= m_signY
* YLOG2DEVREL(height
);
955 // CMB: draw nothing if transformed w or h is 0
956 if (ww
== 0 || hh
== 0)
958 // CMB: handle -ve width and/or height
969 Rect rect
= { yy
, xx
, yy
+ hh
, xx
+ ww
} ;
970 if (m_brush
.GetStyle() != wxTRANSPARENT
)
973 ::PaintRect( &rect
) ;
975 if (m_pen
.GetStyle() != wxTRANSPARENT
)
978 ::FrameRect( &rect
) ;
982 void wxDC::DoDrawRoundedRectangle(wxCoord x
, wxCoord y
,
983 wxCoord width
, wxCoord height
,
986 wxCHECK_RET(Ok(), wxT("Invalid DC"));
987 wxMacFastPortSetter
helper(this) ;
989 radius
= - radius
* ((width
< height
) ? width
: height
);
990 wxCoord xx
= XLOG2DEVMAC(x
);
991 wxCoord yy
= YLOG2DEVMAC(y
);
992 wxCoord ww
= m_signX
* XLOG2DEVREL(width
);
993 wxCoord hh
= m_signY
* YLOG2DEVREL(height
);
994 // CMB: draw nothing if transformed w or h is 0
995 if (ww
== 0 || hh
== 0)
997 // CMB: handle -ve width and/or height
1008 Rect rect
= { yy
, xx
, yy
+ hh
, xx
+ ww
} ;
1009 if (m_brush
.GetStyle() != wxTRANSPARENT
)
1012 ::PaintRoundRect( &rect
, int(radius
* 2) , int(radius
* 2) ) ;
1014 if (m_pen
.GetStyle() != wxTRANSPARENT
)
1017 ::FrameRoundRect( &rect
, int(radius
* 2) , int(radius
* 2) ) ;
1021 void wxDC::DoDrawEllipse(wxCoord x
, wxCoord y
, wxCoord width
, wxCoord height
)
1023 wxCHECK_RET(Ok(), wxT("Invalid DC"));
1024 wxMacFastPortSetter
helper(this) ;
1025 wxCoord xx
= XLOG2DEVMAC(x
);
1026 wxCoord yy
= YLOG2DEVMAC(y
);
1027 wxCoord ww
= m_signX
* XLOG2DEVREL(width
);
1028 wxCoord hh
= m_signY
* YLOG2DEVREL(height
);
1029 // CMB: draw nothing if transformed w or h is 0
1030 if (ww
== 0 || hh
== 0)
1032 // CMB: handle -ve width and/or height
1043 Rect rect
= { yy
, xx
, yy
+ hh
, xx
+ ww
} ;
1044 if (m_brush
.GetStyle() != wxTRANSPARENT
)
1047 ::PaintOval( &rect
) ;
1049 if (m_pen
.GetStyle() != wxTRANSPARENT
)
1052 ::FrameOval( &rect
) ;
1056 bool wxDC::CanDrawBitmap(void) const
1061 bool wxDC::DoBlit(wxCoord xdest
, wxCoord ydest
, wxCoord width
, wxCoord height
,
1062 wxDC
*source
, wxCoord xsrc
, wxCoord ysrc
, int logical_func
, bool useMask
,
1063 wxCoord xsrcMask
, wxCoord ysrcMask
)
1065 wxCHECK_MSG(Ok(), false, wxT("wxDC::DoBlit Illegal dc"));
1066 wxCHECK_MSG(source
->Ok(), false, wxT("wxDC::DoBlit Illegal source DC"));
1067 if ( logical_func
== wxNO_OP
)
1069 if (xsrcMask
== -1 && ysrcMask
== -1)
1071 xsrcMask
= xsrc
; ysrcMask
= ysrc
;
1073 // correct the parameter in case this dc does not have a mask at all
1074 if ( useMask
&& !source
->m_macMask
)
1076 Rect srcrect
, dstrect
;
1077 srcrect
.top
= source
->YLOG2DEVMAC(ysrc
) ;
1078 srcrect
.left
= source
->XLOG2DEVMAC(xsrc
) ;
1079 srcrect
.right
= source
->XLOG2DEVMAC(xsrc
+ width
) ;
1080 srcrect
.bottom
= source
->YLOG2DEVMAC(ysrc
+ height
) ;
1081 dstrect
.top
= YLOG2DEVMAC(ydest
) ;
1082 dstrect
.left
= XLOG2DEVMAC(xdest
) ;
1083 dstrect
.bottom
= YLOG2DEVMAC(ydest
+ height
) ;
1084 dstrect
.right
= XLOG2DEVMAC(xdest
+ width
) ;
1085 short mode
= kUnsupportedMode
;
1086 bool invertDestinationFirst
= false ;
1087 switch ( logical_func
)
1089 case wxAND
: // src AND dst
1090 mode
= adMin
; // ok
1092 case wxAND_INVERT
: // (NOT src) AND dst
1093 mode
= notSrcOr
; // ok
1095 case wxAND_REVERSE
:// src AND (NOT dst)
1096 invertDestinationFirst
= true ;
1100 mode
= kEmulatedMode
;
1103 mode
= srcCopy
; // ok
1105 case wxEQUIV
: // (NOT src) XOR dst
1106 mode
= srcXor
; // ok
1108 case wxINVERT
: // NOT dst
1109 mode
= kEmulatedMode
; //or hilite ;
1111 case wxNAND
: // (NOT src) OR (NOT dst)
1112 invertDestinationFirst
= true ;
1115 case wxNOR
: // (NOT src) AND (NOT dst)
1116 invertDestinationFirst
= true ;
1119 case wxNO_OP
: // dst
1120 mode
= kEmulatedMode
; // this has already been handled upon entry
1122 case wxOR
: // src OR dst
1125 case wxOR_INVERT
: // (NOT src) OR dst
1128 case wxOR_REVERSE
: // src OR (NOT dst)
1129 invertDestinationFirst
= true ;
1133 mode
= kEmulatedMode
;
1135 case wxSRC_INVERT
: // (NOT src)
1136 mode
= notSrcCopy
; // ok
1138 case wxXOR
: // src XOR dst
1139 mode
= notSrcXor
; // ok
1144 if ( mode
== kUnsupportedMode
)
1146 wxFAIL_MSG(wxT("unsupported blitting mode" ));
1149 CGrafPtr sourcePort
= (CGrafPtr
) source
->m_macPort
;
1150 PixMapHandle bmappixels
= GetGWorldPixMap( sourcePort
) ;
1151 if ( LockPixels(bmappixels
) )
1153 wxMacFastPortSetter
helper(this) ;
1154 if ( source
->GetDepth() == 1 )
1156 RGBForeColor( &MAC_WXCOLORREF(m_textForegroundColour
.GetPixel()) ) ;
1157 RGBBackColor( &MAC_WXCOLORREF(m_textBackgroundColour
.GetPixel()) ) ;
1161 // the modes need this, otherwise we'll end up having really nice colors...
1162 RGBColor white
= { 0xFFFF, 0xFFFF,0xFFFF} ;
1163 RGBColor black
= { 0,0,0} ;
1164 RGBForeColor( &black
) ;
1165 RGBBackColor( &white
) ;
1167 if ( useMask
&& source
->m_macMask
)
1169 if ( mode
== srcCopy
)
1171 if ( LockPixels( GetGWorldPixMap( MAC_WXHBITMAP(source
->m_macMask
) ) ) )
1173 CopyMask( GetPortBitMapForCopyBits( sourcePort
) ,
1174 GetPortBitMapForCopyBits( MAC_WXHBITMAP(source
->m_macMask
) ) ,
1175 GetPortBitMapForCopyBits( MAC_WXHBITMAP(m_macPort
) ) ,
1176 &srcrect
, &srcrect
, &dstrect
) ;
1177 UnlockPixels( GetGWorldPixMap( MAC_WXHBITMAP(source
->m_macMask
) ) ) ;
1182 RgnHandle clipRgn
= NewRgn() ;
1183 LockPixels( GetGWorldPixMap( MAC_WXHBITMAP(source
->m_macMask
) ) ) ;
1184 BitMapToRegion( clipRgn
, (BitMap
*) *GetGWorldPixMap( MAC_WXHBITMAP(source
->m_macMask
) ) ) ;
1185 UnlockPixels( GetGWorldPixMap( MAC_WXHBITMAP(source
->m_macMask
) ) ) ;
1186 OffsetRgn( clipRgn
, -srcrect
.left
+ dstrect
.left
, -srcrect
.top
+ dstrect
.top
) ;
1187 if ( mode
== kEmulatedMode
)
1190 ::PenPat(GetQDGlobalsBlack(&pat
));
1191 if ( logical_func
== wxSET
)
1193 RGBColor col
= { 0xFFFF, 0xFFFF, 0xFFFF } ;
1194 ::RGBForeColor( &col
) ;
1195 ::PaintRgn( clipRgn
) ;
1197 else if ( logical_func
== wxCLEAR
)
1199 RGBColor col
= { 0x0000, 0x0000, 0x0000 } ;
1200 ::RGBForeColor( &col
) ;
1201 ::PaintRgn( clipRgn
) ;
1203 else if ( logical_func
== wxINVERT
)
1205 MacInvertRgn( clipRgn
) ;
1209 for ( int y
= 0 ; y
< srcrect
.right
- srcrect
.left
; ++y
)
1211 for ( int x
= 0 ; x
< srcrect
.bottom
- srcrect
.top
; ++x
)
1213 Point dstPoint
= { dstrect
.top
+ y
, dstrect
.left
+ x
} ;
1214 Point srcPoint
= { srcrect
.top
+ y
, srcrect
.left
+ x
} ;
1215 if ( PtInRgn( dstPoint
, clipRgn
) )
1219 SetPort( (GrafPtr
) sourcePort
) ;
1220 GetCPixel( srcPoint
.h
, srcPoint
.v
, &srcColor
) ;
1221 SetPort( (GrafPtr
) m_macPort
) ;
1222 GetCPixel( dstPoint
.h
, dstPoint
.v
, &dstColor
) ;
1223 wxMacCalculateColour( logical_func
, srcColor
, dstColor
) ;
1224 SetCPixel( dstPoint
.h
, dstPoint
.v
, &dstColor
) ;
1232 if ( invertDestinationFirst
)
1234 MacInvertRgn( clipRgn
) ;
1236 CopyBits( GetPortBitMapForCopyBits( sourcePort
) ,
1237 GetPortBitMapForCopyBits( MAC_WXHBITMAP(m_macPort
) ) ,
1238 &srcrect
, &dstrect
, mode
, clipRgn
) ;
1240 DisposeRgn( clipRgn
) ;
1245 RgnHandle clipRgn
= NewRgn() ;
1246 SetRectRgn( clipRgn
, dstrect
.left
, dstrect
.top
, dstrect
.right
, dstrect
.bottom
) ;
1247 if ( mode
== kEmulatedMode
)
1250 ::PenPat(GetQDGlobalsBlack(&pat
));
1251 if ( logical_func
== wxSET
)
1253 RGBColor col
= { 0xFFFF, 0xFFFF, 0xFFFF } ;
1254 ::RGBForeColor( &col
) ;
1255 ::PaintRgn( clipRgn
) ;
1257 else if ( logical_func
== wxCLEAR
)
1259 RGBColor col
= { 0x0000, 0x0000, 0x0000 } ;
1260 ::RGBForeColor( &col
) ;
1261 ::PaintRgn( clipRgn
) ;
1263 else if ( logical_func
== wxINVERT
)
1265 MacInvertRgn( clipRgn
) ;
1269 for ( int y
= 0 ; y
< srcrect
.right
- srcrect
.left
; ++y
)
1271 for ( int x
= 0 ; x
< srcrect
.bottom
- srcrect
.top
; ++x
)
1273 Point dstPoint
= { dstrect
.top
+ y
, dstrect
.left
+ x
} ;
1274 Point srcPoint
= { srcrect
.top
+ y
, srcrect
.left
+ x
} ;
1278 SetPort( (GrafPtr
) sourcePort
) ;
1279 GetCPixel( srcPoint
.h
, srcPoint
.v
, &srcColor
) ;
1280 SetPort( (GrafPtr
) m_macPort
) ;
1281 GetCPixel( dstPoint
.h
, dstPoint
.v
, &dstColor
) ;
1282 wxMacCalculateColour( logical_func
, srcColor
, dstColor
) ;
1283 SetCPixel( dstPoint
.h
, dstPoint
.v
, &dstColor
) ;
1291 if ( invertDestinationFirst
)
1293 MacInvertRgn( clipRgn
) ;
1295 CopyBits( GetPortBitMapForCopyBits( sourcePort
) ,
1296 GetPortBitMapForCopyBits( MAC_WXHBITMAP(m_macPort
) ) ,
1297 &srcrect
, &dstrect
, mode
, NULL
) ;
1299 DisposeRgn( clipRgn
) ;
1301 UnlockPixels( bmappixels
) ;
1303 m_macPenInstalled
= false ;
1304 m_macBrushInstalled
= false ;
1305 m_macFontInstalled
= false ;
1310 // as macro in FixMath.h for 10.3
1311 inline Fixed
IntToFixed( int inInt
)
1313 return (((SInt32
) inInt
) << 16);
1316 inline int FixedToInt( Fixed inFixed
)
1318 return (((SInt32
) inFixed
) >> 16);
1322 void wxDC::DoDrawRotatedText(const wxString
& str
, wxCoord x
, wxCoord y
,
1325 wxCHECK_RET( Ok(), wxT("wxDC::DoDrawRotatedText Invalid window dc") );
1329 DrawText(str, x, y);
1333 if ( str.Length() == 0 )
1336 wxMacFastPortSetter
helper(this) ;
1341 m_macFormerAliasState
= IsAntiAliasedTextEnabled(&m_macFormerAliasSize
);
1342 SetAntiAliasedTextEnabled(true, SInt16(m_scaleY
* m_font
.MacGetFontSize()));
1343 m_macAliasWasEnabled
= true ;
1345 OSStatus status
= noErr
;
1346 ATSUTextLayout atsuLayout
;
1347 UniCharCount chars
= str
.Length() ;
1349 status
= ::ATSUCreateTextLayoutWithTextPtr( (UniCharArrayPtr
) (const wxChar
*) str
, 0 , str
.Length() , str
.Length() , 1 ,
1350 &chars
, (ATSUStyle
*) &m_macATSUIStyle
, &atsuLayout
) ;
1352 wxWCharBuffer wchar
= str
.wc_str( wxConvLocal
) ;
1353 int wlen
= wxWcslen( wchar
.data() ) ;
1354 status
= ::ATSUCreateTextLayoutWithTextPtr( (UniCharArrayPtr
) wchar
.data() , 0 , wlen
, wlen
, 1 ,
1355 &chars
, (ATSUStyle
*) &m_macATSUIStyle
, &atsuLayout
) ;
1357 wxASSERT_MSG( status
== noErr
, wxT("couldn't create the layout of the rotated text") );
1358 int iAngle
= int( angle
);
1359 int drawX
= XLOG2DEVMAC(x
) ;
1360 int drawY
= YLOG2DEVMAC(y
) ;
1362 ATSUTextMeasurement textBefore
;
1363 ATSUTextMeasurement textAfter
;
1364 ATSUTextMeasurement ascent
;
1365 ATSUTextMeasurement descent
;
1368 if ( abs(iAngle
) > 0 )
1370 Fixed atsuAngle
= IntToFixed( iAngle
) ;
1371 ATSUAttributeTag atsuTags
[] =
1373 kATSULineRotationTag
,
1375 ByteCount atsuSizes
[sizeof(atsuTags
)/sizeof(ATSUAttributeTag
)] =
1379 ATSUAttributeValuePtr atsuValues
[sizeof(atsuTags
)/sizeof(ATSUAttributeTag
)] =
1383 status
= ::ATSUSetLayoutControls(atsuLayout
, sizeof(atsuTags
)/sizeof(ATSUAttributeTag
),
1384 atsuTags
, atsuSizes
, atsuValues
) ;
1386 status
= ::ATSUMeasureText( atsuLayout
, kATSUFromTextBeginning
, kATSUToTextEnd
,
1387 &textBefore
, &textAfter
, &ascent
, &descent
);
1389 drawX
+= (int)(sin(angle
/RAD2DEG
) * FixedToInt(ascent
));
1390 drawY
+= (int)(cos(angle
/RAD2DEG
) * FixedToInt(ascent
));
1391 status
= ::ATSUDrawText( atsuLayout
, kATSUFromTextBeginning
, kATSUToTextEnd
,
1392 IntToFixed(drawX
) , IntToFixed(drawY
) );
1393 wxASSERT_MSG( status
== noErr
, wxT("couldn't draw the rotated text") );
1395 status
= ::ATSUMeasureTextImage( atsuLayout
, kATSUFromTextBeginning
, kATSUToTextEnd
,
1396 IntToFixed(drawX
) , IntToFixed(drawY
) , &rect
);
1397 wxASSERT_MSG( status
== noErr
, wxT("couldn't measure the rotated text") );
1398 OffsetRect( &rect
, -m_macLocalOrigin
.x
, -m_macLocalOrigin
.y
) ;
1399 CalcBoundingBox(XDEV2LOG(rect
.left
), YDEV2LOG(rect
.top
) );
1400 CalcBoundingBox(XDEV2LOG(rect
.right
), YDEV2LOG(rect
.bottom
) );
1401 ::ATSUDisposeTextLayout(atsuLayout
);
1404 void wxDC::DoDrawText(const wxString
& strtext
, wxCoord x
, wxCoord y
)
1406 wxCHECK_RET(Ok(), wxT("wxDC::DoDrawText Invalid DC"));
1408 wxMacFastPortSetter
helper(this) ;
1409 long xx
= XLOG2DEVMAC(x
);
1410 long yy
= YLOG2DEVMAC(y
);
1412 bool useDrawThemeText
= ( DrawThemeTextBox
!= (void*) kUnresolvedCFragSymbolAddress
) ;
1413 if ( UMAGetSystemVersion() < 0x1000 || IsKindOf(CLASSINFO( wxPrinterDC
) ) || m_font
.GetNoAntiAliasing() )
1414 useDrawThemeText
= false ;
1419 m_macFormerAliasState
= IsAntiAliasedTextEnabled(&m_macFormerAliasSize
);
1420 SetAntiAliasedTextEnabled(true, 8);
1421 m_macAliasWasEnabled
= true ;
1424 ::GetFontInfo( &fi
) ;
1426 if ( !useDrawThemeText
)
1429 ::MoveTo( xx
, yy
);
1430 if ( m_backgroundMode
== wxTRANSPARENT
)
1432 ::TextMode( srcOr
) ;
1436 ::TextMode( srcCopy
) ;
1440 wxString linetext
= strtext
;
1442 if ( useDrawThemeText
)
1444 Rect frame
= { yy
+ line
*(fi
.descent
+ fi
.ascent
+ fi
.leading
) ,xx
, yy
+ (line
+1)*(fi
.descent
+ fi
.ascent
+ fi
.leading
) , xx
+ 10000 } ;
1445 wxMacCFStringHolder
mString( linetext
, m_font
.GetEncoding()) ;
1447 if ( m_backgroundMode
!= wxTRANSPARENT
)
1449 Point bounds
={0,0} ;
1450 Rect background
= frame
;
1452 ::GetThemeTextDimensions( mString
,
1453 m_font
.MacGetThemeFontID() ,
1458 background
.right
= background
.left
+ bounds
.h
;
1459 background
.bottom
= background
.top
+ bounds
.v
;
1460 ::EraseRect( &background
) ;
1462 ::DrawThemeTextBox( mString
,
1463 m_font
.MacGetThemeFontID() ,
1473 wxCharBuffer text
= linetext
.mb_str(wxConvLocal
) ;
1474 if ( m_backgroundMode
!= wxTRANSPARENT
)
1476 Rect frame
= { yy
- fi
.ascent
+ line
*(fi
.descent
+ fi
.ascent
+ fi
.leading
) ,xx
, yy
- fi
.ascent
+ (line
+1)*(fi
.descent
+ fi
.ascent
+ fi
.leading
) , xx
+ 10000 } ;
1477 short width
= ::TextWidth( text
, 0 , strlen(text
) ) ;
1478 frame
.right
= frame
.left
+ width
;
1480 ::EraseRect( &frame
) ;
1482 ::DrawText( text
, 0 , strlen(text
) ) ;
1485 ::TextMode( srcOr
) ;
1488 bool wxDC::CanGetTextExtent() const
1490 wxCHECK_MSG(Ok(), false, wxT("Invalid DC"));
1494 void wxDC::DoGetTextExtent( const wxString
&strtext
, wxCoord
*width
, wxCoord
*height
,
1495 wxCoord
*descent
, wxCoord
*externalLeading
,
1496 wxFont
*theFont
) const
1498 wxCHECK_RET(Ok(), wxT("Invalid DC"));
1499 wxMacFastPortSetter
helper(this) ;
1500 wxFont formerFont
= m_font
;
1503 // work around the constness
1504 *((wxFont
*)(&m_font
)) = *theFont
;
1508 ::GetFontInfo( &fi
) ;
1510 bool useGetThemeText
= ( GetThemeTextDimensions
!= (void*) kUnresolvedCFragSymbolAddress
) ;
1511 if ( UMAGetSystemVersion() < 0x1000 || IsKindOf(CLASSINFO( wxPrinterDC
) ) || ((wxFont
*)&m_font
)->GetNoAntiAliasing() )
1512 useGetThemeText
= false ;
1515 *height
= YDEV2LOGREL( fi
.descent
+ fi
.ascent
) ;
1517 *descent
=YDEV2LOGREL( fi
.descent
);
1518 if ( externalLeading
)
1519 *externalLeading
= YDEV2LOGREL( fi
.leading
) ;
1525 wxString linetext
= strtext
;
1527 if ( useGetThemeText
)
1529 Point bounds
={0,0} ;
1531 wxMacCFStringHolder
mString( linetext
, m_font
.GetEncoding() ) ;
1532 ThemeFontID themeFont
= m_font
.MacGetThemeFontID() ;
1533 ::GetThemeTextDimensions( mString
,
1539 curwidth
= bounds
.h
;
1543 wxCharBuffer text
= linetext
.mb_str(wxConvLocal
) ;
1544 curwidth
= ::TextWidth( text
, 0 , strlen(text
) ) ;
1546 if ( curwidth
> *width
)
1547 *width
= XDEV2LOGREL( curwidth
) ;
1551 // work around the constness
1552 *((wxFont
*)(&m_font
)) = formerFont
;
1553 m_macFontInstalled
= false ;
1558 bool wxDC::DoGetPartialTextExtents(const wxString
& text
, wxArrayInt
& widths
) const
1560 wxCHECK_MSG(Ok(), false, wxT("Invalid DC"));
1563 widths
.Add(0, text
.Length());
1565 if (text
.Length() == 0)
1568 wxMacFastPortSetter
helper(this) ;
1571 bool useGetThemeText
= ( GetThemeTextDimensions
!= (void*) kUnresolvedCFragSymbolAddress
) ;
1572 if ( UMAGetSystemVersion() < 0x1000 || IsKindOf(CLASSINFO( wxPrinterDC
) ) || ((wxFont
*)&m_font
)->GetNoAntiAliasing() )
1573 useGetThemeText
= false ;
1575 if ( useGetThemeText
)
1577 // If anybody knows how to do this more efficiently yet still handle
1578 // the fractional glyph widths that may be present when using AA
1579 // fonts, please change it. Currently it is measuring from the
1580 // begining of the string for each succeding substring, which is much
1581 // slower than this should be.
1582 for (size_t i
=0; i
<text
.Length(); i
++)
1584 wxString
str(text
.Left(i
+1));
1585 Point bounds
= {0,0};
1587 wxMacCFStringHolder
mString(str
, m_font
.GetEncoding());
1588 ::GetThemeTextDimensions( mString
,
1589 m_font
.MacGetThemeFontID(),
1594 widths
[i
] = XDEV2LOGREL(bounds
.h
);
1600 wxCharBuffer buff
= text
.mb_str(wxConvLocal
);
1601 size_t len
= strlen(buff
);
1602 short* measurements
= new short[len
+1];
1603 MeasureText(len
, buff
.data(), measurements
);
1605 // Copy to widths, starting at measurements[1]
1606 // NOTE: this doesn't take into account any multi-byte characters
1607 // in buff, it probabkly should...
1608 for (size_t i
=0; i
<text
.Length(); i
++)
1609 widths
[i
] = XDEV2LOGREL(measurements
[i
+1]);
1611 delete [] measurements
;
1619 wxCoord
wxDC::GetCharWidth(void) const
1621 wxCHECK_MSG(Ok(), 1, wxT("Invalid DC"));
1622 wxMacFastPortSetter
helper(this) ;
1626 bool useGetThemeText
= ( GetThemeTextDimensions
!= (void*) kUnresolvedCFragSymbolAddress
) ;
1627 if ( UMAGetSystemVersion() < 0x1000 || ((wxFont
*)&m_font
)->GetNoAntiAliasing() )
1628 useGetThemeText
= false ;
1632 if ( useGetThemeText
)
1634 Point bounds
={0,0} ;
1636 CFStringRef mString
= CFStringCreateWithBytes( NULL
, (UInt8
*) text
, 1 , CFStringGetSystemEncoding(), false ) ;
1637 ::GetThemeTextDimensions( mString
,
1638 m_font
.MacGetThemeFontID(),
1643 CFRelease( mString
) ;
1649 width
= ::TextWidth( text
, 0 , 1 ) ;
1651 return YDEV2LOGREL(width
) ;
1654 wxCoord
wxDC::GetCharHeight(void) const
1656 wxCHECK_MSG(Ok(), 1, wxT("Invalid DC"));
1657 wxMacFastPortSetter
helper(this) ;
1660 ::GetFontInfo( &fi
) ;
1661 return YDEV2LOGREL( fi
.descent
+ fi
.ascent
);
1664 void wxDC::Clear(void)
1666 wxCHECK_RET(Ok(), wxT("Invalid DC"));
1667 wxMacFastPortSetter
helper(this) ;
1668 Rect rect
= { -31000 , -31000 , 31000 , 31000 } ;
1669 if ( m_backgroundBrush
.Ok() && m_backgroundBrush
.GetStyle() != wxTRANSPARENT
)
1672 MacSetupBackgroundForCurrentPort( m_backgroundBrush
) ;
1673 ::EraseRect( &rect
) ;
1677 void wxDC::MacInstallFont() const
1679 wxCHECK_RET(Ok(), wxT("Invalid DC"));
1680 // if ( m_macFontInstalled )
1682 Pattern blackColor
;
1683 MacSetupBackgroundForCurrentPort(m_backgroundBrush
) ;
1686 ::TextFont( m_font
.MacGetFontNum() ) ;
1687 ::TextSize( (short)(m_scaleY
* m_font
.MacGetFontSize()) ) ;
1688 ::TextFace( m_font
.MacGetFontStyle() ) ;
1689 m_macFontInstalled
= true ;
1690 m_macBrushInstalled
= false ;
1691 m_macPenInstalled
= false ;
1692 RGBColor forecolor
= MAC_WXCOLORREF( m_textForegroundColour
.GetPixel());
1693 RGBColor backcolor
= MAC_WXCOLORREF( m_textBackgroundColour
.GetPixel());
1694 ::RGBForeColor( &forecolor
);
1695 ::RGBBackColor( &backcolor
);
1699 FontFamilyID fontId
;
1703 GetThemeFont(kThemeSmallSystemFont
, GetApplicationScript() , fontName
, &fontSize
, &fontStyle
) ;
1704 GetFNum( fontName
, &fontId
);
1705 ::TextFont( fontId
) ;
1706 ::TextSize( short(m_scaleY
* fontSize
) ) ;
1707 ::TextFace( fontStyle
) ;
1708 // todo reset after spacing changes - or store the current spacing somewhere
1709 m_macFontInstalled
= true ;
1710 m_macBrushInstalled
= false ;
1711 m_macPenInstalled
= false ;
1712 RGBColor forecolor
= MAC_WXCOLORREF( m_textForegroundColour
.GetPixel());
1713 RGBColor backcolor
= MAC_WXCOLORREF( m_textBackgroundColour
.GetPixel());
1714 ::RGBForeColor( &forecolor
);
1715 ::RGBBackColor( &backcolor
);
1717 short mode
= patCopy
;
1719 switch( m_logicalFunction
)
1724 case wxINVERT
: // NOT dst
1725 ::PenPat(GetQDGlobalsBlack(&blackColor
));
1728 case wxXOR
: // src XOR dst
1731 case wxOR_REVERSE
: // src OR (NOT dst)
1734 case wxSRC_INVERT
: // (NOT src)
1737 case wxAND
: // src AND dst
1742 case wxAND_REVERSE
:// src AND (NOT dst)
1743 case wxAND_INVERT
: // (NOT src) AND dst
1744 case wxNO_OP
: // dst
1745 case wxNOR
: // (NOT src) AND (NOT dst)
1746 case wxEQUIV
: // (NOT src) XOR dst
1747 case wxOR_INVERT
: // (NOT src) OR dst
1748 case wxNAND
: // (NOT src) OR (NOT dst)
1749 case wxOR
: // src OR dst
1751 // case wxSRC_OR: // source _bitmap_ OR destination
1752 // case wxSRC_AND: // source _bitmap_ AND destination
1756 OSStatus status
= noErr
;
1757 Fixed atsuSize
= IntToFixed( int(m_scaleY
* m_font
.MacGetFontSize()) ) ;
1758 Style qdStyle
= m_font
.MacGetATSUAdditionalQDStyles() ;
1759 ATSUFontID atsuFont
= m_font
.MacGetATSUFontID() ;
1760 status
= ::ATSUCreateStyle((ATSUStyle
*)&m_macATSUIStyle
) ;
1761 wxASSERT_MSG( status
== noErr
, wxT("couldn't create ATSU style") ) ;
1762 ATSUAttributeTag atsuTags
[] =
1767 // kATSUBaselineClassTag ,
1768 kATSUVerticalCharacterTag
,
1769 kATSUQDBoldfaceTag
,
1771 kATSUQDUnderlineTag
,
1772 kATSUQDCondensedTag
,
1773 kATSUQDExtendedTag
,
1775 ByteCount atsuSizes
[sizeof(atsuTags
)/sizeof(ATSUAttributeTag
)] =
1777 sizeof( ATSUFontID
) ,
1779 // sizeof( RGBColor ) ,
1780 // sizeof( BslnBaselineClass ) ,
1781 sizeof( ATSUVerticalCharacterType
),
1788 Boolean kTrue
= true ;
1789 Boolean kFalse
= false ;
1790 //BslnBaselineClass kBaselineDefault = kBSLNHangingBaseline ;
1791 ATSUVerticalCharacterType kHorizontal
= kATSUStronglyHorizontal
;
1792 ATSUAttributeValuePtr atsuValues
[sizeof(atsuTags
)/sizeof(ATSUAttributeTag
)] =
1796 // &MAC_WXCOLORREF( m_textForegroundColour.GetPixel() ) ,
1797 // &kBaselineDefault ,
1799 (qdStyle
& bold
) ? &kTrue
: &kFalse
,
1800 (qdStyle
& italic
) ? &kTrue
: &kFalse
,
1801 (qdStyle
& underline
) ? &kTrue
: &kFalse
,
1802 (qdStyle
& condense
) ? &kTrue
: &kFalse
,
1803 (qdStyle
& extend
) ? &kTrue
: &kFalse
,
1805 status
= ::ATSUSetAttributes((ATSUStyle
)m_macATSUIStyle
, sizeof(atsuTags
)/sizeof(ATSUAttributeTag
) ,
1806 atsuTags
, atsuSizes
, atsuValues
);
1807 wxASSERT_MSG( status
== noErr
, wxT("couldn't set create ATSU style") ) ;
1810 Pattern gPatterns
[] =
1812 { { 0xFF , 0xFF , 0xFF , 0xFF , 0xFF , 0xFF , 0xFF , 0xFF } } ,
1813 { { 0x01 , 0x02 , 0x04 , 0x08 , 0x10 , 0x20 , 0x40 , 0x80 } } ,
1814 { { 0x80 , 0x40 , 0x20 , 0x10 , 0x08 , 0x04 , 0x02 , 0x01 } } ,
1815 { { 0x10 , 0x10 , 0x10 , 0xFF , 0x10 , 0x10 , 0x10 , 0x10 } } ,
1816 { { 0x00 , 0x00 , 0x00 , 0xFF , 0x00 , 0x00 , 0x00 , 0x00 } } ,
1817 { { 0x10 , 0x10 , 0x10 , 0x10 , 0x10 , 0x10 , 0x10 , 0x10 } } ,
1818 { { 0x81 , 0x42 , 0x24 , 0x18 , 0x18 , 0x24 , 0x42 , 0x81 } } ,
1820 { { 0xCC , 0x99 , 0x33 , 0x66 , 0xCC , 0x99 , 0x33 , 0x66 } } , // DOT
1821 { { 0xFE , 0xFD , 0xFB , 0xF7 , 0xEF , 0xDF , 0xBF , 0x7F } } , // LONG_DASH
1822 { { 0xEE , 0xDD , 0xBB , 0x77 , 0xEE , 0xDD , 0xBB , 0x77 } } , // SHORT_DASH
1823 { { 0xDE , 0xBD , 0x7B , 0xF6 , 0xED , 0xDB , 0xB7 , 0x6F } } , // DOT_DASH
1826 static void wxMacGetPattern(int penStyle
, Pattern
*pattern
)
1828 int index
= 0; // solid pattern by default
1832 case wxBDIAGONAL_HATCH
: index
= 1; break;
1833 case wxFDIAGONAL_HATCH
: index
= 2; break;
1834 case wxCROSS_HATCH
: index
= 3; break;
1835 case wxHORIZONTAL_HATCH
: index
= 4; break;
1836 case wxVERTICAL_HATCH
: index
= 5; break;
1837 case wxCROSSDIAG_HATCH
: index
= 6; break;
1839 case wxDOT
: index
= 7; break;
1840 case wxLONG_DASH
: index
= 8; break;
1841 case wxSHORT_DASH
: index
= 9; break;
1842 case wxDOT_DASH
: index
= 10; break;
1844 *pattern
= gPatterns
[index
];
1847 void wxDC::MacInstallPen() const
1849 wxCHECK_RET(Ok(), wxT("Invalid DC"));
1850 //Pattern blackColor;
1851 // if ( m_macPenInstalled )
1853 RGBColor forecolor
= MAC_WXCOLORREF( m_pen
.GetColour().GetPixel());
1854 RGBColor backcolor
= MAC_WXCOLORREF( m_backgroundBrush
.GetColour().GetPixel());
1855 ::RGBForeColor( &forecolor
);
1856 ::RGBBackColor( &backcolor
);
1858 int penWidth
= (int) (m_pen
.GetWidth() * m_scaleX
) ; ;
1859 // null means only one pixel, at whatever resolution
1860 if ( penWidth
== 0 )
1862 ::PenSize(penWidth
, penWidth
);
1864 int penStyle
= m_pen
.GetStyle();
1866 if (penStyle
== wxUSER_DASH
)
1868 // FIXME: there should be exactly 8 items in the dash
1870 int number
= m_pen
.GetDashes(&dash
) ;
1872 for ( int i
= 0 ; i
< 8 ; ++i
)
1874 pat
.pat
[i
] = dash
[index
] ;
1875 if (index
< number
- 1)
1881 wxMacGetPattern(penStyle
, &pat
);
1885 short mode
= patCopy
;
1887 switch( m_logicalFunction
)
1889 case wxCOPY
: // only foreground color, leave background (thus not patCopy)
1892 case wxINVERT
: // NOT dst
1893 // ::PenPat(GetQDGlobalsBlack(&blackColor));
1896 case wxXOR
: // src XOR dst
1899 case wxOR_REVERSE
: // src OR (NOT dst)
1902 case wxSRC_INVERT
: // (NOT src)
1905 case wxAND
: // src AND dst
1910 case wxAND_REVERSE
:// src AND (NOT dst)
1911 case wxAND_INVERT
: // (NOT src) AND dst
1912 case wxNO_OP
: // dst
1913 case wxNOR
: // (NOT src) AND (NOT dst)
1914 case wxEQUIV
: // (NOT src) XOR dst
1915 case wxOR_INVERT
: // (NOT src) OR dst
1916 case wxNAND
: // (NOT src) OR (NOT dst)
1917 case wxOR
: // src OR dst
1919 // case wxSRC_OR: // source _bitmap_ OR destination
1920 // case wxSRC_AND: // source _bitmap_ AND destination
1924 m_macPenInstalled
= true ;
1925 m_macBrushInstalled
= false ;
1926 m_macFontInstalled
= false ;
1929 void wxDC::MacSetupBackgroundForCurrentPort(const wxBrush
& background
)
1931 Pattern whiteColor
;
1932 if ( background
.Ok() )
1934 switch( background
.MacGetBrushKind() )
1936 case kwxMacBrushTheme
:
1938 ::SetThemeBackground( background
.MacGetTheme() , wxDisplayDepth() , true ) ;
1941 case kwxMacBrushThemeBackground
:
1944 ThemeBackgroundKind bg
= background
.MacGetThemeBackground( &extent
) ;
1945 ::ApplyThemeBackground( bg
, &extent
,kThemeStateActive
, wxDisplayDepth() , true ) ;
1948 case kwxMacBrushColour
:
1950 ::RGBBackColor( &MAC_WXCOLORREF( background
.GetColour().GetPixel()) );
1951 int brushStyle
= background
.GetStyle();
1952 if (brushStyle
== wxSOLID
)
1953 ::BackPat(GetQDGlobalsWhite(&whiteColor
));
1954 else if (IS_HATCH(brushStyle
))
1957 wxMacGetPattern(brushStyle
, &pat
);
1962 ::BackPat(GetQDGlobalsWhite(&whiteColor
));
1970 void wxDC::MacInstallBrush() const
1972 wxCHECK_RET(Ok(), wxT("Invalid DC"));
1973 Pattern blackColor
;
1974 // if ( m_macBrushInstalled )
1977 bool backgroundTransparent
= (GetBackgroundMode() == wxTRANSPARENT
) ;
1978 ::RGBForeColor( &MAC_WXCOLORREF( m_brush
.GetColour().GetPixel()) );
1979 ::RGBBackColor( &MAC_WXCOLORREF( m_backgroundBrush
.GetColour().GetPixel()) );
1980 int brushStyle
= m_brush
.GetStyle();
1981 if (brushStyle
== wxSOLID
)
1983 ::PenPat(GetQDGlobalsBlack(&blackColor
));
1985 else if (IS_HATCH(brushStyle
))
1988 wxMacGetPattern(brushStyle
, &pat
);
1991 else if ( m_brush
.GetStyle() == wxSTIPPLE
|| m_brush
.GetStyle() == wxSTIPPLE_MASK_OPAQUE
)
1993 // we force this in order to be compliant with wxMSW
1994 backgroundTransparent
= false ;
1995 // for these the text fore (and back for MASK_OPAQUE) colors are used
1996 wxBitmap
* bitmap
= m_brush
.GetStipple() ;
1997 int width
= bitmap
->GetWidth() ;
1998 int height
= bitmap
->GetHeight() ;
1999 GWorldPtr gw
= NULL
;
2000 if ( m_brush
.GetStyle() == wxSTIPPLE
)
2001 gw
= MAC_WXHBITMAP(bitmap
->GetHBITMAP()) ;
2003 gw
= MAC_WXHBITMAP(bitmap
->GetMask()->GetMaskBitmap()) ;
2004 PixMapHandle gwpixmaphandle
= GetGWorldPixMap( gw
) ;
2005 LockPixels( gwpixmaphandle
) ;
2006 bool isMonochrome
= !IsPortColor( gw
) ;
2007 if ( !isMonochrome
)
2009 if ( (**gwpixmaphandle
).pixelSize
== 1 )
2010 isMonochrome
= true ;
2012 if ( isMonochrome
&& width
== 8 && height
== 8 )
2014 ::RGBForeColor( &MAC_WXCOLORREF( m_textForegroundColour
.GetPixel()) );
2015 ::RGBForeColor( &MAC_WXCOLORREF( m_textBackgroundColour
.GetPixel()) );
2016 BitMap
* gwbitmap
= (BitMap
*) *gwpixmaphandle
; // since the color depth is 1 it is a BitMap
2017 UInt8
*gwbits
= (UInt8
*) gwbitmap
->baseAddr
;
2018 int alignment
= gwbitmap
->rowBytes
& 0x7FFF ;
2020 for ( int i
= 0 ; i
< 8 ; ++i
)
2022 pat
.pat
[i
] = gwbits
[i
*alignment
+0] ;
2024 UnlockPixels( GetGWorldPixMap( gw
) ) ;
2029 // this will be the code to handle power of 2 patterns, we will have to arrive at a nice
2030 // caching scheme before putting this into production
2033 PixPatHandle pixpat
= NewPixPat() ;
2034 CopyPixMap(gwpixmaphandle
, (**pixpat
).patMap
);
2035 imageSize
= GetPixRowBytes((**pixpat
).patMap
) *
2036 ((**(**pixpat
).patMap
).bounds
.bottom
-
2037 (**(**pixpat
).patMap
).bounds
.top
);
2038 PtrToHand( (**gwpixmaphandle
).baseAddr
, &image
, imageSize
);
2039 (**pixpat
).patData
= image
;
2042 CTabHandle ctable
= ((**((**pixpat
).patMap
)).pmTable
) ;
2043 ColorSpecPtr ctspec
= (ColorSpecPtr
) &(**ctable
).ctTable
;
2044 if ( ctspec
[0].rgb
.red
== 0x0000 )
2046 ctspec
[1].rgb
= MAC_WXCOLORREF( m_textBackgroundColour
.GetPixel()) ;
2047 ctspec
[0].rgb
= MAC_WXCOLORREF( m_textForegroundColour
.GetPixel()) ;
2051 ctspec
[0].rgb
= MAC_WXCOLORREF( m_textBackgroundColour
.GetPixel()) ;
2052 ctspec
[1].rgb
= MAC_WXCOLORREF( m_textForegroundColour
.GetPixel()) ;
2054 ::CTabChanged( ctable
) ;
2056 ::PenPixPat(pixpat
);
2057 m_macForegroundPixMap
= pixpat
;
2059 UnlockPixels( gwpixmaphandle
) ;
2063 ::PenPat(GetQDGlobalsBlack(&blackColor
));
2065 short mode
= patCopy
;
2066 switch( m_logicalFunction
)
2069 if ( backgroundTransparent
)
2074 case wxINVERT
: // NOT dst
2075 if ( !backgroundTransparent
)
2077 ::PenPat(GetQDGlobalsBlack(&blackColor
));
2081 case wxXOR
: // src XOR dst
2084 case wxOR_REVERSE
: // src OR (NOT dst)
2087 case wxSRC_INVERT
: // (NOT src)
2090 case wxAND
: // src AND dst
2095 case wxAND_REVERSE
:// src AND (NOT dst)
2096 case wxAND_INVERT
: // (NOT src) AND dst
2097 case wxNO_OP
: // dst
2098 case wxNOR
: // (NOT src) AND (NOT dst)
2099 case wxEQUIV
: // (NOT src) XOR dst
2100 case wxOR_INVERT
: // (NOT src) OR dst
2101 case wxNAND
: // (NOT src) OR (NOT dst)
2102 case wxOR
: // src OR dst
2104 // case wxSRC_OR: // source _bitmap_ OR destination
2105 // case wxSRC_AND: // source _bitmap_ AND destination
2109 m_macBrushInstalled
= true ;
2110 m_macPenInstalled
= false ;
2111 m_macFontInstalled
= false ;
2114 // ---------------------------------------------------------------------------
2115 // coordinates transformations
2116 // ---------------------------------------------------------------------------
2118 wxCoord
wxDCBase::DeviceToLogicalX(wxCoord x
) const
2120 return ((wxDC
*)this)->XDEV2LOG(x
);
2123 wxCoord
wxDCBase::DeviceToLogicalY(wxCoord y
) const
2125 return ((wxDC
*)this)->YDEV2LOG(y
);
2128 wxCoord
wxDCBase::DeviceToLogicalXRel(wxCoord x
) const
2130 return ((wxDC
*)this)->XDEV2LOGREL(x
);
2133 wxCoord
wxDCBase::DeviceToLogicalYRel(wxCoord y
) const
2135 return ((wxDC
*)this)->YDEV2LOGREL(y
);
2138 wxCoord
wxDCBase::LogicalToDeviceX(wxCoord x
) const
2140 return ((wxDC
*)this)->XLOG2DEV(x
);
2143 wxCoord
wxDCBase::LogicalToDeviceY(wxCoord y
) const
2145 return ((wxDC
*)this)->YLOG2DEV(y
);
2148 wxCoord
wxDCBase::LogicalToDeviceXRel(wxCoord x
) const
2150 return ((wxDC
*)this)->XLOG2DEVREL(x
);
2153 wxCoord
wxDCBase::LogicalToDeviceYRel(wxCoord y
) const
2155 return ((wxDC
*)this)->YLOG2DEVREL(y
);