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