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