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