]> git.saurik.com Git - wxWidgets.git/blob - src/mac/carbon/dccg.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
simplified ::Show
[wxWidgets.git] / src / mac / carbon / dccg.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: dc.cpp
3 // Purpose: wxDC class
4 // Author: Stefan Csomor
5 // Modified by:
6 // Created: 01/02/97
7 // RCS-ID: $Id$
8 // Copyright: (c) Stefan Csomor
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #include "wx/wxprec.h"
13
14 #include "wx/dc.h"
15
16 #if wxMAC_USE_CORE_GRAPHICS
17
18 #include "wx/app.h"
19 #include "wx/mac/uma.h"
20 #include "wx/dcmemory.h"
21 #include "wx/dcprint.h"
22 #include "wx/region.h"
23 #include "wx/image.h"
24 #include "wx/log.h"
25
26
27 #ifdef __MSL__
28 #if __MSL__ >= 0x6000
29 #include "math.h"
30 // in case our functions were defined outside std, we make it known all the same
31 namespace std { }
32 using namespace std ;
33 #endif
34 #endif
35
36 #include "wx/mac/private.h"
37
38 IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
39
40 //-----------------------------------------------------------------------------
41 // constants
42 //-----------------------------------------------------------------------------
43
44 #if !defined( __DARWIN__ ) || defined(__MWERKS__)
45 #ifndef M_PI
46 const double M_PI = 3.14159265358979 ;
47 #endif
48 #endif
49 const double RAD2DEG = 180.0 / M_PI;
50 const short kEmulatedMode = -1 ;
51 const short kUnsupportedMode = -2 ;
52
53 extern TECObjectRef s_TECNativeCToUnicode ;
54
55 // TODO Update
56 // The text ctrl implementation still needs that for the non hiview implementation
57
58 wxMacWindowClipper::wxMacWindowClipper( const wxWindow* win ) :
59 wxMacPortSaver( (GrafPtr) GetWindowPort((WindowRef) win->MacGetTopLevelWindowRef()) )
60 {
61 m_newPort = (GrafPtr) GetWindowPort((WindowRef) win->MacGetTopLevelWindowRef()) ;
62 m_formerClip = NewRgn() ;
63 m_newClip = NewRgn() ;
64 GetClip( m_formerClip ) ;
65
66 if ( win )
67 {
68 // guard against half constructed objects, this just leads to a empty clip
69 if ( win->GetPeer() )
70 {
71 int x = 0 , y = 0;
72 win->MacWindowToRootWindow( &x,&y ) ;
73 // get area including focus rect
74 CopyRgn( (RgnHandle) ((wxWindow*)win)->MacGetVisibleRegion(true).GetWXHRGN() , m_newClip ) ;
75 if ( !EmptyRgn( m_newClip ) )
76 OffsetRgn( m_newClip , x , y ) ;
77 }
78
79 SetClip( m_newClip ) ;
80 }
81 }
82
83 wxMacWindowClipper::~wxMacWindowClipper()
84 {
85 SetPort( m_newPort ) ;
86 SetClip( m_formerClip ) ;
87 DisposeRgn( m_newClip ) ;
88 DisposeRgn( m_formerClip ) ;
89 }
90
91 wxMacWindowStateSaver::wxMacWindowStateSaver( const wxWindow* win ) :
92 wxMacWindowClipper( win )
93 {
94 // the port is already set at this point
95 m_newPort = (GrafPtr) GetWindowPort((WindowRef) win->MacGetTopLevelWindowRef()) ;
96 GetThemeDrawingState( &m_themeDrawingState ) ;
97 }
98
99 wxMacWindowStateSaver::~wxMacWindowStateSaver()
100 {
101 SetPort( m_newPort ) ;
102 SetThemeDrawingState( m_themeDrawingState , true ) ;
103 }
104
105 // minimal implementation only used for appearance drawing < 10.3
106
107 wxMacPortSetter::wxMacPortSetter( const wxDC* dc ) :
108 m_ph( (GrafPtr) dc->m_macPort )
109 {
110 wxASSERT( dc->Ok() ) ;
111 m_dc = dc ;
112 // dc->MacSetupPort(&m_ph) ;
113 }
114
115 wxMacPortSetter::~wxMacPortSetter()
116 {
117 // m_dc->MacCleanupPort(&m_ph) ;
118 }
119
120 //-----------------------------------------------------------------------------
121 // Local functions
122 //-----------------------------------------------------------------------------
123
124 static inline double dmin(double a, double b) { return a < b ? a : b; }
125 static inline double dmax(double a, double b) { return a > b ? a : b; }
126 static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; }
127
128 //-----------------------------------------------------------------------------
129 // device context implementation
130 //
131 // more and more of the dc functionality should be implemented by calling
132 // the appropricate wxMacCGContext, but we will have to do that step by step
133 // also coordinate conversions should be moved to native matrix ops
134 //-----------------------------------------------------------------------------
135
136 // we always stock two context states, one at entry, to be able to preserve the
137 // state we were called with, the other one after changing to HI Graphics orientation
138 // (this one is used for getting back clippings etc)
139
140 wxMacCGPath::wxMacCGPath()
141 {
142 m_path = CGPathCreateMutable() ;
143 }
144
145 wxMacCGPath::~wxMacCGPath()
146 {
147 CGPathRelease( m_path ) ;
148 }
149
150 // Starts a new subpath at
151 void wxMacCGPath::MoveToPoint( wxCoord x1 , wxCoord y1 )
152 {
153 CGPathMoveToPoint( m_path , NULL , x1 , y1 ) ;
154 }
155
156 void wxMacCGPath::AddLineToPoint( wxCoord x1 , wxCoord y1 )
157 {
158 CGPathAddLineToPoint( m_path , NULL , x1 , y1 ) ;
159 }
160
161 void wxMacCGPath::AddQuadCurveToPoint( wxCoord cx1, wxCoord cy1, wxCoord x1, wxCoord y1 )
162 {
163 CGPathAddQuadCurveToPoint( m_path , NULL , cx1 , cy1 , x1 , y1 );
164 }
165
166 void wxMacCGPath::AddRectangle( wxCoord x, wxCoord y, wxCoord w, wxCoord h )
167 {
168 CGRect cgRect = { { x , y } , { w , h } } ;
169 CGPathAddRect( m_path , NULL , cgRect ) ;
170 }
171
172 void wxMacCGPath::AddCircle( wxCoord x, wxCoord y , wxCoord r )
173 {
174 CGPathAddArc( m_path , NULL , x , y , r , 0.0 , 2 * M_PI , true ) ;
175 }
176
177 // closes the current subpath
178 void wxMacCGPath::CloseSubpath()
179 {
180 CGPathCloseSubpath( m_path ) ;
181 }
182
183 CGPathRef wxMacCGPath::GetPath() const
184 {
185 return m_path ;
186 }
187
188 wxMacCGContext::wxMacCGContext( CGrafPtr port )
189 {
190 m_qdPort = port ;
191 m_cgContext = NULL ;
192 }
193
194 wxMacCGContext::wxMacCGContext( CGContextRef cgcontext )
195 {
196 m_qdPort = NULL ;
197 m_cgContext = cgcontext ;
198 CGContextSaveGState( m_cgContext ) ;
199 CGContextSaveGState( m_cgContext ) ;
200 }
201
202 wxMacCGContext::wxMacCGContext()
203 {
204 m_qdPort = NULL ;
205 m_cgContext = NULL ;
206 }
207
208 wxMacCGContext::~wxMacCGContext()
209 {
210 if ( m_cgContext )
211 {
212 CGContextSynchronize( m_cgContext ) ;
213 CGContextRestoreGState( m_cgContext ) ;
214 CGContextRestoreGState( m_cgContext ) ;
215 }
216
217 if ( m_qdPort )
218 CGContextRelease( m_cgContext ) ;
219 }
220
221
222 void wxMacCGContext::Clip( const wxRegion &region )
223 {
224 // ClipCGContextToRegion ( m_cgContext, &bounds , (RgnHandle) dc->m_macCurrentClipRgn ) ;
225 }
226
227 void wxMacCGContext::StrokePath( const wxGraphicPath *p )
228 {
229 const wxMacCGPath* path = dynamic_cast< const wxMacCGPath*>( p ) ;
230 CGContextAddPath( m_cgContext , path->GetPath() ) ;
231 CGContextStrokePath( m_cgContext ) ;
232 }
233
234 void wxMacCGContext::DrawPath( const wxGraphicPath *p , int fillStyle )
235 {
236 const wxMacCGPath* path = dynamic_cast< const wxMacCGPath*>( p ) ;
237 CGPathDrawingMode mode = m_mode ;
238
239 if ( fillStyle == wxODDEVEN_RULE )
240 {
241 if ( mode == kCGPathFill )
242 mode = kCGPathEOFill ;
243 else if ( mode == kCGPathFillStroke )
244 mode = kCGPathEOFillStroke ;
245 }
246
247 CGContextAddPath( m_cgContext , path->GetPath() ) ;
248 CGContextDrawPath( m_cgContext , mode ) ;
249 }
250
251 void wxMacCGContext::FillPath( const wxGraphicPath *p , const wxColor &fillColor , int fillStyle )
252 {
253 const wxMacCGPath* path = dynamic_cast< const wxMacCGPath*>( p ) ;
254 CGContextSaveGState( m_cgContext ) ;
255
256 RGBColor col = MAC_WXCOLORREF( fillColor.GetPixel() ) ;
257 CGContextSetRGBFillColor( m_cgContext , col.red / 65536.0 , col.green / 65536.0 , col.blue / 65536.0 , 1.0 ) ;
258 CGPathDrawingMode mode = kCGPathFill ;
259
260 if ( fillStyle == wxODDEVEN_RULE )
261 mode = kCGPathEOFill ;
262
263 CGContextBeginPath( m_cgContext ) ;
264 CGContextAddPath( m_cgContext , path->GetPath() ) ;
265 CGContextClosePath( m_cgContext ) ;
266 CGContextDrawPath( m_cgContext , mode ) ;
267
268 CGContextRestoreGState( m_cgContext ) ;
269 }
270
271 wxGraphicPath* wxMacCGContext::CreatePath()
272 {
273 // make sure that we now have a real cgref, before doing
274 // anything with paths
275 CGContextRef cg = GetNativeContext() ;
276 cg = NULL ;
277
278 return new wxMacCGPath() ;
279 }
280
281 // in case we only got a QDPort only create a cgref now
282
283 CGContextRef wxMacCGContext::GetNativeContext()
284 {
285 if ( m_cgContext == NULL )
286 {
287 Rect bounds ;
288 GetPortBounds( (CGrafPtr) m_qdPort , &bounds ) ;
289 OSStatus status = CreateCGContextForPort((CGrafPtr) m_qdPort , &m_cgContext) ;
290 CGContextSaveGState( m_cgContext ) ;
291
292 wxASSERT_MSG( status == noErr , wxT("Cannot nest wxDCs on the same window") ) ;
293
294 CGContextTranslateCTM( m_cgContext , 0 , bounds.bottom - bounds.top ) ;
295 CGContextScaleCTM( m_cgContext , 1 , -1 ) ;
296
297 CGContextSaveGState( m_cgContext ) ;
298 SetPen( m_pen ) ;
299 SetBrush( m_brush ) ;
300 }
301
302 return m_cgContext ;
303 }
304
305 void wxMacCGContext::SetNativeContext( CGContextRef cg )
306 {
307 // we allow either setting or clearing but not replacing
308 wxASSERT( m_cgContext == NULL || cg == NULL ) ;
309
310 if ( cg )
311 CGContextSaveGState( cg ) ;
312 m_cgContext = cg ;
313 }
314
315 #pragma mark -
316
317 // wrapper class for a CGPattern, always allocate on heap, never call destructor
318
319 class wxMacCGPattern
320 {
321 public :
322 wxMacCGPattern() {}
323
324 // is guaranteed to be called only with a non-Null CGContextRef
325 virtual void Render( CGContextRef ctxRef ) = 0 ;
326
327 operator CGPatternRef() const { return m_patternRef ; }
328
329 protected :
330 virtual ~wxMacCGPattern()
331 {
332 // as this is called only when our m_patternRef is been released;
333 // don't release it again
334 }
335
336 static void _Render( void *info, CGContextRef ctxRef )
337 {
338 wxMacCGPattern* self = (wxMacCGPattern*) info ;
339 if ( self && ctxRef )
340 self->Render( ctxRef ) ;
341 }
342
343 static void _Dispose( void *info )
344 {
345 wxMacCGPattern* self = (wxMacCGPattern*) info ;
346 delete self ;
347 }
348
349 CGPatternRef m_patternRef ;
350
351 static const CGPatternCallbacks ms_Callbacks ;
352 } ;
353
354 const CGPatternCallbacks wxMacCGPattern::ms_Callbacks = { 0, &wxMacCGPattern::_Render, &wxMacCGPattern::_Dispose };
355
356 class ImagePattern : public wxMacCGPattern
357 {
358 public :
359 ImagePattern( const wxBitmap* bmp , CGAffineTransform transform )
360 {
361 wxASSERT( bmp && bmp->Ok() ) ;
362
363 Init( (CGImageRef) bmp->CGImageCreate() , transform ) ;
364 }
365
366 // ImagePattern takes ownership of CGImageRef passed in
367 ImagePattern( CGImageRef image , CGAffineTransform transform )
368 {
369 if ( image )
370 CFRetain( image ) ;
371
372 Init( image , transform ) ;
373 }
374
375 virtual void Render( CGContextRef ctxRef )
376 {
377 if (m_image != NULL)
378 HIViewDrawCGImage( ctxRef, &m_imageBounds, m_image );
379 }
380
381 protected :
382 void Init( CGImageRef image , CGAffineTransform transform )
383 {
384 m_image = image ;
385 if ( m_image )
386 {
387 m_imageBounds = CGRectMake( 0.0, 0.0, (float)CGImageGetWidth( m_image ), (float)CGImageGetHeight( m_image ) ) ;
388 m_patternRef = CGPatternCreate( this , m_imageBounds, transform ,
389 m_imageBounds.size.width, m_imageBounds.size.height,
390 kCGPatternTilingNoDistortion, true , &wxMacCGPattern::ms_Callbacks ) ;
391 }
392 }
393
394 ~ImagePattern()
395 {
396 if ( m_image )
397 CGImageRelease( m_image ) ;
398 }
399
400 CGImageRef m_image ;
401 CGRect m_imageBounds ;
402 } ;
403
404 class HatchPattern : public wxMacCGPattern
405 {
406 public :
407 HatchPattern( int hatchstyle , CGAffineTransform transform )
408 {
409 m_hatch = hatchstyle ;
410 m_imageBounds = CGRectMake( 0.0, 0.0, 8.0 , 8.0 ) ;
411 m_patternRef = CGPatternCreate( this , m_imageBounds, transform ,
412 m_imageBounds.size.width, m_imageBounds.size.height,
413 kCGPatternTilingNoDistortion, false , &wxMacCGPattern::ms_Callbacks ) ;
414 }
415
416 void StrokeLineSegments( CGContextRef ctxRef , const CGPoint pts[] , size_t count )
417 {
418 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4
419 if ( UMAGetSystemVersion() >= 0x1040 )
420 {
421 CGContextStrokeLineSegments( ctxRef , pts , count ) ;
422 }
423 else
424 #endif
425 {
426 CGContextBeginPath (ctxRef);
427 for (size_t i = 0; i < count; i += 2)
428 {
429 CGContextMoveToPoint(ctxRef, pts[i].x, pts[i].y);
430 CGContextAddLineToPoint(ctxRef, pts[i+1].x, pts[i+1].y);
431 }
432 CGContextStrokePath(ctxRef);
433 }
434 }
435
436 virtual void Render( CGContextRef ctxRef )
437 {
438 switch ( m_hatch )
439 {
440 case wxBDIAGONAL_HATCH :
441 {
442 CGPoint pts[] =
443 {
444 { 8.0 , 0.0 } , { 0.0 , 8.0 }
445 };
446 StrokeLineSegments( ctxRef , pts , 2 ) ;
447 }
448 break ;
449
450 case wxCROSSDIAG_HATCH :
451 {
452 CGPoint pts[] =
453 {
454 { 0.0 , 0.0 } , { 8.0 , 8.0 } ,
455 { 8.0 , 0.0 } , { 0.0 , 8.0 }
456 };
457 StrokeLineSegments( ctxRef , pts , 4 ) ;
458 }
459 break ;
460
461 case wxFDIAGONAL_HATCH :
462 {
463 CGPoint pts[] =
464 {
465 { 0.0 , 0.0 } , { 8.0 , 8.0 }
466 };
467 StrokeLineSegments( ctxRef , pts , 2 ) ;
468 }
469 break ;
470
471 case wxCROSS_HATCH :
472 {
473 CGPoint pts[] =
474 {
475 { 0.0 , 4.0 } , { 8.0 , 4.0 } ,
476 { 4.0 , 0.0 } , { 4.0 , 8.0 } ,
477 };
478 StrokeLineSegments( ctxRef , pts , 4 ) ;
479 }
480 break ;
481
482 case wxHORIZONTAL_HATCH :
483 {
484 CGPoint pts[] =
485 {
486 { 0.0 , 4.0 } , { 8.0 , 4.0 } ,
487 };
488 StrokeLineSegments( ctxRef , pts , 2 ) ;
489 }
490 break ;
491
492 case wxVERTICAL_HATCH :
493 {
494 CGPoint pts[] =
495 {
496 { 4.0 , 0.0 } , { 4.0 , 8.0 } ,
497 };
498 StrokeLineSegments( ctxRef , pts , 2 ) ;
499 }
500 break ;
501
502 default:
503 break;
504 }
505 }
506
507 protected :
508 ~HatchPattern() {}
509
510 int m_hatch ;
511 CGRect m_imageBounds ;
512 } ;
513
514 void wxMacCGContext::SetPen( const wxPen &pen )
515 {
516 m_pen = pen ;
517 if ( m_cgContext == NULL )
518 return ;
519
520 bool fill = m_brush.GetStyle() != wxTRANSPARENT ;
521 bool stroke = pen.GetStyle() != wxTRANSPARENT ;
522
523 #if 0
524 // we can benchmark performance, should go into a setting later
525 CGContextSetShouldAntialias( m_cgContext , false ) ;
526 #endif
527
528 if ( fill | stroke )
529 {
530 // set up brushes
531 m_mode = kCGPathFill ; // just a default
532
533 if ( stroke )
534 {
535 RGBColor col = MAC_WXCOLORREF( pen.GetColour().GetPixel() ) ;
536 CGContextSetRGBStrokeColor( m_cgContext , col.red / 65536.0 , col.green / 65536.0 , col.blue / 65536.0 , 1.0 ) ;
537
538 // TODO * m_dc->m_scaleX
539 float penWidth = pen.GetWidth();
540 if (penWidth <= 0.0)
541 penWidth = 0.1;
542 CGContextSetLineWidth( m_cgContext , penWidth ) ;
543
544 CGLineCap cap ;
545 switch ( pen.GetCap() )
546 {
547 case wxCAP_ROUND :
548 cap = kCGLineCapRound ;
549 break ;
550
551 case wxCAP_PROJECTING :
552 cap = kCGLineCapSquare ;
553 break ;
554
555 case wxCAP_BUTT :
556 cap = kCGLineCapButt ;
557 break ;
558
559 default :
560 cap = kCGLineCapButt ;
561 break ;
562 }
563
564 CGLineJoin join ;
565 switch ( pen.GetJoin() )
566 {
567 case wxJOIN_BEVEL :
568 join = kCGLineJoinBevel ;
569 break ;
570
571 case wxJOIN_MITER :
572 join = kCGLineJoinMiter ;
573 break ;
574
575 case wxJOIN_ROUND :
576 join = kCGLineJoinRound ;
577 break ;
578
579 default :
580 join = kCGLineJoinMiter ;
581 break;
582 }
583
584 m_mode = kCGPathStroke ;
585 int count = 0 ;
586
587 const float *lengths = NULL ;
588 float *userLengths = NULL ;
589
590 const float dashUnit = penWidth < 1.0 ? 1.0 : penWidth;
591
592 const float dotted[] = { dashUnit , dashUnit + 2.0 };
593 const float short_dashed[] = { 9.0 , 6.0 };
594 const float dashed[] = { 19.0 , 9.0 };
595 const float dotted_dashed[] = { 9.0 , 6.0 , 3.0 , 3.0 };
596
597 switch ( pen.GetStyle() )
598 {
599 case wxSOLID :
600 break ;
601
602 case wxDOT :
603 lengths = dotted ;
604 count = WXSIZEOF(dotted);
605 break ;
606
607 case wxLONG_DASH :
608 lengths = dashed ;
609 count = WXSIZEOF(dashed) ;
610 break ;
611
612 case wxSHORT_DASH :
613 lengths = short_dashed ;
614 count = WXSIZEOF(short_dashed) ;
615 break ;
616
617 case wxDOT_DASH :
618 lengths = dotted_dashed ;
619 count = WXSIZEOF(dotted_dashed);
620 break ;
621
622 case wxUSER_DASH :
623 wxDash *dashes ;
624 count = pen.GetDashes( &dashes ) ;
625 if ((dashes != NULL) && (count > 0))
626 {
627 userLengths = new float[count] ;
628 for( int i = 0 ; i < count ; ++i )
629 {
630 userLengths[i] = dashes[i] * dashUnit ;
631
632 if ( i % 2 == 1 && userLengths[i] < dashUnit + 2.0 )
633 userLengths[i] = dashUnit + 2.0 ;
634 else if ( i % 2 == 0 && userLengths[i] < dashUnit )
635 userLengths[i] = dashUnit ;
636 }
637 }
638 lengths = userLengths ;
639 break ;
640
641 case wxSTIPPLE :
642 {
643 float alphaArray[1] = { 1.0 } ;
644 wxBitmap* bmp = pen.GetStipple() ;
645 if ( bmp && bmp->Ok() )
646 {
647 wxMacCFRefHolder<CGColorSpaceRef> patternSpace( CGColorSpaceCreatePattern( NULL ) ) ;
648 CGContextSetStrokeColorSpace( m_cgContext , patternSpace ) ;
649 wxMacCFRefHolder<CGPatternRef> pattern( *( new ImagePattern( bmp , CGContextGetCTM( m_cgContext ) ) ) );
650 CGContextSetStrokePattern( m_cgContext, pattern , alphaArray ) ;
651 }
652 }
653 break ;
654
655 default :
656 {
657 wxMacCFRefHolder<CGColorSpaceRef> patternSpace( CGColorSpaceCreatePattern( wxMacGetGenericRGBColorSpace() ) ) ;
658 CGContextSetStrokeColorSpace( m_cgContext , patternSpace ) ;
659 wxMacCFRefHolder<CGPatternRef> pattern( *( new HatchPattern( pen.GetStyle() , CGContextGetCTM( m_cgContext ) ) ) );
660
661 RGBColor col = MAC_WXCOLORREF( pen.GetColour().GetPixel() ) ;
662 float colorArray[4] = { col.red / 65536.0 , col.green / 65536.0 , col.blue / 65536.0 , 1.0 } ;
663
664 CGContextSetStrokePattern( m_cgContext, pattern , colorArray ) ;
665 }
666 break ;
667 }
668
669 if ((lengths != NULL) && (count > 0))
670 {
671 CGContextSetLineDash( m_cgContext , 0 , lengths , count ) ;
672 // force the line cap, otherwise we get artifacts (overlaps) and just solid lines
673 cap = kCGLineCapButt ;
674 }
675 else
676 {
677 CGContextSetLineDash( m_cgContext , 0 , NULL , 0 ) ;
678 }
679
680 CGContextSetLineCap( m_cgContext , cap ) ;
681 CGContextSetLineJoin( m_cgContext , join ) ;
682
683 delete[] userLengths ;
684 }
685
686 if ( fill && stroke )
687 m_mode = kCGPathFillStroke ;
688 }
689 }
690
691 void wxMacCGContext::SetBrush( const wxBrush &brush )
692 {
693 m_brush = brush ;
694 if ( m_cgContext == NULL )
695 return ;
696
697 bool fill = brush.GetStyle() != wxTRANSPARENT ;
698 bool stroke = m_pen.GetStyle() != wxTRANSPARENT ;
699
700 #if 0
701 // we can benchmark performance, should go into a setting later
702 CGContextSetShouldAntialias( m_cgContext , false ) ;
703 #endif
704
705 if ( fill | stroke )
706 {
707 // setup brushes
708 m_mode = kCGPathFill ; // just a default
709
710 if ( fill )
711 {
712 if ( brush.GetStyle() == wxSOLID )
713 {
714 RGBColor col = MAC_WXCOLORREF( brush.GetColour().GetPixel() ) ;
715 CGContextSetRGBFillColor( m_cgContext , col.red / 65536.0 , col.green / 65536.0 , col.blue / 65536.0 , 1.0 ) ;
716 }
717 else if ( brush.IsHatch() )
718 {
719 wxMacCFRefHolder<CGColorSpaceRef> patternSpace( CGColorSpaceCreatePattern( wxMacGetGenericRGBColorSpace() ) ) ;
720 CGContextSetFillColorSpace( m_cgContext , patternSpace ) ;
721 wxMacCFRefHolder<CGPatternRef> pattern( *( new HatchPattern( brush.GetStyle() , CGContextGetCTM( m_cgContext ) ) ) );
722
723 RGBColor col = MAC_WXCOLORREF( brush.GetColour().GetPixel() ) ;
724 float colorArray[4] = { col.red / 65536.0 , col.green / 65536.0 , col.blue / 65536.0 , 1.0 } ;
725
726 CGContextSetFillPattern( m_cgContext, pattern , colorArray ) ;
727 }
728 else
729 {
730 // now brush is a bitmap
731 float alphaArray[1] = { 1.0 } ;
732 wxBitmap* bmp = brush.GetStipple() ;
733 if ( bmp && bmp->Ok() )
734 {
735 wxMacCFRefHolder<CGColorSpaceRef> patternSpace( CGColorSpaceCreatePattern( NULL ) ) ;
736 CGContextSetFillColorSpace( m_cgContext , patternSpace ) ;
737 wxMacCFRefHolder<CGPatternRef> pattern( *( new ImagePattern( bmp , CGContextGetCTM( m_cgContext ) ) ) );
738 CGContextSetFillPattern( m_cgContext, pattern , alphaArray ) ;
739 }
740 }
741
742 m_mode = kCGPathFill ;
743 }
744
745 if ( fill && stroke )
746 m_mode = kCGPathFillStroke ;
747 else if ( stroke )
748 m_mode = kCGPathStroke ;
749 }
750 }
751
752 void AddEllipticArcToPath(CGContextRef c, CGPoint center, float a, float b, float fromDegree , float toDegree )
753 {
754 CGContextSaveGState(c);
755 CGContextTranslateCTM(c, center.x, center.y);
756 CGContextScaleCTM(c, a, b);
757 CGContextMoveToPoint(c, 1, 0);
758 CGContextAddArc(c, 0, 0, 1, DegToRad(fromDegree), DegToRad(toDegree), 0);
759 CGContextClosePath(c);
760 CGContextRestoreGState(c);
761 }
762
763 void AddRoundedRectToPath(CGContextRef c, CGRect rect, float ovalWidth,
764 float ovalHeight)
765 {
766 float fw, fh;
767 if (ovalWidth == 0 || ovalHeight == 0)
768 {
769 CGContextAddRect(c, rect);
770 return;
771 }
772
773 CGContextSaveGState(c);
774 CGContextTranslateCTM(c, CGRectGetMinX(rect), CGRectGetMinY(rect));
775 CGContextScaleCTM(c, ovalWidth, ovalHeight);
776 fw = CGRectGetWidth(rect) / ovalWidth;
777 fh = CGRectGetHeight(rect) / ovalHeight;
778 CGContextMoveToPoint(c, fw, fh/2);
779 CGContextAddArcToPoint(c, fw, fh, fw/2, fh, 1);
780 CGContextAddArcToPoint(c, 0, fh, 0, fh/2, 1);
781 CGContextAddArcToPoint(c, 0, 0, fw/2, 0, 1);
782 CGContextAddArcToPoint(c, fw, 0, fw, fh/2, 1);
783 CGContextClosePath(c);
784 CGContextRestoreGState(c);
785 }
786
787 wxDC::wxDC()
788 {
789 m_ok = false;
790 m_colour = true;
791 m_mm_to_pix_x = mm2pt;
792 m_mm_to_pix_y = mm2pt;
793
794 m_externalDeviceOriginX = 0;
795 m_externalDeviceOriginY = 0;
796 m_logicalScaleX = 1.0;
797 m_logicalScaleY = 1.0;
798 m_userScaleX = 1.0;
799 m_userScaleY = 1.0;
800 m_scaleX = 1.0;
801 m_scaleY = 1.0;
802 m_needComputeScaleX = false;
803 m_needComputeScaleY = false;
804
805 m_ok = false ;
806 m_macPort = 0 ;
807 m_macLocalOrigin.x = m_macLocalOrigin.y = 0 ;
808
809 m_pen = *wxBLACK_PEN;
810 m_font = *wxNORMAL_FONT;
811 m_brush = *wxWHITE_BRUSH;
812
813 m_macATSUIStyle = NULL ;
814 m_graphicContext = NULL ;
815 }
816
817 wxDC::~wxDC()
818 {
819 if ( m_macATSUIStyle )
820 {
821 ::ATSUDisposeStyle((ATSUStyle)m_macATSUIStyle);
822 m_macATSUIStyle = NULL ;
823 }
824
825 delete m_graphicContext ;
826 }
827
828 void wxDC::DoDrawBitmap( const wxBitmap &bmp, wxCoord x, wxCoord y, bool useMask )
829 {
830 wxCHECK_RET( Ok(), wxT("invalid window dc") );
831 wxCHECK_RET( bmp.Ok(), wxT("invalid bitmap") );
832
833 wxCoord xx = XLOG2DEVMAC(x);
834 wxCoord yy = YLOG2DEVMAC(y);
835 wxCoord w = bmp.GetWidth();
836 wxCoord h = bmp.GetHeight();
837 wxCoord ww = XLOG2DEVREL(w);
838 wxCoord hh = YLOG2DEVREL(h);
839
840 CGContextRef cg = ((wxMacCGContext*)(m_graphicContext))->GetNativeContext() ;
841 CGImageRef image = (CGImageRef)( bmp.CGImageCreate() ) ;
842 HIRect r = CGRectMake( xx , yy , ww , hh ) ;
843 HIViewDrawCGImage( cg , &r , image ) ;
844 CGImageRelease( image ) ;
845 }
846
847 void wxDC::DoDrawIcon( const wxIcon &icon, wxCoord x, wxCoord y )
848 {
849 wxCHECK_RET(Ok(), wxT("Invalid dc wxDC::DoDrawIcon"));
850 wxCHECK_RET(icon.Ok(), wxT("Invalid icon wxDC::DoDrawIcon"));
851
852 wxCoord xx = XLOG2DEVMAC(x);
853 wxCoord yy = YLOG2DEVMAC(y);
854 wxCoord w = icon.GetWidth();
855 wxCoord h = icon.GetHeight();
856 wxCoord ww = XLOG2DEVREL(w);
857 wxCoord hh = YLOG2DEVREL(h);
858
859 CGContextRef cg = ((wxMacCGContext*)(m_graphicContext))->GetNativeContext() ;
860 CGRect r = CGRectMake( 00 , 00 , ww , hh ) ;
861 CGContextSaveGState(cg);
862 CGContextTranslateCTM( cg, xx , yy + hh );
863 CGContextScaleCTM(cg, 1, -1);
864 PlotIconRefInContext( cg , &r , kAlignNone , kTransformNone ,
865 NULL , kPlotIconRefNormalFlags , MAC_WXHICON( icon.GetHICON() ) ) ;
866 CGContextRestoreGState( cg ) ;
867 }
868
869 void wxDC::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
870 {
871 wxCHECK_RET(Ok(), wxT("wxDC::DoSetClippingRegion Invalid DC"));
872
873 wxCoord xx, yy, ww, hh;
874 xx = XLOG2DEVMAC(x);
875 yy = YLOG2DEVMAC(y);
876 ww = XLOG2DEVREL(width);
877 hh = YLOG2DEVREL(height);
878
879 CGContextRef cgContext = ((wxMacCGContext*)(m_graphicContext))->GetNativeContext() ;
880 CGRect clipRect = CGRectMake( xx ,yy , ww, hh ) ;
881 CGContextClipToRect( cgContext , clipRect ) ;
882
883 // SetRectRgn( (RgnHandle) m_macCurrentClipRgn , xx , yy , xx + ww , yy + hh ) ;
884 // SectRgn( (RgnHandle) m_macCurrentClipRgn , (RgnHandle) m_macBoundaryClipRgn , (RgnHandle) m_macCurrentClipRgn ) ;
885
886 if ( m_clipping )
887 {
888 m_clipX1 = wxMax( m_clipX1 , xx );
889 m_clipY1 = wxMax( m_clipY1 , yy );
890 m_clipX2 = wxMin( m_clipX2, (xx + ww));
891 m_clipY2 = wxMin( m_clipY2, (yy + hh));
892 }
893 else
894 {
895 m_clipping = true;
896 m_clipX1 = xx;
897 m_clipY1 = yy;
898 m_clipX2 = xx + ww;
899 m_clipY2 = yy + hh;
900 }
901
902 // TODO as soon as we don't reset the context for each operation anymore
903 // we have to update the context as well
904 }
905
906 void wxDC::DoSetClippingRegionAsRegion( const wxRegion &region )
907 {
908 wxCHECK_RET( Ok(), wxT("invalid window dc") ) ;
909 if (region.Empty())
910 {
911 DestroyClippingRegion();
912 return;
913 }
914
915 wxCoord x, y, w, h;
916 region.GetBox( x, y, w, h );
917 wxCoord xx, yy, ww, hh;
918 xx = XLOG2DEVMAC(x);
919 yy = YLOG2DEVMAC(y);
920 ww = XLOG2DEVREL(w);
921 hh = YLOG2DEVREL(h);
922
923 // if we have a scaling that we cannot map onto native regions
924 // we must use the box
925 if ( ww != w || hh != h )
926 {
927 wxDC::DoSetClippingRegion( x, y, w, h );
928 }
929 else
930 {
931 #if 0
932 CopyRgn( (RgnHandle) region.GetWXHRGN() , (RgnHandle) m_macCurrentClipRgn ) ;
933 if ( xx != x || yy != y )
934 OffsetRgn( (RgnHandle) m_macCurrentClipRgn , xx - x , yy - y ) ;
935 SectRgn( (RgnHandle) m_macCurrentClipRgn , (RgnHandle) m_macBoundaryClipRgn , (RgnHandle) m_macCurrentClipRgn ) ;
936 #endif
937
938 if ( m_clipping )
939 {
940 m_clipX1 = wxMax( m_clipX1 , xx );
941 m_clipY1 = wxMax( m_clipY1 , yy );
942 m_clipX2 = wxMin( m_clipX2, (xx + ww));
943 m_clipY2 = wxMin( m_clipY2, (yy + hh));
944 }
945 else
946 {
947 m_clipping = true;
948 m_clipX1 = xx;
949 m_clipY1 = yy;
950 m_clipX2 = xx + ww;
951 m_clipY2 = yy + hh;
952 }
953 }
954 }
955
956 void wxDC::DestroyClippingRegion()
957 {
958 // CopyRgn( (RgnHandle) m_macBoundaryClipRgn , (RgnHandle) m_macCurrentClipRgn ) ;
959 CGContextRef cgContext = ((wxMacCGContext*)(m_graphicContext))->GetNativeContext() ;
960 CGContextRestoreGState( cgContext );
961 CGContextSaveGState( cgContext );
962 m_graphicContext->SetPen( m_pen ) ;
963 m_graphicContext->SetBrush( m_brush ) ;
964 m_clipping = false;
965 }
966
967 void wxDC::DoGetSizeMM( int* width, int* height ) const
968 {
969 int w = 0, h = 0;
970
971 GetSize( &w, &h );
972 if (width)
973 *width = long( double(w) / (m_scaleX * m_mm_to_pix_x) );
974 if (height)
975 *height = long( double(h) / (m_scaleY * m_mm_to_pix_y) );
976 }
977
978 void wxDC::SetTextForeground( const wxColour &col )
979 {
980 wxCHECK_RET(Ok(), wxT("Invalid DC"));
981
982 if ( col != m_textForegroundColour )
983 {
984 m_textForegroundColour = col;
985 MacInstallFont() ;
986 }
987 }
988
989 void wxDC::SetTextBackground( const wxColour &col )
990 {
991 wxCHECK_RET(Ok(), wxT("Invalid DC"));
992
993 m_textBackgroundColour = col;
994 }
995
996 void wxDC::SetMapMode( int mode )
997 {
998 switch (mode)
999 {
1000 case wxMM_TWIPS:
1001 SetLogicalScale( twips2mm * m_mm_to_pix_x, twips2mm * m_mm_to_pix_y );
1002 break;
1003
1004 case wxMM_POINTS:
1005 SetLogicalScale( pt2mm * m_mm_to_pix_x, pt2mm * m_mm_to_pix_y );
1006 break;
1007
1008 case wxMM_METRIC:
1009 SetLogicalScale( m_mm_to_pix_x, m_mm_to_pix_y );
1010 break;
1011
1012 case wxMM_LOMETRIC:
1013 SetLogicalScale( m_mm_to_pix_x / 10.0, m_mm_to_pix_y / 10.0 );
1014 break;
1015
1016 case wxMM_TEXT:
1017 default:
1018 SetLogicalScale( 1.0, 1.0 );
1019 break;
1020 }
1021
1022 if (mode != wxMM_TEXT)
1023 {
1024 m_needComputeScaleX =
1025 m_needComputeScaleY = true;
1026 }
1027 }
1028
1029 void wxDC::SetUserScale( double x, double y )
1030 {
1031 // allow negative ? -> no
1032 m_userScaleX = x;
1033 m_userScaleY = y;
1034 ComputeScaleAndOrigin();
1035 }
1036
1037 void wxDC::SetLogicalScale( double x, double y )
1038 {
1039 // allow negative ?
1040 m_logicalScaleX = x;
1041 m_logicalScaleY = y;
1042 ComputeScaleAndOrigin();
1043 }
1044
1045 void wxDC::SetLogicalOrigin( wxCoord x, wxCoord y )
1046 {
1047 m_logicalOriginX = x * m_signX; // is this still correct ?
1048 m_logicalOriginY = y * m_signY;
1049 ComputeScaleAndOrigin();
1050 }
1051
1052 void wxDC::SetDeviceOrigin( wxCoord x, wxCoord y )
1053 {
1054 m_externalDeviceOriginX = x;
1055 m_externalDeviceOriginY = y;
1056 ComputeScaleAndOrigin();
1057 }
1058
1059 void wxDC::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
1060 {
1061 m_signX = (xLeftRight ? 1 : -1);
1062 m_signY = (yBottomUp ? -1 : 1);
1063 ComputeScaleAndOrigin();
1064 }
1065
1066 wxSize wxDC::GetPPI() const
1067 {
1068 return wxSize(72, 72);
1069 }
1070
1071 int wxDC::GetDepth() const
1072 {
1073 return 32 ;
1074 }
1075
1076 void wxDC::ComputeScaleAndOrigin()
1077 {
1078 // CMB: copy scale to see if it changes
1079 double origScaleX = m_scaleX;
1080 double origScaleY = m_scaleY;
1081 m_scaleX = m_logicalScaleX * m_userScaleX;
1082 m_scaleY = m_logicalScaleY * m_userScaleY;
1083 m_deviceOriginX = m_externalDeviceOriginX;
1084 m_deviceOriginY = m_externalDeviceOriginY;
1085
1086 // CMB: if scale has changed call SetPen to recalulate the line width
1087 if (m_scaleX != origScaleX || m_scaleY != origScaleY)
1088 {
1089 // this is a bit artificial, but we need to force wxDC to think
1090 // the pen has changed
1091 wxPen pen( GetPen() );
1092
1093 m_pen = wxNullPen;
1094 SetPen(pen);
1095 }
1096 }
1097
1098 void wxDC::SetPalette( const wxPalette& palette )
1099 {
1100 }
1101
1102 void wxDC::SetBackgroundMode( int mode )
1103 {
1104 m_backgroundMode = mode ;
1105 }
1106
1107 void wxDC::SetFont( const wxFont &font )
1108 {
1109 m_font = font;
1110 MacInstallFont() ;
1111 }
1112
1113 void wxDC::SetPen( const wxPen &pen )
1114 {
1115 if ( m_pen == pen )
1116 return ;
1117
1118 m_pen = pen;
1119 if ( m_graphicContext )
1120 {
1121 if ( m_pen.GetStyle() == wxSOLID || m_pen.GetStyle() == wxTRANSPARENT )
1122 {
1123 m_graphicContext->SetPen( m_pen ) ;
1124 }
1125 else
1126 {
1127 // we have to compensate for moved device origins etc. otherwise patterned pens are standing still
1128 // eg when using a wxScrollWindow and scrolling around
1129 CGContextRef cgContext = ((wxMacCGContext*)(m_graphicContext))->GetNativeContext() ;
1130 int origX = XLOG2DEVMAC(0) ;
1131 int origY = YLOG2DEVMAC(0) ;
1132 CGContextTranslateCTM (cgContext,origX,origY);
1133 m_graphicContext->SetPen( m_pen ) ;
1134 CGContextTranslateCTM (cgContext,-origX,-origY);
1135 }
1136 }
1137 }
1138
1139 void wxDC::SetBrush( const wxBrush &brush )
1140 {
1141 if (m_brush == brush)
1142 return;
1143
1144 m_brush = brush;
1145 if ( m_graphicContext )
1146 {
1147 if ( brush.GetStyle() == wxSOLID || brush.GetStyle() == wxTRANSPARENT )
1148 {
1149 m_graphicContext->SetBrush( m_brush ) ;
1150 }
1151 else
1152 {
1153 // we have to compensate for moved device origins etc. otherwise patterned brushes are standing still
1154 // eg when using a wxScrollWindow and scrolling around
1155 CGContextRef cgContext = ((wxMacCGContext*)(m_graphicContext))->GetNativeContext() ;
1156 int origX = XLOG2DEVMAC(0) ;
1157 int origY = YLOG2DEVMAC(0) ;
1158 CGContextTranslateCTM (cgContext,origX,origY);
1159 m_graphicContext->SetBrush( m_brush ) ;
1160 CGContextTranslateCTM (cgContext,-origX,-origY);
1161 }
1162 }
1163 }
1164
1165 void wxDC::SetBackground( const wxBrush &brush )
1166 {
1167 if (m_backgroundBrush == brush)
1168 return;
1169
1170 m_backgroundBrush = brush;
1171 if (!m_backgroundBrush.Ok())
1172 return;
1173 }
1174
1175 void wxDC::SetLogicalFunction( int function )
1176 {
1177 if (m_logicalFunction == function)
1178 return;
1179
1180 m_logicalFunction = function ;
1181 }
1182
1183 extern bool wxDoFloodFill(wxDC *dc, wxCoord x, wxCoord y,
1184 const wxColour & col, int style);
1185
1186 bool wxDC::DoFloodFill(wxCoord x, wxCoord y,
1187 const wxColour& col, int style)
1188 {
1189 return wxDoFloodFill(this, x, y, col, style);
1190 }
1191
1192 bool wxDC::DoGetPixel( wxCoord x, wxCoord y, wxColour *col ) const
1193 {
1194 wxCHECK_MSG( Ok(), false, wxT("wxDC::DoGetPixel Invalid DC") );
1195 wxCHECK_MSG( Ok(), false, wxT("wxDC::DoGetPixel Invalid DC") );
1196
1197 wxMacPortSaver helper((CGrafPtr)m_macPort) ;
1198 RGBColor colour;
1199
1200 // NB: GetCPixel is a deprecated QD call, and a slow one at that
1201 GetCPixel(
1202 XLOG2DEVMAC(x) + m_macLocalOriginInPort.x - m_macLocalOrigin.x,
1203 YLOG2DEVMAC(y) + m_macLocalOriginInPort.y - m_macLocalOrigin.y, &colour );
1204
1205 // convert from Mac colour to wx
1206 col->Set( colour.red >> 8, colour.green >> 8, colour.blue >> 8 );
1207
1208 return true ;
1209 }
1210
1211 void wxDC::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 )
1212 {
1213 wxCHECK_RET(Ok(), wxT("Invalid DC"));
1214
1215 if ( m_logicalFunction != wxCOPY )
1216 return ;
1217
1218 wxCoord xx1 = XLOG2DEVMAC(x1) ;
1219 wxCoord yy1 = YLOG2DEVMAC(y1) ;
1220 wxCoord xx2 = XLOG2DEVMAC(x2) ;
1221 wxCoord yy2 = YLOG2DEVMAC(y2) ;
1222
1223 wxGraphicPath* path = m_graphicContext->CreatePath() ;
1224 path->MoveToPoint( xx1 , yy1 ) ;
1225 path->AddLineToPoint( xx2 , yy2 ) ;
1226 path->CloseSubpath() ;
1227 m_graphicContext->StrokePath( path ) ;
1228 delete path ;
1229
1230 CalcBoundingBox(x1, y1);
1231 CalcBoundingBox(x2, y2);
1232 }
1233
1234 void wxDC::DoCrossHair( wxCoord x, wxCoord y )
1235 {
1236 wxCHECK_RET( Ok(), wxT("wxDC::DoCrossHair Invalid window dc") );
1237
1238 if ( m_logicalFunction != wxCOPY )
1239 return ;
1240
1241 int w = 0;
1242 int h = 0;
1243 GetSize( &w, &h );
1244 wxCoord xx = XLOG2DEVMAC(x);
1245 wxCoord yy = YLOG2DEVMAC(y);
1246
1247 wxGraphicPath* path = m_graphicContext->CreatePath() ;
1248 path->MoveToPoint( XLOG2DEVMAC(0), yy ) ;
1249 path->AddLineToPoint( XLOG2DEVMAC(w), yy ) ;
1250 path->CloseSubpath() ;
1251 path->MoveToPoint( xx, YLOG2DEVMAC(0) ) ;
1252 path->AddLineToPoint( xx, YLOG2DEVMAC(h) ) ;
1253 path->CloseSubpath() ;
1254 m_graphicContext->StrokePath( path ) ;
1255 delete path ;
1256
1257 CalcBoundingBox(x, y);
1258 CalcBoundingBox(x+w, y+h);
1259 }
1260
1261 void wxDC::DoDrawArc( wxCoord x1, wxCoord y1,
1262 wxCoord x2, wxCoord y2,
1263 wxCoord xc, wxCoord yc )
1264 {
1265 wxCHECK_RET(Ok(), wxT("wxDC::DoDrawArc Invalid DC"));
1266
1267 if ( m_logicalFunction != wxCOPY )
1268 return ;
1269
1270 wxCoord xx1 = XLOG2DEVMAC(x1);
1271 wxCoord yy1 = YLOG2DEVMAC(y1);
1272 wxCoord xx2 = XLOG2DEVMAC(x2);
1273 wxCoord yy2 = YLOG2DEVMAC(y2);
1274 wxCoord xxc = XLOG2DEVMAC(xc);
1275 wxCoord yyc = YLOG2DEVMAC(yc);
1276
1277 double dx = xx1 - xxc;
1278 double dy = yy1 - yyc;
1279 double radius = sqrt((double)(dx*dx+dy*dy));
1280 wxCoord rad = (wxCoord)radius;
1281 double sa, ea;
1282 if (xx1 == xx2 && yy1 == yy2)
1283 {
1284 sa = 0.0;
1285 ea = 360.0;
1286 }
1287 else if (radius == 0.0)
1288 {
1289 sa = ea = 0.0;
1290 }
1291 else
1292 {
1293 sa = (xx1 - xxc == 0) ?
1294 (yy1 - yyc < 0) ? 90.0 : -90.0 :
1295 -atan2(double(yy1-yyc), double(xx1-xxc)) * RAD2DEG;
1296 ea = (xx2 - xxc == 0) ?
1297 (yy2 - yyc < 0) ? 90.0 : -90.0 :
1298 -atan2(double(yy2-yyc), double(xx2-xxc)) * RAD2DEG;
1299 }
1300
1301 bool fill = m_brush.GetStyle() != wxTRANSPARENT ;
1302 wxMacCGContext* mctx = ((wxMacCGContext*) m_graphicContext) ;
1303 CGContextRef ctx = mctx->GetNativeContext() ;
1304 CGContextSaveGState( ctx ) ;
1305 CGContextTranslateCTM( ctx, xxc , yyc );
1306 CGContextScaleCTM( ctx , 1 , -1 ) ;
1307 if ( fill )
1308 CGContextMoveToPoint( ctx , 0 , 0 ) ;
1309 CGContextAddArc( ctx, 0, 0 , rad , DegToRad(sa), DegToRad(ea), 0);
1310 if ( fill )
1311 CGContextAddLineToPoint( ctx , 0 , 0 ) ;
1312 CGContextRestoreGState( ctx ) ;
1313 CGContextDrawPath( ctx , mctx->GetDrawingMode() ) ;
1314 }
1315
1316 void wxDC::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord w, wxCoord h,
1317 double sa, double ea )
1318 {
1319 wxCHECK_RET(Ok(), wxT("wxDC::DoDrawEllepticArc Invalid DC"));
1320
1321 if ( m_logicalFunction != wxCOPY )
1322 return ;
1323
1324 wxCoord xx = XLOG2DEVMAC(x);
1325 wxCoord yy = YLOG2DEVMAC(y);
1326 wxCoord ww = m_signX * XLOG2DEVREL(w);
1327 wxCoord hh = m_signY * YLOG2DEVREL(h);
1328
1329 // handle -ve width and/or height
1330 if (ww < 0)
1331 {
1332 ww = -ww;
1333 xx = xx - ww;
1334 }
1335 if (hh < 0)
1336 {
1337 hh = -hh;
1338 yy = yy - hh;
1339 }
1340
1341 bool fill = m_brush.GetStyle() != wxTRANSPARENT ;
1342
1343 wxMacCGContext* mctx = ((wxMacCGContext*) m_graphicContext) ;
1344 CGContextRef ctx = mctx->GetNativeContext() ;
1345
1346 CGContextSaveGState( ctx ) ;
1347 CGContextTranslateCTM( ctx, xx + ww / 2, yy + hh / 2);
1348 CGContextScaleCTM( ctx , 1 * ww / 2 , -1 * hh / 2 ) ;
1349 if ( fill )
1350 CGContextMoveToPoint( ctx , 0 , 0 ) ;
1351 CGContextAddArc( ctx, 0, 0, 1, DegToRad(sa), DegToRad(ea), 0);
1352 if ( fill )
1353 CGContextAddLineToPoint( ctx , 0 , 0 ) ;
1354 CGContextRestoreGState( ctx ) ;
1355 CGContextDrawPath( ctx , mctx->GetDrawingMode() ) ;
1356 }
1357
1358 void wxDC::DoDrawPoint( wxCoord x, wxCoord y )
1359 {
1360 wxCHECK_RET(Ok(), wxT("Invalid DC"));
1361
1362 DoDrawLine( x , y , x + 1 , y + 1 ) ;
1363 }
1364
1365 void wxDC::DoDrawLines(int n, wxPoint points[],
1366 wxCoord xoffset, wxCoord yoffset)
1367 {
1368 wxCHECK_RET(Ok(), wxT("Invalid DC"));
1369
1370 if ( m_logicalFunction != wxCOPY )
1371 return ;
1372
1373 wxCoord x1, x2 , y1 , y2 ;
1374 x1 = XLOG2DEVMAC(points[0].x + xoffset);
1375 y1 = YLOG2DEVMAC(points[0].y + yoffset);
1376 wxGraphicPath* path = m_graphicContext->CreatePath() ;
1377 path->MoveToPoint( x1 , y1 ) ;
1378 for (int i = 1; i < n; i++)
1379 {
1380 x2 = XLOG2DEVMAC(points[i].x + xoffset);
1381 y2 = YLOG2DEVMAC(points[i].y + yoffset);
1382
1383 path->AddLineToPoint( x2 , y2 ) ;
1384 }
1385
1386 m_graphicContext->StrokePath( path ) ;
1387 delete path ;
1388 }
1389
1390 #if wxUSE_SPLINES
1391 void wxDC::DoDrawSpline(wxList *points)
1392 {
1393 wxCHECK_RET(Ok(), wxT("Invalid DC"));
1394
1395 if ( m_logicalFunction != wxCOPY )
1396 return ;
1397
1398 wxGraphicPath* path = m_graphicContext->CreatePath() ;
1399
1400 wxList::compatibility_iterator node = points->GetFirst();
1401 if (node == wxList::compatibility_iterator())
1402 // empty list
1403 return;
1404
1405 wxPoint *p = (wxPoint *)node->GetData();
1406
1407 wxCoord x1 = p->x;
1408 wxCoord y1 = p->y;
1409
1410 node = node->GetNext();
1411 p = (wxPoint *)node->GetData();
1412
1413 wxCoord x2 = p->x;
1414 wxCoord y2 = p->y;
1415 wxCoord cx1 = ( x1 + x2 ) / 2;
1416 wxCoord cy1 = ( y1 + y2 ) / 2;
1417
1418 path->MoveToPoint( XLOG2DEVMAC( x1 ) , XLOG2DEVMAC( y1 ) ) ;
1419 path->AddLineToPoint( XLOG2DEVMAC( cx1 ) , XLOG2DEVMAC( cy1 ) ) ;
1420
1421 #if !wxUSE_STL
1422 while ((node = node->GetNext()) != NULL)
1423 #else
1424 while ((node = node->GetNext()))
1425 #endif // !wxUSE_STL
1426 {
1427 p = (wxPoint *)node->GetData();
1428 x1 = x2;
1429 y1 = y2;
1430 x2 = p->x;
1431 y2 = p->y;
1432 wxCoord cx4 = (x1 + x2) / 2;
1433 wxCoord cy4 = (y1 + y2) / 2;
1434
1435 path->AddQuadCurveToPoint( XLOG2DEVMAC( x1 ) , XLOG2DEVMAC( y1 ) ,
1436 XLOG2DEVMAC( cx4 ) , XLOG2DEVMAC( cy4 ) ) ;
1437
1438 cx1 = cx4;
1439 cy1 = cy4;
1440 }
1441
1442 path->AddLineToPoint( XLOG2DEVMAC( x2 ) , XLOG2DEVMAC( y2 ) ) ;
1443
1444 m_graphicContext->StrokePath( path ) ;
1445 delete path ;
1446 }
1447 #endif
1448
1449 void wxDC::DoDrawPolygon( int n, wxPoint points[],
1450 wxCoord xoffset, wxCoord yoffset,
1451 int fillStyle )
1452 {
1453 wxCHECK_RET(Ok(), wxT("Invalid DC"));
1454
1455 if ( n <= 0 || (m_brush.GetStyle() == wxTRANSPARENT && m_pen.GetStyle() == wxTRANSPARENT ) )
1456 return ;
1457 if ( m_logicalFunction != wxCOPY )
1458 return ;
1459
1460 wxCoord x1, x2 , y1 , y2 ;
1461 x2 = x1 = XLOG2DEVMAC(points[0].x + xoffset);
1462 y2 = y1 = YLOG2DEVMAC(points[0].y + yoffset);
1463
1464 wxGraphicPath* path = m_graphicContext->CreatePath() ;
1465 path->MoveToPoint( x1 , y1 ) ;
1466 for (int i = 1; i < n; i++)
1467 {
1468 x2 = XLOG2DEVMAC(points[i].x + xoffset);
1469 y2 = YLOG2DEVMAC(points[i].y + yoffset);
1470
1471 path->AddLineToPoint( x2 , y2 ) ;
1472 }
1473
1474 if ( x1 != x2 || y1 != y2 )
1475 path->AddLineToPoint( x1,y1 ) ;
1476
1477 path->CloseSubpath() ;
1478 m_graphicContext->DrawPath( path , fillStyle ) ;
1479
1480 delete path ;
1481 }
1482
1483 void wxDC::DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
1484 {
1485 wxCHECK_RET(Ok(), wxT("Invalid DC"));
1486
1487 if ( m_logicalFunction != wxCOPY )
1488 return ;
1489
1490 wxCoord xx = XLOG2DEVMAC(x);
1491 wxCoord yy = YLOG2DEVMAC(y);
1492 wxCoord ww = m_signX * XLOG2DEVREL(width);
1493 wxCoord hh = m_signY * YLOG2DEVREL(height);
1494
1495 // CMB: draw nothing if transformed w or h is 0
1496 if (ww == 0 || hh == 0)
1497 return;
1498
1499 // CMB: handle -ve width and/or height
1500 if (ww < 0)
1501 {
1502 ww = -ww;
1503 xx = xx - ww;
1504 }
1505 if (hh < 0)
1506 {
1507 hh = -hh;
1508 yy = yy - hh;
1509 }
1510
1511 wxGraphicPath* path = m_graphicContext->CreatePath() ;
1512 path->AddRectangle( xx , yy , ww , hh ) ;
1513 m_graphicContext->DrawPath( path ) ;
1514 delete path ;
1515 }
1516
1517 void wxDC::DoDrawRoundedRectangle(wxCoord x, wxCoord y,
1518 wxCoord width, wxCoord height,
1519 double radius)
1520 {
1521 wxCHECK_RET(Ok(), wxT("Invalid DC"));
1522
1523 if ( m_logicalFunction != wxCOPY )
1524 return ;
1525
1526 if (radius < 0.0)
1527 radius = - radius * ((width < height) ? width : height);
1528 wxCoord xx = XLOG2DEVMAC(x);
1529 wxCoord yy = YLOG2DEVMAC(y);
1530 wxCoord ww = m_signX * XLOG2DEVREL(width);
1531 wxCoord hh = m_signY * YLOG2DEVREL(height);
1532
1533 // CMB: draw nothing if transformed w or h is 0
1534 if (ww == 0 || hh == 0)
1535 return;
1536
1537 // CMB: handle -ve width and/or height
1538 if (ww < 0)
1539 {
1540 ww = -ww;
1541 xx = xx - ww;
1542 }
1543 if (hh < 0)
1544 {
1545 hh = -hh;
1546 yy = yy - hh;
1547 }
1548
1549 wxMacCGContext* mctx = ((wxMacCGContext*) m_graphicContext) ;
1550 CGContextRef ctx = mctx->GetNativeContext() ;
1551 AddRoundedRectToPath( ctx , CGRectMake( xx , yy , ww , hh ) , 16 ,16 ) ;
1552 CGContextDrawPath( ctx , mctx->GetDrawingMode() ) ;
1553 }
1554
1555 void wxDC::DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
1556 {
1557 wxCHECK_RET(Ok(), wxT("Invalid DC"));
1558
1559 if ( m_logicalFunction != wxCOPY )
1560 return ;
1561
1562 wxCoord xx = XLOG2DEVMAC(x);
1563 wxCoord yy = YLOG2DEVMAC(y);
1564 wxCoord ww = m_signX * XLOG2DEVREL(width);
1565 wxCoord hh = m_signY * YLOG2DEVREL(height);
1566 // CMB: draw nothing if transformed w or h is 0
1567 if (ww == 0 || hh == 0)
1568 return;
1569
1570 // CMB: handle -ve width and/or height
1571 if (ww < 0)
1572 {
1573 ww = -ww;
1574 xx = xx - ww;
1575 }
1576 if (hh < 0)
1577 {
1578 hh = -hh;
1579 yy = yy - hh;
1580 }
1581
1582 wxMacCGContext* mctx = ((wxMacCGContext*) m_graphicContext) ;
1583 CGContextRef ctx = mctx->GetNativeContext() ;
1584 CGContextSaveGState( ctx ) ;
1585 CGContextTranslateCTM( ctx, xx + ww / 2, yy + hh / 2);
1586 CGContextScaleCTM( ctx , ww / 2 , hh / 2 ) ;
1587 CGContextAddArc( ctx, 0, 0, 1, 0 , 2*M_PI , 0);
1588 CGContextRestoreGState( ctx ) ;
1589 CGContextDrawPath( ctx , mctx->GetDrawingMode() ) ;
1590 }
1591
1592 bool wxDC::CanDrawBitmap(void) const
1593 {
1594 return true ;
1595 }
1596
1597 bool wxDC::DoBlit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
1598 wxDC *source, wxCoord xsrc, wxCoord ysrc, int logical_func , bool useMask,
1599 wxCoord xsrcMask, wxCoord ysrcMask )
1600 {
1601 wxCHECK_MSG(Ok(), false, wxT("wxDC::DoBlit Illegal dc"));
1602 wxCHECK_MSG(source->Ok(), false, wxT("wxDC::DoBlit Illegal source DC"));
1603
1604 if ( logical_func == wxNO_OP )
1605 return true ;
1606
1607 if (xsrcMask == -1 && ysrcMask == -1)
1608 {
1609 xsrcMask = xsrc;
1610 ysrcMask = ysrc;
1611 }
1612
1613 wxCoord yysrc = source->YLOG2DEVMAC(ysrc) ;
1614 wxCoord xxsrc = source->XLOG2DEVMAC(xsrc) ;
1615 wxCoord wwsrc = source->XLOG2DEVREL(width ) ;
1616 wxCoord hhsrc = source->YLOG2DEVREL(height) ;
1617
1618 wxCoord yydest = YLOG2DEVMAC(ydest) ;
1619 wxCoord xxdest = XLOG2DEVMAC(xdest) ;
1620 wxCoord wwdest = XLOG2DEVREL(width ) ;
1621 wxCoord hhdest = YLOG2DEVREL(height) ;
1622
1623 wxMemoryDC* memdc = dynamic_cast<wxMemoryDC*>(source) ;
1624 if ( memdc && logical_func == wxCOPY )
1625 {
1626 wxBitmap blit = memdc->GetSelectedObject() ;
1627 wxASSERT_MSG( blit.Ok() , wxT("Invalid bitmap for blitting") ) ;
1628
1629 wxCoord bmpwidth = blit.GetWidth();
1630 wxCoord bmpheight = blit.GetHeight();
1631
1632 if ( xxsrc != 0 || yysrc != 0 || bmpwidth != wwsrc || bmpheight != hhsrc )
1633 {
1634 wwsrc = wxMin( wwsrc , bmpwidth - xxsrc ) ;
1635 hhsrc = wxMin( hhsrc , bmpheight - yysrc ) ;
1636 if ( wwsrc > 0 && hhsrc > 0 )
1637 {
1638 if ( xxsrc >= 0 && yysrc >= 0 )
1639 {
1640 wxRect subrect( xxsrc, yysrc, wwsrc , hhsrc ) ;
1641 blit = blit.GetSubBitmap( subrect ) ;
1642 }
1643 else
1644 {
1645 // in this case we'd probably have to adjust the different coordinates, but
1646 // we have to find out proper contract first
1647 blit = wxNullBitmap ;
1648 }
1649 }
1650 else
1651 {
1652 blit = wxNullBitmap ;
1653 }
1654 }
1655
1656 if ( blit.Ok() )
1657 {
1658 CGContextRef cg = ((wxMacCGContext*)(m_graphicContext))->GetNativeContext() ;
1659 CGImageRef image = (CGImageRef)( blit.CGImageCreate() ) ;
1660 HIRect r = CGRectMake( xxdest , yydest , wwdest , hhdest ) ;
1661 HIViewDrawCGImage( cg , &r , image ) ;
1662 CGImageRelease( image ) ;
1663 }
1664 }
1665 else
1666 {
1667 #if 0
1668 CGContextRef cg = (wxMacCGContext*)(source->GetGraphicContext())->GetNativeContext() ;
1669 void *data = CGBitmapContextGetData( cg ) ;
1670 #endif
1671
1672 return false ; // wxFAIL_MSG( wxT("Blitting is only supported from bitmap contexts") ) ;
1673 }
1674
1675 return true;
1676 }
1677
1678 void wxDC::DoDrawRotatedText(const wxString& str, wxCoord x, wxCoord y,
1679 double angle)
1680 {
1681 wxCHECK_RET( Ok(), wxT("wxDC::DoDrawRotatedText Invalid window dc") );
1682 wxCHECK_RET( m_macATSUIStyle != NULL , wxT("No valid font set") ) ;
1683
1684 if ( str.Length() == 0 )
1685 return ;
1686 if ( m_logicalFunction != wxCOPY )
1687 return ;
1688
1689 OSStatus status = noErr ;
1690 ATSUTextLayout atsuLayout ;
1691 UniCharCount chars = str.Length() ;
1692 UniChar* ubuf = NULL ;
1693 #if SIZEOF_WCHAR_T == 4
1694 wxMBConvUTF16 converter ;
1695 #if wxUSE_UNICODE
1696 size_t unicharlen = converter.WC2MB( NULL , str.wc_str() , 0 ) ;
1697 ubuf = (UniChar*) malloc( unicharlen + 2 ) ;
1698 converter.WC2MB( (char*) ubuf , str.wc_str(), unicharlen + 2 ) ;
1699 #else
1700 const wxWCharBuffer wchar = str.wc_str( wxConvLocal ) ;
1701 size_t unicharlen = converter.WC2MB( NULL , wchar.data() , 0 ) ;
1702 ubuf = (UniChar*) malloc( unicharlen + 2 ) ;
1703 converter.WC2MB( (char*) ubuf , wchar.data() , unicharlen + 2 ) ;
1704 #endif
1705 chars = unicharlen / 2 ;
1706 #else
1707 #if wxUSE_UNICODE
1708 ubuf = (UniChar*) str.wc_str() ;
1709 #else
1710 wxWCharBuffer wchar = str.wc_str( wxConvLocal ) ;
1711 chars = wxWcslen( wchar.data() ) ;
1712 ubuf = (UniChar*) wchar.data() ;
1713 #endif
1714 #endif
1715
1716 int drawX = XLOG2DEVMAC(x) ;
1717 int drawY = YLOG2DEVMAC(y) ;
1718
1719 status = ::ATSUCreateTextLayoutWithTextPtr( (UniCharArrayPtr) ubuf , 0 , chars , chars , 1 ,
1720 &chars , (ATSUStyle*) &m_macATSUIStyle , &atsuLayout ) ;
1721
1722 wxASSERT_MSG( status == noErr , wxT("couldn't create the layout of the rotated text") );
1723
1724 status = ::ATSUSetTransientFontMatching( atsuLayout , true ) ;
1725 wxASSERT_MSG( status == noErr , wxT("couldn't setup transient font matching") );
1726
1727 int iAngle = int( angle );
1728 if ( abs(iAngle) > 0 )
1729 {
1730 Fixed atsuAngle = IntToFixed( iAngle ) ;
1731 ATSUAttributeTag atsuTags[] =
1732 {
1733 kATSULineRotationTag ,
1734 } ;
1735 ByteCount atsuSizes[sizeof(atsuTags)/sizeof(ATSUAttributeTag)] =
1736 {
1737 sizeof( Fixed ) ,
1738 } ;
1739 ATSUAttributeValuePtr atsuValues[sizeof(atsuTags)/sizeof(ATSUAttributeTag)] =
1740 {
1741 &atsuAngle ,
1742 } ;
1743 status = ::ATSUSetLayoutControls(atsuLayout , sizeof(atsuTags)/sizeof(ATSUAttributeTag),
1744 atsuTags, atsuSizes, atsuValues ) ;
1745 }
1746
1747 {
1748 CGContextRef cgContext = ((wxMacCGContext*)(m_graphicContext))->GetNativeContext() ;
1749 ATSUAttributeTag atsuTags[] =
1750 {
1751 kATSUCGContextTag ,
1752 } ;
1753 ByteCount atsuSizes[sizeof(atsuTags)/sizeof(ATSUAttributeTag)] =
1754 {
1755 sizeof( CGContextRef ) ,
1756 } ;
1757 ATSUAttributeValuePtr atsuValues[sizeof(atsuTags)/sizeof(ATSUAttributeTag)] =
1758 {
1759 &cgContext ,
1760 } ;
1761 status = ::ATSUSetLayoutControls(atsuLayout , sizeof(atsuTags)/sizeof(ATSUAttributeTag),
1762 atsuTags, atsuSizes, atsuValues ) ;
1763 }
1764
1765 ATSUTextMeasurement textBefore ;
1766 ATSUTextMeasurement textAfter ;
1767 ATSUTextMeasurement ascent ;
1768 ATSUTextMeasurement descent ;
1769
1770 status = ::ATSUGetUnjustifiedBounds( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd,
1771 &textBefore , &textAfter, &ascent , &descent );
1772 wxASSERT_MSG( status == noErr , wxT("couldn't measure the rotated text") );
1773
1774 Rect rect ;
1775
1776 if ( m_backgroundMode == wxSOLID )
1777 {
1778 wxGraphicPath* path = m_graphicContext->CreatePath() ;
1779 path->MoveToPoint(
1780 drawX ,
1781 drawY ) ;
1782 path->AddLineToPoint(
1783 (int) (drawX + sin(angle/RAD2DEG) * FixedToInt(ascent + descent)) ,
1784 (int) (drawY + cos(angle/RAD2DEG) * FixedToInt(ascent + descent)) ) ;
1785 path->AddLineToPoint(
1786 (int) (drawX + sin(angle/RAD2DEG) * FixedToInt(ascent + descent ) + cos(angle/RAD2DEG) * FixedToInt(textAfter)) ,
1787 (int) (drawY + cos(angle/RAD2DEG) * FixedToInt(ascent + descent) - sin(angle/RAD2DEG) * FixedToInt(textAfter)) ) ;
1788 path->AddLineToPoint(
1789 (int) (drawX + cos(angle/RAD2DEG) * FixedToInt(textAfter)) ,
1790 (int) (drawY - sin(angle/RAD2DEG) * FixedToInt(textAfter)) ) ;
1791
1792 m_graphicContext->FillPath( path , m_textBackgroundColour ) ;
1793 delete path ;
1794 }
1795
1796 drawX += (int)(sin(angle/RAD2DEG) * FixedToInt(ascent));
1797 drawY += (int)(cos(angle/RAD2DEG) * FixedToInt(ascent));
1798
1799 status = ::ATSUMeasureTextImage( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd,
1800 IntToFixed(drawX) , IntToFixed(drawY) , &rect );
1801 wxASSERT_MSG( status == noErr , wxT("couldn't measure the rotated text") );
1802
1803 CGContextSaveGState(((wxMacCGContext*)(m_graphicContext))->GetNativeContext());
1804 CGContextTranslateCTM(((wxMacCGContext*)(m_graphicContext))->GetNativeContext(), drawX, drawY);
1805 CGContextScaleCTM(((wxMacCGContext*)(m_graphicContext))->GetNativeContext(), 1, -1);
1806 status = ::ATSUDrawText( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd,
1807 IntToFixed(0) , IntToFixed(0) );
1808 wxASSERT_MSG( status == noErr , wxT("couldn't draw the rotated text") );
1809 CGContextRestoreGState( ((wxMacCGContext*)(m_graphicContext))->GetNativeContext() ) ;
1810
1811 CalcBoundingBox(XDEV2LOG(rect.left), YDEV2LOG(rect.top) );
1812 CalcBoundingBox(XDEV2LOG(rect.right), YDEV2LOG(rect.bottom) );
1813
1814 ::ATSUDisposeTextLayout(atsuLayout);
1815
1816 #if SIZEOF_WCHAR_T == 4
1817 free( ubuf ) ;
1818 #endif
1819 }
1820
1821 void wxDC::DoDrawText(const wxString& strtext, wxCoord x, wxCoord y)
1822 {
1823 wxCHECK_RET(Ok(), wxT("wxDC::DoDrawText Invalid DC"));
1824
1825 DoDrawRotatedText( strtext , x , y , 0.0 ) ;
1826 }
1827
1828 bool wxDC::CanGetTextExtent() const
1829 {
1830 wxCHECK_MSG(Ok(), false, wxT("Invalid DC"));
1831
1832 return true ;
1833 }
1834
1835 void wxDC::DoGetTextExtent( const wxString &str, wxCoord *width, wxCoord *height,
1836 wxCoord *descent, wxCoord *externalLeading ,
1837 wxFont *theFont ) const
1838 {
1839 wxCHECK_RET(Ok(), wxT("Invalid DC"));
1840
1841 wxFont formerFont = m_font ;
1842 if ( theFont )
1843 {
1844 // work around the constness
1845 *((wxFont*)(&m_font)) = *theFont ;
1846 MacInstallFont() ;
1847 }
1848
1849 if ( str.Length() == 0 )
1850 return ;
1851
1852 wxCHECK_RET( m_macATSUIStyle != NULL , wxT("No valid font set") ) ;
1853
1854 OSStatus status = noErr ;
1855 ATSUTextLayout atsuLayout ;
1856 UniCharCount chars = str.Length() ;
1857 UniChar* ubuf = NULL ;
1858 #if SIZEOF_WCHAR_T == 4
1859 wxMBConvUTF16 converter ;
1860 #if wxUSE_UNICODE
1861 size_t unicharlen = converter.WC2MB( NULL , str.wc_str() , 0 ) ;
1862 ubuf = (UniChar*) malloc( unicharlen + 2 ) ;
1863 converter.WC2MB( (char*) ubuf , str.wc_str(), unicharlen + 2 ) ;
1864 #else
1865 const wxWCharBuffer wchar = str.wc_str( wxConvLocal ) ;
1866 size_t unicharlen = converter.WC2MB( NULL , wchar.data() , 0 ) ;
1867 ubuf = (UniChar*) malloc( unicharlen + 2 ) ;
1868 converter.WC2MB( (char*) ubuf , wchar.data() , unicharlen + 2 ) ;
1869 #endif
1870 chars = unicharlen / 2 ;
1871 #else
1872 #if wxUSE_UNICODE
1873 ubuf = (UniChar*) str.wc_str() ;
1874 #else
1875 wxWCharBuffer wchar = str.wc_str( wxConvLocal ) ;
1876 chars = wxWcslen( wchar.data() ) ;
1877 ubuf = (UniChar*) wchar.data() ;
1878 #endif
1879 #endif
1880
1881 status = ::ATSUCreateTextLayoutWithTextPtr( (UniCharArrayPtr) ubuf , 0 , chars , chars , 1 ,
1882 &chars , (ATSUStyle*) &m_macATSUIStyle , &atsuLayout ) ;
1883
1884 wxASSERT_MSG( status == noErr , wxT("couldn't create the layout of the text") );
1885
1886 ATSUTextMeasurement textBefore ;
1887 ATSUTextMeasurement textAfter ;
1888 ATSUTextMeasurement textAscent ;
1889 ATSUTextMeasurement textDescent ;
1890
1891 status = ::ATSUGetUnjustifiedBounds( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd,
1892 &textBefore , &textAfter, &textAscent , &textDescent );
1893
1894 if ( height )
1895 *height = YDEV2LOGREL( FixedToInt(textAscent + textDescent) ) ;
1896 if ( descent )
1897 *descent =YDEV2LOGREL( FixedToInt(textDescent) );
1898 if ( externalLeading )
1899 *externalLeading = 0 ;
1900 if ( width )
1901 *width = XDEV2LOGREL( FixedToInt(textAfter - textBefore) ) ;
1902
1903 ::ATSUDisposeTextLayout(atsuLayout);
1904 #if SIZEOF_WCHAR_T == 4
1905 free( ubuf ) ;
1906 #endif
1907 if ( theFont )
1908 {
1909 // work around the constness
1910 *((wxFont*)(&m_font)) = formerFont ;
1911 MacInstallFont() ;
1912 }
1913 }
1914
1915 bool wxDC::DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const
1916 {
1917 wxCHECK_MSG(Ok(), false, wxT("Invalid DC"));
1918
1919 widths.Empty();
1920 widths.Add(0, text.Length());
1921
1922 if (text.Length() == 0)
1923 return false;
1924
1925 ATSUTextLayout atsuLayout ;
1926 UniCharCount chars = text.Length() ;
1927 UniChar* ubuf = NULL ;
1928 #if SIZEOF_WCHAR_T == 4
1929 wxMBConvUTF16 converter ;
1930 #if wxUSE_UNICODE
1931 size_t unicharlen = converter.WC2MB( NULL , text.wc_str() , 0 ) ;
1932 ubuf = (UniChar*) malloc( unicharlen + 2 ) ;
1933 converter.WC2MB( (char*) ubuf , text.wc_str(), unicharlen + 2 ) ;
1934 #else
1935 const wxWCharBuffer wchar = text.wc_str( wxConvLocal ) ;
1936 size_t unicharlen = converter.WC2MB( NULL , wchar.data() , 0 ) ;
1937 ubuf = (UniChar*) malloc( unicharlen + 2 ) ;
1938 converter.WC2MB( (char*) ubuf , wchar.data() , unicharlen + 2 ) ;
1939 #endif
1940 chars = unicharlen / 2 ;
1941 #else
1942 #if wxUSE_UNICODE
1943 ubuf = (UniChar*) text.wc_str() ;
1944 #else
1945 wxWCharBuffer wchar = text.wc_str( wxConvLocal ) ;
1946 chars = wxWcslen( wchar.data() ) ;
1947 ubuf = (UniChar*) wchar.data() ;
1948 #endif
1949 #endif
1950
1951 OSStatus status;
1952 status = ::ATSUCreateTextLayoutWithTextPtr( (UniCharArrayPtr) ubuf , 0 , chars , chars , 1 ,
1953 &chars , (ATSUStyle*) &m_macATSUIStyle , &atsuLayout ) ;
1954
1955 for ( int pos = 0; pos < (int)chars; pos ++ )
1956 {
1957 unsigned long actualNumberOfBounds = 0;
1958 ATSTrapezoid glyphBounds;
1959
1960 // We get a single bound, since the text should only require one. If it requires more, there is an issue
1961 OSStatus result;
1962 result = ATSUGetGlyphBounds( atsuLayout, 0, 0, kATSUFromTextBeginning, pos + 1,
1963 kATSUseDeviceOrigins, 1, &glyphBounds, &actualNumberOfBounds );
1964 if (result != noErr || actualNumberOfBounds != 1 )
1965 return false;
1966
1967 widths[pos] = XDEV2LOGREL(FixedToInt( glyphBounds.upperRight.x - glyphBounds.upperLeft.x ));
1968 //unsigned char uch = s[i];
1969 }
1970
1971 ::ATSUDisposeTextLayout(atsuLayout);
1972 return true;
1973 }
1974
1975 wxCoord wxDC::GetCharWidth(void) const
1976 {
1977 wxCoord width ;
1978 DoGetTextExtent(wxT("g") , &width , NULL , NULL , NULL , NULL ) ;
1979
1980 return width ;
1981 }
1982
1983 wxCoord wxDC::GetCharHeight(void) const
1984 {
1985 wxCoord height ;
1986 DoGetTextExtent(wxT("g") , NULL , &height , NULL , NULL , NULL ) ;
1987
1988 return height ;
1989 }
1990
1991 void wxDC::Clear(void)
1992 {
1993 wxCHECK_RET(Ok(), wxT("Invalid DC"));
1994
1995 if (m_backgroundBrush.Ok() && m_backgroundBrush.GetStyle() != wxTRANSPARENT)
1996 {
1997 HIRect rect = CGRectMake( -10000 , -10000 , 20000 , 20000 ) ;
1998 CGContextRef cg = ((wxMacCGContext*)(m_graphicContext))->GetNativeContext() ;
1999 switch( m_backgroundBrush.MacGetBrushKind() )
2000 {
2001 case kwxMacBrushTheme :
2002 {
2003 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4
2004 if ( HIThemeSetFill != 0 )
2005 {
2006 HIThemeSetFill( m_backgroundBrush.MacGetTheme(), NULL, cg, kHIThemeOrientationNormal );
2007 CGContextFillRect(cg, rect);
2008
2009 }
2010 else
2011 #endif
2012 {
2013 RGBColor color;
2014 GetThemeBrushAsColor( m_backgroundBrush.MacGetTheme(), 32, true, &color );
2015 CGContextSetRGBFillColor( cg, (float) color.red / 65536,
2016 (float) color.green / 65536, (float) color.blue / 65536, 1 );
2017 CGContextFillRect( cg, rect );
2018 }
2019
2020 // reset to normal value
2021 RGBColor col = MAC_WXCOLORREF( GetBrush().GetColour().GetPixel() ) ;
2022 CGContextSetRGBFillColor( cg, col.red / 65536.0, col.green / 65536.0, col.blue / 65536.0, 1.0 );
2023 }
2024 break ;
2025
2026 case kwxMacBrushThemeBackground :
2027 {
2028 wxFAIL_MSG( wxT("There shouldn't be theme backgrounds under Quartz") ) ;
2029
2030 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_3
2031 if ( UMAGetSystemVersion() >= 0x1030 )
2032 {
2033 HIThemeBackgroundDrawInfo drawInfo ;
2034 drawInfo.version = 0 ;
2035 drawInfo.state = kThemeStateActive ;
2036 drawInfo.kind = m_backgroundBrush.MacGetThemeBackground(NULL) ;
2037 if ( drawInfo.kind == kThemeBackgroundMetal )
2038 HIThemeDrawBackground( &rect , &drawInfo, cg ,
2039 kHIThemeOrientationNormal) ;
2040 HIThemeApplyBackground( &rect , &drawInfo, cg ,
2041 kHIThemeOrientationNormal) ;
2042 }
2043 #endif
2044 }
2045 break ;
2046
2047 case kwxMacBrushColour :
2048 {
2049 RGBColor col = MAC_WXCOLORREF( m_backgroundBrush.GetColour().GetPixel()) ;
2050 CGContextSetRGBFillColor( cg , col.red / 65536.0 , col.green / 65536.0 , col.blue / 65536.0 , 1.0 ) ;
2051 CGContextFillRect(cg, rect);
2052
2053 // reset to normal value
2054 col = MAC_WXCOLORREF( GetBrush().GetColour().GetPixel() ) ;
2055 CGContextSetRGBFillColor( cg , col.red / 65536.0 , col.green / 65536.0 , col.blue / 65536.0 , 1.0 ) ;
2056 }
2057 break ;
2058
2059 default :
2060 wxFAIL_MSG( wxT("unknown brush kind") ) ;
2061 break ;
2062 }
2063 }
2064 }
2065
2066 void wxDC::MacInstallFont() const
2067 {
2068 wxCHECK_RET(Ok(), wxT("Invalid DC"));
2069
2070 if ( m_macATSUIStyle )
2071 {
2072 ::ATSUDisposeStyle((ATSUStyle)m_macATSUIStyle);
2073 m_macATSUIStyle = NULL ;
2074 }
2075
2076 if ( m_font.Ok() )
2077 {
2078 OSStatus status = noErr ;
2079 status = ATSUCreateAndCopyStyle( (ATSUStyle) m_font.MacGetATSUStyle() , (ATSUStyle*) &m_macATSUIStyle ) ;
2080 wxASSERT_MSG( status == noErr , wxT("couldn't set create ATSU style") ) ;
2081
2082 Fixed atsuSize = IntToFixed( int(m_scaleY * m_font.MacGetFontSize()) ) ;
2083 RGBColor atsuColor = MAC_WXCOLORREF( m_textForegroundColour.GetPixel() ) ;
2084 ATSUAttributeTag atsuTags[] =
2085 {
2086 kATSUSizeTag ,
2087 kATSUColorTag ,
2088 } ;
2089 ByteCount atsuSizes[sizeof(atsuTags)/sizeof(ATSUAttributeTag)] =
2090 {
2091 sizeof( Fixed ) ,
2092 sizeof( RGBColor ) ,
2093 } ;
2094 // Boolean kTrue = true ;
2095 // Boolean kFalse = false ;
2096 // ATSUVerticalCharacterType kHorizontal = kATSUStronglyHorizontal;
2097 ATSUAttributeValuePtr atsuValues[sizeof(atsuTags)/sizeof(ATSUAttributeTag)] =
2098 {
2099 &atsuSize ,
2100 &atsuColor ,
2101 } ;
2102 status = ::ATSUSetAttributes((ATSUStyle)m_macATSUIStyle, sizeof(atsuTags)/sizeof(ATSUAttributeTag) ,
2103 atsuTags, atsuSizes, atsuValues);
2104
2105 wxASSERT_MSG( status == noErr , wxT("couldn't Modify ATSU style") ) ;
2106 }
2107 }
2108
2109 // ---------------------------------------------------------------------------
2110 // coordinates transformations
2111 // ---------------------------------------------------------------------------
2112
2113 wxCoord wxDCBase::DeviceToLogicalX(wxCoord x) const
2114 {
2115 return ((wxDC *)this)->XDEV2LOG(x);
2116 }
2117
2118 wxCoord wxDCBase::DeviceToLogicalY(wxCoord y) const
2119 {
2120 return ((wxDC *)this)->YDEV2LOG(y);
2121 }
2122
2123 wxCoord wxDCBase::DeviceToLogicalXRel(wxCoord x) const
2124 {
2125 return ((wxDC *)this)->XDEV2LOGREL(x);
2126 }
2127
2128 wxCoord wxDCBase::DeviceToLogicalYRel(wxCoord y) const
2129 {
2130 return ((wxDC *)this)->YDEV2LOGREL(y);
2131 }
2132
2133 wxCoord wxDCBase::LogicalToDeviceX(wxCoord x) const
2134 {
2135 return ((wxDC *)this)->XLOG2DEV(x);
2136 }
2137
2138 wxCoord wxDCBase::LogicalToDeviceY(wxCoord y) const
2139 {
2140 return ((wxDC *)this)->YLOG2DEV(y);
2141 }
2142
2143 wxCoord wxDCBase::LogicalToDeviceXRel(wxCoord x) const
2144 {
2145 return ((wxDC *)this)->XLOG2DEVREL(x);
2146 }
2147
2148 wxCoord wxDCBase::LogicalToDeviceYRel(wxCoord y) const
2149 {
2150 return ((wxDC *)this)->YLOG2DEVREL(y);
2151 }
2152
2153 #endif // wxMAC_USE_CORE_GRAPHICS
2154
wxWidgets (Impactor)