]> git.saurik.com Git - wxWidgets.git/blob - src/osx/carbon/graphics.cpp
projects / wxWidgets.git / blob
? search:


f165cbfdaaca3859684f862ffe8a367cd03dd2bc
[wxWidgets.git] / src / osx / carbon / graphics.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/osx/carbon/graphics.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/graphics.h"
15 #include "wx/private/graphics.h"
16
17 #ifndef WX_PRECOMP
18 #include "wx/dcclient.h"
19 #include "wx/dcmemory.h"
20 #include "wx/dcprint.h"
21 #include "wx/log.h"
22 #include "wx/region.h"
23 #include "wx/image.h"
24 #include "wx/icon.h"
25 #endif
26
27
28 #ifdef __MSL__
29 #if __MSL__ >= 0x6000
30 #include "math.h"
31 // in case our functions were defined outside std, we make it known all the same
32 namespace std { }
33 using namespace std;
34 #endif
35 #endif
36
37 #ifdef __WXMAC__
38 #include "wx/osx/private.h"
39 #include "wx/osx/dcprint.h"
40 #include "wx/osx/dcclient.h"
41 #include "wx/osx/dcmemory.h"
42 #include "wx/osx/private.h"
43 #else
44 #include "CoreServices/CoreServices.h"
45 #include "ApplicationServices/ApplicationServices.h"
46 #include "wx/osx/core/cfstring.h"
47 #include "wx/cocoa/dcclient.h"
48 #endif
49
50 #ifdef __WXCOCOA__
51
52 CGColorSpaceRef wxMacGetGenericRGBColorSpace()
53 {
54 static wxCFRef<CGColorSpaceRef> genericRGBColorSpace;
55
56 if (genericRGBColorSpace == NULL)
57 {
58 genericRGBColorSpace.reset( CGColorSpaceCreateWithName( kCGColorSpaceGenericRGB ) );
59 }
60
61 return genericRGBColorSpace;
62 }
63
64 int UMAGetSystemVersion()
65 {
66 return 0x1050;
67 }
68
69
70 #define wxOSX_USE_CORE_TEXT 1
71
72 #endif
73
74 #if wxOSX_USE_COCOA_OR_IPHONE
75 extern CGContextRef wxOSXGetContextFromCurrentContext() ;
76 #if wxOSX_USE_COCOA
77 extern bool wxOSXLockFocus( WXWidget view) ;
78 extern void wxOSXUnlockFocus( WXWidget view) ;
79 #endif
80 #endif
81
82 #if 1 // MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5
83
84 // TODO test whether this private API also works under 10.3
85
86 // copying values from NSCompositingModes (see also webkit and cairo sources)
87
88 typedef enum CGCompositeOperation {
89 kCGCompositeOperationClear = 0,
90 kCGCompositeOperationCopy = 1,
91 kCGCompositeOperationSourceOver = 2,
92 kCGCompositeOperationSourceIn = 3,
93 kCGCompositeOperationSourceOut = 4,
94 kCGCompositeOperationSourceAtop = 5,
95 kCGCompositeOperationDestinationOver = 6,
96 kCGCompositeOperationDestinationIn = 7,
97 kCGCompositeOperationDestinationOut = 8,
98 kCGCompositeOperationDestinationAtop = 9,
99 kCGCompositeOperationXOR = 10,
100 kCGCompositeOperationPlusDarker = 11,
101 // NS only, unsupported by CG : Highlight
102 kCGCompositeOperationPlusLighter = 12
103 } CGCompositeOperation ;
104
105 extern "C"
106 {
107 CG_EXTERN void CGContextSetCompositeOperation (CGContextRef context, int operation);
108 } ;
109
110 #endif
111
112 //-----------------------------------------------------------------------------
113 // constants
114 //-----------------------------------------------------------------------------
115
116 #if !defined( __DARWIN__ ) || defined(__MWERKS__)
117 #ifndef M_PI
118 const double M_PI = 3.14159265358979;
119 #endif
120 #endif
121
122 static const double RAD2DEG = 180.0 / M_PI;
123
124 //
125 // Pen, Brushes and Fonts
126 //
127
128 #pragma mark -
129 #pragma mark wxMacCoreGraphicsPattern, ImagePattern, HatchPattern classes
130
131 OSStatus wxMacDrawCGImage(
132 CGContextRef inContext,
133 const CGRect * inBounds,
134 CGImageRef inImage)
135 {
136 #if wxOSX_USE_CARBON
137 return HIViewDrawCGImage( inContext, inBounds, inImage );
138 #else
139 CGContextSaveGState(inContext);
140 CGContextTranslateCTM(inContext, inBounds->origin.x, inBounds->origin.y + inBounds->size.height);
141 CGRect r = *inBounds;
142 r.origin.x = r.origin.y = 0;
143 CGContextScaleCTM(inContext, 1, -1);
144 CGContextDrawImage(inContext, r, inImage );
145 CGContextRestoreGState(inContext);
146 return noErr;
147 #endif
148 }
149
150 CGColorRef wxMacCreateCGColor( const wxColour& col )
151 {
152 CGColorRef retval = 0;
153 #ifdef __WXMAC__
154 retval = col.CreateCGColor();
155 #else
156 // TODO add conversion NSColor - CGColorRef (obj-c)
157 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
158 if ( CGColorCreateGenericRGB )
159 retval = CGColorCreateGenericRGB( col.Red() / 255.0 , col.Green() / 255.0, col.Blue() / 255.0, col.Alpha() / 255.0 );
160 else
161 #endif
162 {
163 CGFloat components[4] = { col.Red() / 255.0, col.Green() / 255.0, col.Blue() / 255.0, col.Alpha() / 255.0 } ;
164 retval = CGColorCreate( wxMacGetGenericRGBColorSpace() , components ) ;
165 }
166
167 #endif
168 return retval;
169 }
170
171 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5 && wxOSX_USE_CORE_TEXT
172
173 CTFontRef wxMacCreateCTFont( const wxFont& font )
174 {
175 #ifdef __WXMAC__
176 return wxCFRetain((CTFontRef) font.OSXGetCTFont());
177 #else
178 return CTFontCreateWithName( wxCFStringRef( font.GetFaceName(), wxLocale::GetSystemEncoding() ) , font.GetPointSize() , NULL );
179 #endif
180 }
181
182 #endif
183
184 // CGPattern wrapper class: always allocate on heap, never call destructor
185
186 class wxMacCoreGraphicsPattern
187 {
188 public :
189 wxMacCoreGraphicsPattern() {}
190
191 // is guaranteed to be called only with a non-Null CGContextRef
192 virtual void Render( CGContextRef ctxRef ) = 0;
193
194 operator CGPatternRef() const { return m_patternRef; }
195
196 protected :
197 virtual ~wxMacCoreGraphicsPattern()
198 {
199 // as this is called only when the m_patternRef is been released;
200 // don't release it again
201 }
202
203 static void _Render( void *info, CGContextRef ctxRef )
204 {
205 wxMacCoreGraphicsPattern* self = (wxMacCoreGraphicsPattern*) info;
206 if ( self && ctxRef )
207 self->Render( ctxRef );
208 }
209
210 static void _Dispose( void *info )
211 {
212 wxMacCoreGraphicsPattern* self = (wxMacCoreGraphicsPattern*) info;
213 delete self;
214 }
215
216 CGPatternRef m_patternRef;
217
218 static const CGPatternCallbacks ms_Callbacks;
219 };
220
221 const CGPatternCallbacks wxMacCoreGraphicsPattern::ms_Callbacks = { 0, &wxMacCoreGraphicsPattern::_Render, &wxMacCoreGraphicsPattern::_Dispose };
222
223 class ImagePattern : public wxMacCoreGraphicsPattern
224 {
225 public :
226 ImagePattern( const wxBitmap* bmp , const CGAffineTransform& transform )
227 {
228 wxASSERT( bmp && bmp->Ok() );
229 #ifdef __WXMAC__
230 Init( (CGImageRef) bmp->CreateCGImage() , transform );
231 #endif
232 }
233
234 // ImagePattern takes ownership of CGImageRef passed in
235 ImagePattern( CGImageRef image , const CGAffineTransform& transform )
236 {
237 if ( image )
238 CFRetain( image );
239
240 Init( image , transform );
241 }
242
243 virtual void Render( CGContextRef ctxRef )
244 {
245 if (m_image != NULL)
246 wxMacDrawCGImage( ctxRef, &m_imageBounds, m_image );
247 }
248
249 protected :
250 void Init( CGImageRef image, const CGAffineTransform& transform )
251 {
252 m_image = image;
253 if ( m_image )
254 {
255 m_imageBounds = CGRectMake( (CGFloat) 0.0, (CGFloat) 0.0, (CGFloat)CGImageGetWidth( m_image ), (CGFloat)CGImageGetHeight( m_image ) );
256 m_patternRef = CGPatternCreate(
257 this , m_imageBounds, transform ,
258 m_imageBounds.size.width, m_imageBounds.size.height,
259 kCGPatternTilingNoDistortion, true , &wxMacCoreGraphicsPattern::ms_Callbacks );
260 }
261 }
262
263 virtual ~ImagePattern()
264 {
265 if ( m_image )
266 CGImageRelease( m_image );
267 }
268
269 CGImageRef m_image;
270 CGRect m_imageBounds;
271 };
272
273 class HatchPattern : public wxMacCoreGraphicsPattern
274 {
275 public :
276 HatchPattern( int hatchstyle, const CGAffineTransform& transform )
277 {
278 m_hatch = hatchstyle;
279 m_imageBounds = CGRectMake( (CGFloat) 0.0, (CGFloat) 0.0, (CGFloat) 8.0 , (CGFloat) 8.0 );
280 m_patternRef = CGPatternCreate(
281 this , m_imageBounds, transform ,
282 m_imageBounds.size.width, m_imageBounds.size.height,
283 kCGPatternTilingNoDistortion, false , &wxMacCoreGraphicsPattern::ms_Callbacks );
284 }
285
286 void StrokeLineSegments( CGContextRef ctxRef , const CGPoint pts[] , size_t count )
287 {
288 CGContextStrokeLineSegments( ctxRef , pts , count );
289 }
290
291 virtual void Render( CGContextRef ctxRef )
292 {
293 switch ( m_hatch )
294 {
295 case wxBDIAGONAL_HATCH :
296 {
297 CGPoint pts[] =
298 {
299 { (CGFloat) 8.0 , (CGFloat) 0.0 } , { (CGFloat) 0.0 , (CGFloat) 8.0 }
300 };
301 StrokeLineSegments( ctxRef , pts , 2 );
302 }
303 break;
304
305 case wxCROSSDIAG_HATCH :
306 {
307 CGPoint pts[] =
308 {
309 { (CGFloat) 0.0 , (CGFloat) 0.0 } , { (CGFloat) 8.0 , (CGFloat) 8.0 } ,
310 { (CGFloat) 8.0 , (CGFloat) 0.0 } , { (CGFloat) 0.0 , (CGFloat) 8.0 }
311 };
312 StrokeLineSegments( ctxRef , pts , 4 );
313 }
314 break;
315
316 case wxFDIAGONAL_HATCH :
317 {
318 CGPoint pts[] =
319 {
320 { (CGFloat) 0.0 , (CGFloat) 0.0 } , { (CGFloat) 8.0 , (CGFloat) 8.0 }
321 };
322 StrokeLineSegments( ctxRef , pts , 2 );
323 }
324 break;
325
326 case wxCROSS_HATCH :
327 {
328 CGPoint pts[] =
329 {
330 { (CGFloat) 0.0 , (CGFloat) 4.0 } , { (CGFloat) 8.0 , (CGFloat) 4.0 } ,
331 { (CGFloat) 4.0 , (CGFloat) 0.0 } , { (CGFloat) 4.0 , (CGFloat) 8.0 } ,
332 };
333 StrokeLineSegments( ctxRef , pts , 4 );
334 }
335 break;
336
337 case wxHORIZONTAL_HATCH :
338 {
339 CGPoint pts[] =
340 {
341 { (CGFloat) 0.0 , (CGFloat) 4.0 } , { (CGFloat) 8.0 , (CGFloat) 4.0 } ,
342 };
343 StrokeLineSegments( ctxRef , pts , 2 );
344 }
345 break;
346
347 case wxVERTICAL_HATCH :
348 {
349 CGPoint pts[] =
350 {
351 { (CGFloat) 4.0 , (CGFloat) 0.0 } , { (CGFloat) 4.0 , (CGFloat) 8.0 } ,
352 };
353 StrokeLineSegments( ctxRef , pts , 2 );
354 }
355 break;
356
357 default:
358 break;
359 }
360 }
361
362 protected :
363 virtual ~HatchPattern() {}
364
365 CGRect m_imageBounds;
366 int m_hatch;
367 };
368
369 class wxMacCoreGraphicsPenData : public wxGraphicsObjectRefData
370 {
371 public:
372 wxMacCoreGraphicsPenData( wxGraphicsRenderer* renderer, const wxPen &pen );
373 ~wxMacCoreGraphicsPenData();
374
375 void Init();
376 virtual void Apply( wxGraphicsContext* context );
377 virtual wxDouble GetWidth() { return m_width; }
378
379 protected :
380 CGLineCap m_cap;
381 wxCFRef<CGColorRef> m_color;
382 wxCFRef<CGColorSpaceRef> m_colorSpace;
383
384 CGLineJoin m_join;
385 CGFloat m_width;
386
387 int m_count;
388 const CGFloat *m_lengths;
389 CGFloat *m_userLengths;
390
391
392 bool m_isPattern;
393 wxCFRef<CGPatternRef> m_pattern;
394 CGFloat* m_patternColorComponents;
395 };
396
397 wxMacCoreGraphicsPenData::wxMacCoreGraphicsPenData( wxGraphicsRenderer* renderer, const wxPen &pen ) :
398 wxGraphicsObjectRefData( renderer )
399 {
400 Init();
401
402 m_color.reset( wxMacCreateCGColor( pen.GetColour() ) ) ;
403
404 // TODO: * m_dc->m_scaleX
405 m_width = pen.GetWidth();
406 if (m_width <= 0.0)
407 m_width = (CGFloat) 0.1;
408
409 switch ( pen.GetCap() )
410 {
411 case wxCAP_ROUND :
412 m_cap = kCGLineCapRound;
413 break;
414
415 case wxCAP_PROJECTING :
416 m_cap = kCGLineCapSquare;
417 break;
418
419 case wxCAP_BUTT :
420 m_cap = kCGLineCapButt;
421 break;
422
423 default :
424 m_cap = kCGLineCapButt;
425 break;
426 }
427
428 switch ( pen.GetJoin() )
429 {
430 case wxJOIN_BEVEL :
431 m_join = kCGLineJoinBevel;
432 break;
433
434 case wxJOIN_MITER :
435 m_join = kCGLineJoinMiter;
436 break;
437
438 case wxJOIN_ROUND :
439 m_join = kCGLineJoinRound;
440 break;
441
442 default :
443 m_join = kCGLineJoinMiter;
444 break;
445 }
446
447 const CGFloat dashUnit = m_width < 1.0 ? (CGFloat) 1.0 : m_width;
448
449 const CGFloat dotted[] = { (CGFloat) dashUnit , (CGFloat) (dashUnit + 2.0) };
450 static const CGFloat short_dashed[] = { (CGFloat) 9.0 , (CGFloat) 6.0 };
451 static const CGFloat dashed[] = { (CGFloat) 19.0 , (CGFloat) 9.0 };
452 static const CGFloat dotted_dashed[] = { (CGFloat) 9.0 , (CGFloat) 6.0 , (CGFloat) 3.0 , (CGFloat) 3.0 };
453
454 switch ( pen.GetStyle() )
455 {
456 case wxPENSTYLE_SOLID:
457 break;
458
459 case wxPENSTYLE_DOT:
460 m_count = WXSIZEOF(dotted);
461 m_userLengths = new CGFloat[ m_count ] ;
462 memcpy( m_userLengths, dotted, sizeof(dotted) );
463 m_lengths = m_userLengths;
464 break;
465
466 case wxPENSTYLE_LONG_DASH:
467 m_count = WXSIZEOF(dashed);
468 m_lengths = dashed;
469 break;
470
471 case wxPENSTYLE_SHORT_DASH:
472 m_count = WXSIZEOF(short_dashed);
473 m_lengths = short_dashed;
474 break;
475
476 case wxPENSTYLE_DOT_DASH:
477 m_count = WXSIZEOF(dotted_dashed);
478 m_lengths = dotted_dashed;
479 break;
480
481 case wxPENSTYLE_USER_DASH:
482 wxDash *dashes;
483 m_count = pen.GetDashes( &dashes );
484 if ((dashes != NULL) && (m_count > 0))
485 {
486 m_userLengths = new CGFloat[m_count];
487 for ( int i = 0; i < m_count; ++i )
488 {
489 m_userLengths[i] = dashes[i] * dashUnit;
490
491 if ( i % 2 == 1 && m_userLengths[i] < dashUnit + 2.0 )
492 m_userLengths[i] = (CGFloat) (dashUnit + 2.0);
493 else if ( i % 2 == 0 && m_userLengths[i] < dashUnit )
494 m_userLengths[i] = dashUnit;
495 }
496 }
497 m_lengths = m_userLengths;
498 break;
499
500 case wxPENSTYLE_STIPPLE:
501 {
502 wxBitmap* bmp = pen.GetStipple();
503 if ( bmp && bmp->Ok() )
504 {
505 m_colorSpace.reset( CGColorSpaceCreatePattern( NULL ) );
506 m_pattern.reset( (CGPatternRef) *( new ImagePattern( bmp , CGAffineTransformMakeScale( 1,-1 ) ) ) );
507 m_patternColorComponents = new CGFloat[1] ;
508 m_patternColorComponents[0] = (CGFloat) 1.0;
509 m_isPattern = true;
510 }
511 }
512 break;
513
514 default :
515 {
516 m_isPattern = true;
517 m_colorSpace.reset( CGColorSpaceCreatePattern( wxMacGetGenericRGBColorSpace() ) );
518 m_pattern.reset( (CGPatternRef) *( new HatchPattern( pen.GetStyle() , CGAffineTransformMakeScale( 1,-1 ) ) ) );
519 m_patternColorComponents = new CGFloat[4] ;
520 m_patternColorComponents[0] = (CGFloat) (pen.GetColour().Red() / 255.0);
521 m_patternColorComponents[1] = (CGFloat) (pen.GetColour().Green() / 255.0);
522 m_patternColorComponents[2] = (CGFloat) (pen.GetColour().Blue() / 255.0);
523 m_patternColorComponents[3] = (CGFloat) (pen.GetColour().Alpha() / 255.0);
524 }
525 break;
526 }
527 if ((m_lengths != NULL) && (m_count > 0))
528 {
529 // force the line cap, otherwise we get artifacts (overlaps) and just solid lines
530 m_cap = kCGLineCapButt;
531 }
532 }
533
534 wxMacCoreGraphicsPenData::~wxMacCoreGraphicsPenData()
535 {
536 delete[] m_userLengths;
537 delete[] m_patternColorComponents;
538 }
539
540 void wxMacCoreGraphicsPenData::Init()
541 {
542 m_lengths = NULL;
543 m_userLengths = NULL;
544 m_width = 0;
545 m_count = 0;
546 m_patternColorComponents = NULL;
547 m_isPattern = false;
548 }
549
550 void wxMacCoreGraphicsPenData::Apply( wxGraphicsContext* context )
551 {
552 CGContextRef cg = (CGContextRef) context->GetNativeContext();
553 CGContextSetLineWidth( cg , m_width );
554 CGContextSetLineJoin( cg , m_join );
555
556 CGContextSetLineDash( cg , 0 , m_lengths , m_count );
557 CGContextSetLineCap( cg , m_cap );
558
559 if ( m_isPattern )
560 {
561 CGAffineTransform matrix = CGContextGetCTM( cg );
562 CGContextSetPatternPhase( cg, CGSizeMake(matrix.tx, matrix.ty) );
563 CGContextSetStrokeColorSpace( cg , m_colorSpace );
564 CGContextSetStrokePattern( cg, m_pattern , m_patternColorComponents );
565 }
566 else
567 {
568 CGContextSetStrokeColorWithColor( cg , m_color );
569 }
570 }
571
572 //
573 // Brush
574 //
575
576 // make sure we all use one class for all conversions from wx to native colour
577
578 class wxMacCoreGraphicsColour
579 {
580 public:
581 wxMacCoreGraphicsColour();
582 wxMacCoreGraphicsColour(const wxBrush &brush);
583 ~wxMacCoreGraphicsColour();
584
585 void Apply( CGContextRef cgContext );
586 protected:
587 void Init();
588 wxCFRef<CGColorRef> m_color;
589 wxCFRef<CGColorSpaceRef> m_colorSpace;
590
591 bool m_isPattern;
592 wxCFRef<CGPatternRef> m_pattern;
593 CGFloat* m_patternColorComponents;
594 } ;
595
596 wxMacCoreGraphicsColour::~wxMacCoreGraphicsColour()
597 {
598 delete[] m_patternColorComponents;
599 }
600
601 void wxMacCoreGraphicsColour::Init()
602 {
603 m_isPattern = false;
604 m_patternColorComponents = NULL;
605 }
606
607 void wxMacCoreGraphicsColour::Apply( CGContextRef cgContext )
608 {
609 if ( m_isPattern )
610 {
611 CGAffineTransform matrix = CGContextGetCTM( cgContext );
612 CGContextSetPatternPhase( cgContext, CGSizeMake(matrix.tx, matrix.ty) );
613 CGContextSetFillColorSpace( cgContext , m_colorSpace );
614 CGContextSetFillPattern( cgContext, m_pattern , m_patternColorComponents );
615 }
616 else
617 {
618 CGContextSetFillColorWithColor( cgContext, m_color );
619 }
620 }
621
622 wxMacCoreGraphicsColour::wxMacCoreGraphicsColour()
623 {
624 Init();
625 }
626
627 wxMacCoreGraphicsColour::wxMacCoreGraphicsColour( const wxBrush &brush )
628 {
629 Init();
630 if ( brush.GetStyle() == wxSOLID )
631 {
632 m_color.reset( wxMacCreateCGColor( brush.GetColour() ));
633 }
634 else if ( brush.IsHatch() )
635 {
636 m_isPattern = true;
637 m_colorSpace.reset( CGColorSpaceCreatePattern( wxMacGetGenericRGBColorSpace() ) );
638 m_pattern.reset( (CGPatternRef) *( new HatchPattern( brush.GetStyle() , CGAffineTransformMakeScale( 1,-1 ) ) ) );
639
640 m_patternColorComponents = new CGFloat[4] ;
641 m_patternColorComponents[0] = (CGFloat) (brush.GetColour().Red() / 255.0);
642 m_patternColorComponents[1] = (CGFloat) (brush.GetColour().Green() / 255.0);
643 m_patternColorComponents[2] = (CGFloat) (brush.GetColour().Blue() / 255.0);
644 m_patternColorComponents[3] = (CGFloat) (brush.GetColour().Alpha() / 255.0);
645 }
646 else
647 {
648 // now brush is a bitmap
649 wxBitmap* bmp = brush.GetStipple();
650 if ( bmp && bmp->Ok() )
651 {
652 m_isPattern = true;
653 m_patternColorComponents = new CGFloat[1] ;
654 m_patternColorComponents[0] = (CGFloat) 1.0;
655 m_colorSpace.reset( CGColorSpaceCreatePattern( NULL ) );
656 m_pattern.reset( (CGPatternRef) *( new ImagePattern( bmp , CGAffineTransformMakeScale( 1,-1 ) ) ) );
657 }
658 }
659 }
660
661 class wxMacCoreGraphicsBrushData : public wxGraphicsObjectRefData
662 {
663 public:
664 wxMacCoreGraphicsBrushData( wxGraphicsRenderer* renderer );
665 wxMacCoreGraphicsBrushData( wxGraphicsRenderer* renderer, const wxBrush &brush );
666 ~wxMacCoreGraphicsBrushData ();
667
668 virtual void Apply( wxGraphicsContext* context );
669 void CreateLinearGradientBrush(wxDouble x1, wxDouble y1,
670 wxDouble x2, wxDouble y2,
671 const wxGraphicsGradientStops& stops);
672 void CreateRadialGradientBrush(wxDouble xo, wxDouble yo,
673 wxDouble xc, wxDouble yc, wxDouble radius,
674 const wxGraphicsGradientStops& stops);
675
676 virtual bool IsShading() { return m_isShading; }
677 CGShadingRef GetShading() { return m_shading; }
678 protected:
679 CGFunctionRef CreateGradientFunction(const wxGraphicsGradientStops& stops);
680
681 static void CalculateShadingValues (void *info, const CGFloat *in, CGFloat *out);
682 virtual void Init();
683
684 wxMacCoreGraphicsColour m_cgColor;
685
686 bool m_isShading;
687 CGFunctionRef m_gradientFunction;
688 CGShadingRef m_shading;
689
690 // information about a single gradient component
691 struct GradientComponent
692 {
693 CGFloat pos;
694 CGFloat red;
695 CGFloat green;
696 CGFloat blue;
697 CGFloat alpha;
698 };
699
700 // and information about all of them
701 struct GradientComponents
702 {
703 GradientComponents()
704 {
705 count = 0;
706 comps = NULL;
707 }
708
709 void Init(unsigned count_)
710 {
711 count = count_;
712 comps = new GradientComponent[count];
713 }
714
715 ~GradientComponents()
716 {
717 delete [] comps;
718 }
719
720 unsigned count;
721 GradientComponent *comps;
722 };
723
724 GradientComponents m_gradientComponents;
725 };
726
727 wxMacCoreGraphicsBrushData::wxMacCoreGraphicsBrushData( wxGraphicsRenderer* renderer) : wxGraphicsObjectRefData( renderer )
728 {
729 Init();
730 }
731
732 void
733 wxMacCoreGraphicsBrushData::CreateLinearGradientBrush(wxDouble x1, wxDouble y1,
734 wxDouble x2, wxDouble y2,
735 const wxGraphicsGradientStops& stops)
736 {
737 m_gradientFunction = CreateGradientFunction(stops);
738 m_shading = CGShadingCreateAxial( wxMacGetGenericRGBColorSpace(), CGPointMake((CGFloat) x1, (CGFloat) y1),
739 CGPointMake((CGFloat) x2,(CGFloat) y2), m_gradientFunction, true, true ) ;
740 m_isShading = true ;
741 }
742
743 void
744 wxMacCoreGraphicsBrushData::CreateRadialGradientBrush(wxDouble xo, wxDouble yo,
745 wxDouble xc, wxDouble yc,
746 wxDouble radius,
747 const wxGraphicsGradientStops& stops)
748 {
749 m_gradientFunction = CreateGradientFunction(stops);
750 m_shading = CGShadingCreateRadial( wxMacGetGenericRGBColorSpace(), CGPointMake((CGFloat) xo,(CGFloat) yo), 0,
751 CGPointMake((CGFloat) xc,(CGFloat) yc), (CGFloat) radius, m_gradientFunction, true, true ) ;
752 m_isShading = true ;
753 }
754
755 wxMacCoreGraphicsBrushData::wxMacCoreGraphicsBrushData(wxGraphicsRenderer* renderer, const wxBrush &brush) : wxGraphicsObjectRefData( renderer ),
756 m_cgColor( brush )
757 {
758 Init();
759
760 }
761
762 wxMacCoreGraphicsBrushData::~wxMacCoreGraphicsBrushData()
763 {
764 if ( m_shading )
765 CGShadingRelease(m_shading);
766
767 if( m_gradientFunction )
768 CGFunctionRelease(m_gradientFunction);
769 }
770
771 void wxMacCoreGraphicsBrushData::Init()
772 {
773 m_gradientFunction = NULL;
774 m_shading = NULL;
775 m_isShading = false;
776 }
777
778 void wxMacCoreGraphicsBrushData::Apply( wxGraphicsContext* context )
779 {
780 CGContextRef cg = (CGContextRef) context->GetNativeContext();
781
782 if ( m_isShading )
783 {
784 // nothing to set as shades are processed by clipping using the path and filling
785 }
786 else
787 {
788 m_cgColor.Apply( cg );
789 }
790 }
791
792 void wxMacCoreGraphicsBrushData::CalculateShadingValues (void *info, const CGFloat *in, CGFloat *out)
793 {
794 const GradientComponents& stops = *(GradientComponents*) info ;
795
796 CGFloat f = *in;
797 if (f <= 0.0)
798 {
799 // Start
800 out[0] = stops.comps[0].red;
801 out[1] = stops.comps[0].green;
802 out[2] = stops.comps[0].blue;
803 out[3] = stops.comps[0].alpha;
804 }
805 else if (f >= 1.0)
806 {
807 // end
808 out[0] = stops.comps[stops.count - 1].red;
809 out[1] = stops.comps[stops.count - 1].green;
810 out[2] = stops.comps[stops.count - 1].blue;
811 out[3] = stops.comps[stops.count - 1].alpha;
812 }
813 else
814 {
815 // Find first component with position greater than f
816 unsigned i;
817 for ( i = 0; i < stops.count; i++ )
818 {
819 if (stops.comps[i].pos > f)
820 break;
821 }
822
823 // Interpolated between stops
824 CGFloat diff = (f - stops.comps[i-1].pos);
825 CGFloat range = (stops.comps[i].pos - stops.comps[i-1].pos);
826 CGFloat fact = diff / range;
827
828 out[0] = stops.comps[i - 1].red + (stops.comps[i].red - stops.comps[i - 1].red) * fact;
829 out[1] = stops.comps[i - 1].green + (stops.comps[i].green - stops.comps[i - 1].green) * fact;
830 out[2] = stops.comps[i - 1].blue + (stops.comps[i].blue - stops.comps[i - 1].blue) * fact;
831 out[3] = stops.comps[i - 1].alpha + (stops.comps[i].alpha - stops.comps[i - 1].alpha) * fact;
832 }
833 }
834
835 CGFunctionRef
836 wxMacCoreGraphicsBrushData::CreateGradientFunction(const wxGraphicsGradientStops& stops)
837 {
838
839 static const CGFunctionCallbacks callbacks = { 0, &CalculateShadingValues, NULL };
840 static const CGFloat input_value_range [2] = { 0, 1 };
841 static const CGFloat output_value_ranges [8] = { 0, 1, 0, 1, 0, 1, 0, 1 };
842
843 m_gradientComponents.Init(stops.GetCount());
844 for ( unsigned i = 0; i < m_gradientComponents.count; i++ )
845 {
846 const wxGraphicsGradientStop stop = stops.Item(i);
847
848 m_gradientComponents.comps[i].pos = stop.GetPosition();
849
850 const wxColour col = stop.GetColour();
851 m_gradientComponents.comps[i].red = (CGFloat) (col.Red() / 255.0);
852 m_gradientComponents.comps[i].green = (CGFloat) (col.Green() / 255.0);
853 m_gradientComponents.comps[i].blue = (CGFloat) (col.Blue() / 255.0);
854 m_gradientComponents.comps[i].alpha = (CGFloat) (col.Alpha() / 255.0);
855 }
856
857 return CGFunctionCreate ( &m_gradientComponents, 1,
858 input_value_range,
859 4,
860 output_value_ranges,
861 &callbacks);
862 }
863
864 //
865 // Font
866 //
867
868 #if wxOSX_USE_IPHONE
869
870 extern UIFont* CreateUIFont( const wxFont& font );
871 extern void DrawTextInContext( CGContextRef context, CGPoint where, UIFont *font, NSString* text );
872 extern CGSize MeasureTextInContext( UIFont *font, NSString* text );
873
874 #endif
875
876 class wxMacCoreGraphicsFontData : public wxGraphicsObjectRefData
877 {
878 public:
879 wxMacCoreGraphicsFontData( wxGraphicsRenderer* renderer, const wxFont &font, const wxColour& col );
880 ~wxMacCoreGraphicsFontData();
881
882 #if wxOSX_USE_ATSU_TEXT
883 virtual ATSUStyle GetATSUStyle() { return m_macATSUIStyle; }
884 #endif
885 #if wxOSX_USE_CORE_TEXT
886 CTFontRef OSXGetCTFont() const { return m_ctFont ; }
887 #endif
888 wxColour GetColour() const { return m_colour ; }
889
890 bool GetUnderlined() const { return m_underlined ; }
891 #if wxOSX_USE_IPHONE
892 UIFont* GetUIFont() const { return m_uiFont; }
893 #endif
894 private :
895 wxColour m_colour;
896 bool m_underlined;
897 #if wxOSX_USE_ATSU_TEXT
898 ATSUStyle m_macATSUIStyle;
899 #endif
900 #if wxOSX_USE_CORE_TEXT
901 wxCFRef< CTFontRef > m_ctFont;
902 #endif
903 #if wxOSX_USE_IPHONE
904 UIFont* m_uiFont;
905 #endif
906 };
907
908 wxMacCoreGraphicsFontData::wxMacCoreGraphicsFontData(wxGraphicsRenderer* renderer, const wxFont &font, const wxColour& col) : wxGraphicsObjectRefData( renderer )
909 {
910 m_colour = col;
911 m_underlined = font.GetUnderlined();
912
913 #if wxOSX_USE_CORE_TEXT
914 m_ctFont.reset( wxMacCreateCTFont( font ) );
915 #endif
916 #if wxOSX_USE_IPHONE
917 m_uiFont = CreateUIFont(font);
918 wxMacCocoaRetain( m_uiFont );
919 #endif
920 #if wxOSX_USE_ATSU_TEXT
921 OSStatus status = noErr;
922 m_macATSUIStyle = NULL;
923
924 status = ATSUCreateAndCopyStyle( (ATSUStyle) font.MacGetATSUStyle() , &m_macATSUIStyle );
925
926 wxASSERT_MSG( status == noErr, wxT("couldn't create ATSU style") );
927
928 // we need the scale here ...
929
930 Fixed atsuSize = IntToFixed( int( 1 * font.GetPointSize()) );
931 RGBColor atsuColor ;
932 col.GetRGBColor( &atsuColor );
933 ATSUAttributeTag atsuTags[] =
934 {
935 kATSUSizeTag ,
936 kATSUColorTag ,
937 };
938 ByteCount atsuSizes[WXSIZEOF(atsuTags)] =
939 {
940 sizeof( Fixed ) ,
941 sizeof( RGBColor ) ,
942 };
943 ATSUAttributeValuePtr atsuValues[WXSIZEOF(atsuTags)] =
944 {
945 &atsuSize ,
946 &atsuColor ,
947 };
948
949 status = ::ATSUSetAttributes(
950 m_macATSUIStyle, WXSIZEOF(atsuTags),
951 atsuTags, atsuSizes, atsuValues);
952
953 wxASSERT_MSG( status == noErr , wxT("couldn't modify ATSU style") );
954 #endif
955 }
956
957 wxMacCoreGraphicsFontData::~wxMacCoreGraphicsFontData()
958 {
959 #if wxOSX_USE_CORE_TEXT
960 #endif
961 #if wxOSX_USE_ATSU_TEXT
962 if ( m_macATSUIStyle )
963 {
964 ::ATSUDisposeStyle((ATSUStyle)m_macATSUIStyle);
965 m_macATSUIStyle = NULL;
966 }
967 #endif
968 #if wxOSX_USE_IPHONE
969 wxMacCocoaRelease( m_uiFont );
970 #endif
971 }
972
973 class wxMacCoreGraphicsBitmapData : public wxGraphicsObjectRefData
974 {
975 public:
976 wxMacCoreGraphicsBitmapData( wxGraphicsRenderer* renderer, CGImageRef bitmap, bool monochrome );
977 ~wxMacCoreGraphicsBitmapData();
978
979 virtual CGImageRef GetBitmap() { return m_bitmap; }
980 bool IsMonochrome() { return m_monochrome; }
981 private :
982 CGImageRef m_bitmap;
983 bool m_monochrome;
984 };
985
986 wxMacCoreGraphicsBitmapData::wxMacCoreGraphicsBitmapData( wxGraphicsRenderer* renderer, CGImageRef bitmap, bool monochrome ) : wxGraphicsObjectRefData( renderer ),
987 m_bitmap(bitmap), m_monochrome(monochrome)
988 {
989 }
990
991 wxMacCoreGraphicsBitmapData::~wxMacCoreGraphicsBitmapData()
992 {
993 CGImageRelease( m_bitmap );
994 }
995
996 //
997 // Graphics Matrix
998 //
999
1000 //-----------------------------------------------------------------------------
1001 // wxMacCoreGraphicsMatrix declaration
1002 //-----------------------------------------------------------------------------
1003
1004 class WXDLLIMPEXP_CORE wxMacCoreGraphicsMatrixData : public wxGraphicsMatrixData
1005 {
1006 public :
1007 wxMacCoreGraphicsMatrixData(wxGraphicsRenderer* renderer) ;
1008
1009 virtual ~wxMacCoreGraphicsMatrixData() ;
1010
1011 virtual wxGraphicsObjectRefData *Clone() const ;
1012
1013 // concatenates the matrix
1014 virtual void Concat( const wxGraphicsMatrixData *t );
1015
1016 // sets the matrix to the respective values
1017 virtual void Set(wxDouble a=1.0, wxDouble b=0.0, wxDouble c=0.0, wxDouble d=1.0,
1018 wxDouble tx=0.0, wxDouble ty=0.0);
1019
1020 // gets the component valuess of the matrix
1021 virtual void Get(wxDouble* a=NULL, wxDouble* b=NULL, wxDouble* c=NULL,
1022 wxDouble* d=NULL, wxDouble* tx=NULL, wxDouble* ty=NULL) const;
1023
1024 // makes this the inverse matrix
1025 virtual void Invert();
1026
1027 // returns true if the elements of the transformation matrix are equal ?
1028 virtual bool IsEqual( const wxGraphicsMatrixData* t) const ;
1029
1030 // return true if this is the identity matrix
1031 virtual bool IsIdentity() const;
1032
1033 //
1034 // transformation
1035 //
1036
1037 // add the translation to this matrix
1038 virtual void Translate( wxDouble dx , wxDouble dy );
1039
1040 // add the scale to this matrix
1041 virtual void Scale( wxDouble xScale , wxDouble yScale );
1042
1043 // add the rotation to this matrix (radians)
1044 virtual void Rotate( wxDouble angle );
1045
1046 //
1047 // apply the transforms
1048 //
1049
1050 // applies that matrix to the point
1051 virtual void TransformPoint( wxDouble *x, wxDouble *y ) const;
1052
1053 // applies the matrix except for translations
1054 virtual void TransformDistance( wxDouble *dx, wxDouble *dy ) const;
1055
1056 // returns the native representation
1057 virtual void * GetNativeMatrix() const;
1058
1059 private :
1060 CGAffineTransform m_matrix;
1061 } ;
1062
1063 //-----------------------------------------------------------------------------
1064 // wxMacCoreGraphicsMatrix implementation
1065 //-----------------------------------------------------------------------------
1066
1067 wxMacCoreGraphicsMatrixData::wxMacCoreGraphicsMatrixData(wxGraphicsRenderer* renderer) : wxGraphicsMatrixData(renderer)
1068 {
1069 }
1070
1071 wxMacCoreGraphicsMatrixData::~wxMacCoreGraphicsMatrixData()
1072 {
1073 }
1074
1075 wxGraphicsObjectRefData *wxMacCoreGraphicsMatrixData::Clone() const
1076 {
1077 wxMacCoreGraphicsMatrixData* m = new wxMacCoreGraphicsMatrixData(GetRenderer()) ;
1078 m->m_matrix = m_matrix ;
1079 return m;
1080 }
1081
1082 // concatenates the matrix
1083 void wxMacCoreGraphicsMatrixData::Concat( const wxGraphicsMatrixData *t )
1084 {
1085 m_matrix = CGAffineTransformConcat(*((CGAffineTransform*) t->GetNativeMatrix()), m_matrix );
1086 }
1087
1088 // sets the matrix to the respective values
1089 void wxMacCoreGraphicsMatrixData::Set(wxDouble a, wxDouble b, wxDouble c, wxDouble d,
1090 wxDouble tx, wxDouble ty)
1091 {
1092 m_matrix = CGAffineTransformMake((CGFloat) a,(CGFloat) b,(CGFloat) c,(CGFloat) d,(CGFloat) tx,(CGFloat) ty);
1093 }
1094
1095 // gets the component valuess of the matrix
1096 void wxMacCoreGraphicsMatrixData::Get(wxDouble* a, wxDouble* b, wxDouble* c,
1097 wxDouble* d, wxDouble* tx, wxDouble* ty) const
1098 {
1099 if (a) *a = m_matrix.a;
1100 if (b) *b = m_matrix.b;
1101 if (c) *c = m_matrix.c;
1102 if (d) *d = m_matrix.d;
1103 if (tx) *tx= m_matrix.tx;
1104 if (ty) *ty= m_matrix.ty;
1105 }
1106
1107 // makes this the inverse matrix
1108 void wxMacCoreGraphicsMatrixData::Invert()
1109 {
1110 m_matrix = CGAffineTransformInvert( m_matrix );
1111 }
1112
1113 // returns true if the elements of the transformation matrix are equal ?
1114 bool wxMacCoreGraphicsMatrixData::IsEqual( const wxGraphicsMatrixData* t) const
1115 {
1116 return CGAffineTransformEqualToTransform(m_matrix, *((CGAffineTransform*) t->GetNativeMatrix()));
1117 }
1118
1119 // return true if this is the identity matrix
1120 bool wxMacCoreGraphicsMatrixData::IsIdentity() const
1121 {
1122 return ( m_matrix.a == 1 && m_matrix.d == 1 &&
1123 m_matrix.b == 0 && m_matrix.d == 0 && m_matrix.tx == 0 && m_matrix.ty == 0);
1124 }
1125
1126 //
1127 // transformation
1128 //
1129
1130 // add the translation to this matrix
1131 void wxMacCoreGraphicsMatrixData::Translate( wxDouble dx , wxDouble dy )
1132 {
1133 m_matrix = CGAffineTransformTranslate( m_matrix, (CGFloat) dx, (CGFloat) dy);
1134 }
1135
1136 // add the scale to this matrix
1137 void wxMacCoreGraphicsMatrixData::Scale( wxDouble xScale , wxDouble yScale )
1138 {
1139 m_matrix = CGAffineTransformScale( m_matrix, (CGFloat) xScale, (CGFloat) yScale);
1140 }
1141
1142 // add the rotation to this matrix (radians)
1143 void wxMacCoreGraphicsMatrixData::Rotate( wxDouble angle )
1144 {
1145 m_matrix = CGAffineTransformRotate( m_matrix, (CGFloat) angle);
1146 }
1147
1148 //
1149 // apply the transforms
1150 //
1151
1152 // applies that matrix to the point
1153 void wxMacCoreGraphicsMatrixData::TransformPoint( wxDouble *x, wxDouble *y ) const
1154 {
1155 CGPoint pt = CGPointApplyAffineTransform( CGPointMake((CGFloat) *x,(CGFloat) *y), m_matrix);
1156
1157 *x = pt.x;
1158 *y = pt.y;
1159 }
1160
1161 // applies the matrix except for translations
1162 void wxMacCoreGraphicsMatrixData::TransformDistance( wxDouble *dx, wxDouble *dy ) const
1163 {
1164 CGSize sz = CGSizeApplyAffineTransform( CGSizeMake((CGFloat) *dx,(CGFloat) *dy) , m_matrix );
1165 *dx = sz.width;
1166 *dy = sz.height;
1167 }
1168
1169 // returns the native representation
1170 void * wxMacCoreGraphicsMatrixData::GetNativeMatrix() const
1171 {
1172 return (void*) &m_matrix;
1173 }
1174
1175 //
1176 // Graphics Path
1177 //
1178
1179 //-----------------------------------------------------------------------------
1180 // wxMacCoreGraphicsPath declaration
1181 //-----------------------------------------------------------------------------
1182
1183 class WXDLLEXPORT wxMacCoreGraphicsPathData : public wxGraphicsPathData
1184 {
1185 public :
1186 wxMacCoreGraphicsPathData( wxGraphicsRenderer* renderer, CGMutablePathRef path = NULL);
1187
1188 ~wxMacCoreGraphicsPathData();
1189
1190 virtual wxGraphicsObjectRefData *Clone() const;
1191
1192 // begins a new subpath at (x,y)
1193 virtual void MoveToPoint( wxDouble x, wxDouble y );
1194
1195 // adds a straight line from the current point to (x,y)
1196 virtual void AddLineToPoint( wxDouble x, wxDouble y );
1197
1198 // adds a cubic Bezier curve from the current point, using two control points and an end point
1199 virtual void AddCurveToPoint( wxDouble cx1, wxDouble cy1, wxDouble cx2, wxDouble cy2, wxDouble x, wxDouble y );
1200
1201 // closes the current sub-path
1202 virtual void CloseSubpath();
1203
1204 // gets the last point of the current path, (0,0) if not yet set
1205 virtual void GetCurrentPoint( wxDouble* x, wxDouble* y) const;
1206
1207 // adds an arc of a circle centering at (x,y) with radius (r) from startAngle to endAngle
1208 virtual void AddArc( wxDouble x, wxDouble y, wxDouble r, wxDouble startAngle, wxDouble endAngle, bool clockwise );
1209
1210 //
1211 // These are convenience functions which - if not available natively will be assembled
1212 // using the primitives from above
1213 //
1214
1215 // adds a quadratic Bezier curve from the current point, using a control point and an end point
1216 virtual void AddQuadCurveToPoint( wxDouble cx, wxDouble cy, wxDouble x, wxDouble y );
1217
1218 // appends a rectangle as a new closed subpath
1219 virtual void AddRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h );
1220
1221 // appends a circle as a new closed subpath
1222 virtual void AddCircle( wxDouble x, wxDouble y, wxDouble r );
1223
1224 // appends an ellipsis as a new closed subpath fitting the passed rectangle
1225 virtual void AddEllipse( wxDouble x, wxDouble y, wxDouble w, wxDouble h);
1226
1227 // draws a an arc to two tangents connecting (current) to (x1,y1) and (x1,y1) to (x2,y2), also a straight line from (current) to (x1,y1)
1228 virtual void AddArcToPoint( wxDouble x1, wxDouble y1 , wxDouble x2, wxDouble y2, wxDouble r );
1229
1230 // adds another path
1231 virtual void AddPath( const wxGraphicsPathData* path );
1232
1233 // returns the native path
1234 virtual void * GetNativePath() const { return m_path; }
1235
1236 // give the native path returned by GetNativePath() back (there might be some deallocations necessary)
1237 virtual void UnGetNativePath(void *WXUNUSED(p)) const {}
1238
1239 // transforms each point of this path by the matrix
1240 virtual void Transform( const wxGraphicsMatrixData* matrix );
1241
1242 // gets the bounding box enclosing all points (possibly including control points)
1243 virtual void GetBox(wxDouble *x, wxDouble *y, wxDouble *w, wxDouble *h) const;
1244
1245 virtual bool Contains( wxDouble x, wxDouble y, wxPolygonFillMode fillStyle = wxODDEVEN_RULE) const;
1246 private :
1247 CGMutablePathRef m_path;
1248 };
1249
1250 //-----------------------------------------------------------------------------
1251 // wxMacCoreGraphicsPath implementation
1252 //-----------------------------------------------------------------------------
1253
1254 wxMacCoreGraphicsPathData::wxMacCoreGraphicsPathData( wxGraphicsRenderer* renderer, CGMutablePathRef path) : wxGraphicsPathData(renderer)
1255 {
1256 if ( path )
1257 m_path = path;
1258 else
1259 m_path = CGPathCreateMutable();
1260 }
1261
1262 wxMacCoreGraphicsPathData::~wxMacCoreGraphicsPathData()
1263 {
1264 CGPathRelease( m_path );
1265 }
1266
1267 wxGraphicsObjectRefData* wxMacCoreGraphicsPathData::Clone() const
1268 {
1269 wxMacCoreGraphicsPathData* clone = new wxMacCoreGraphicsPathData(GetRenderer(),CGPathCreateMutableCopy(m_path));
1270 return clone ;
1271 }
1272
1273
1274 // opens (starts) a new subpath
1275 void wxMacCoreGraphicsPathData::MoveToPoint( wxDouble x1 , wxDouble y1 )
1276 {
1277 CGPathMoveToPoint( m_path , NULL , (CGFloat) x1 , (CGFloat) y1 );
1278 }
1279
1280 void wxMacCoreGraphicsPathData::AddLineToPoint( wxDouble x1 , wxDouble y1 )
1281 {
1282 CGPathAddLineToPoint( m_path , NULL , (CGFloat) x1 , (CGFloat) y1 );
1283 }
1284
1285 void wxMacCoreGraphicsPathData::AddCurveToPoint( wxDouble cx1, wxDouble cy1, wxDouble cx2, wxDouble cy2, wxDouble x, wxDouble y )
1286 {
1287 CGPathAddCurveToPoint( m_path , NULL , (CGFloat) cx1 , (CGFloat) cy1 , (CGFloat) cx2, (CGFloat) cy2, (CGFloat) x , (CGFloat) y );
1288 }
1289
1290 void wxMacCoreGraphicsPathData::AddQuadCurveToPoint( wxDouble cx1, wxDouble cy1, wxDouble x, wxDouble y )
1291 {
1292 CGPathAddQuadCurveToPoint( m_path , NULL , (CGFloat) cx1 , (CGFloat) cy1 , (CGFloat) x , (CGFloat) y );
1293 }
1294
1295 void wxMacCoreGraphicsPathData::AddRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h )
1296 {
1297 CGRect cgRect = { { (CGFloat) x , (CGFloat) y } , { (CGFloat) w , (CGFloat) h } };
1298 CGPathAddRect( m_path , NULL , cgRect );
1299 }
1300
1301 void wxMacCoreGraphicsPathData::AddCircle( wxDouble x, wxDouble y , wxDouble r )
1302 {
1303 CGPathAddEllipseInRect( m_path, NULL, CGRectMake(x-r,y-r,2*r,2*r));
1304 }
1305
1306 void wxMacCoreGraphicsPathData::AddEllipse( wxDouble x, wxDouble y, wxDouble w, wxDouble h )
1307 {
1308 CGPathAddEllipseInRect( m_path, NULL, CGRectMake(x,y,w,h));
1309 }
1310
1311 // adds an arc of a circle centering at (x,y) with radius (r) from startAngle to endAngle
1312 void wxMacCoreGraphicsPathData::AddArc( wxDouble x, wxDouble y, wxDouble r, wxDouble startAngle, wxDouble endAngle, bool clockwise )
1313 {
1314 // inverse direction as we the 'normal' state is a y axis pointing down, ie mirrored to the standard core graphics setup
1315 CGPathAddArc( m_path, NULL , (CGFloat) x, (CGFloat) y, (CGFloat) r, (CGFloat) startAngle, (CGFloat) endAngle, !clockwise);
1316 }
1317
1318 void wxMacCoreGraphicsPathData::AddArcToPoint( wxDouble x1, wxDouble y1 , wxDouble x2, wxDouble y2, wxDouble r )
1319 {
1320 CGPathAddArcToPoint( m_path, NULL , (CGFloat) x1, (CGFloat) y1, (CGFloat) x2, (CGFloat) y2, (CGFloat) r);
1321 }
1322
1323 void wxMacCoreGraphicsPathData::AddPath( const wxGraphicsPathData* path )
1324 {
1325 CGPathAddPath( m_path , NULL, (CGPathRef) path->GetNativePath() );
1326 }
1327
1328 // closes the current subpath
1329 void wxMacCoreGraphicsPathData::CloseSubpath()
1330 {
1331 CGPathCloseSubpath( m_path );
1332 }
1333
1334 // gets the last point of the current path, (0,0) if not yet set
1335 void wxMacCoreGraphicsPathData::GetCurrentPoint( wxDouble* x, wxDouble* y) const
1336 {
1337 CGPoint p = CGPathGetCurrentPoint( m_path );
1338 *x = p.x;
1339 *y = p.y;
1340 }
1341
1342 // transforms each point of this path by the matrix
1343 void wxMacCoreGraphicsPathData::Transform( const wxGraphicsMatrixData* matrix )
1344 {
1345 CGMutablePathRef p = CGPathCreateMutable() ;
1346 CGPathAddPath( p, (CGAffineTransform*) matrix->GetNativeMatrix() , m_path );
1347 CGPathRelease( m_path );
1348 m_path = p;
1349 }
1350
1351 // gets the bounding box enclosing all points (possibly including control points)
1352 void wxMacCoreGraphicsPathData::GetBox(wxDouble *x, wxDouble *y, wxDouble *w, wxDouble *h) const
1353 {
1354 CGRect bounds = CGPathGetBoundingBox( m_path ) ;
1355 *x = bounds.origin.x;
1356 *y = bounds.origin.y;
1357 *w = bounds.size.width;
1358 *h = bounds.size.height;
1359 }
1360
1361 bool wxMacCoreGraphicsPathData::Contains( wxDouble x, wxDouble y, wxPolygonFillMode fillStyle) const
1362 {
1363 return CGPathContainsPoint( m_path, NULL, CGPointMake((CGFloat) x,(CGFloat) y), fillStyle == wxODDEVEN_RULE );
1364 }
1365
1366 //
1367 // Graphics Context
1368 //
1369
1370 //-----------------------------------------------------------------------------
1371 // wxMacCoreGraphicsContext declaration
1372 //-----------------------------------------------------------------------------
1373
1374 class WXDLLEXPORT wxMacCoreGraphicsContext : public wxGraphicsContext
1375 {
1376 public:
1377 wxMacCoreGraphicsContext( wxGraphicsRenderer* renderer, CGContextRef cgcontext, wxDouble width = 0, wxDouble height = 0 );
1378
1379 #if wxOSX_USE_CARBON
1380 wxMacCoreGraphicsContext( wxGraphicsRenderer* renderer, WindowRef window );
1381 #endif
1382
1383 wxMacCoreGraphicsContext( wxGraphicsRenderer* renderer, wxWindow* window );
1384
1385 wxMacCoreGraphicsContext( wxGraphicsRenderer* renderer);
1386
1387 wxMacCoreGraphicsContext();
1388
1389 ~wxMacCoreGraphicsContext();
1390
1391 void Init();
1392
1393 virtual void StartPage( wxDouble width, wxDouble height );
1394
1395 virtual void EndPage();
1396
1397 virtual void Flush();
1398
1399 // push the current state of the context, ie the transformation matrix on a stack
1400 virtual void PushState();
1401
1402 // pops a stored state from the stack
1403 virtual void PopState();
1404
1405 // clips drawings to the region
1406 virtual void Clip( const wxRegion &region );
1407
1408 // clips drawings to the rect
1409 virtual void Clip( wxDouble x, wxDouble y, wxDouble w, wxDouble h );
1410
1411 // resets the clipping to original extent
1412 virtual void ResetClip();
1413
1414 virtual void * GetNativeContext();
1415
1416 virtual bool SetAntialiasMode(wxAntialiasMode antialias);
1417
1418 virtual bool SetCompositionMode(wxCompositionMode op);
1419
1420 virtual void BeginLayer(wxDouble opacity);
1421
1422 virtual void EndLayer();
1423
1424 //
1425 // transformation
1426 //
1427
1428 // translate
1429 virtual void Translate( wxDouble dx , wxDouble dy );
1430
1431 // scale
1432 virtual void Scale( wxDouble xScale , wxDouble yScale );
1433
1434 // rotate (radians)
1435 virtual void Rotate( wxDouble angle );
1436
1437 // concatenates this transform with the current transform of this context
1438 virtual void ConcatTransform( const wxGraphicsMatrix& matrix );
1439
1440 // sets the transform of this context
1441 virtual void SetTransform( const wxGraphicsMatrix& matrix );
1442
1443 // gets the matrix of this context
1444 virtual wxGraphicsMatrix GetTransform() const;
1445 //
1446 // setting the paint
1447 //
1448
1449 // strokes along a path with the current pen
1450 virtual void StrokePath( const wxGraphicsPath &path );
1451
1452 // fills a path with the current brush
1453 virtual void FillPath( const wxGraphicsPath &path, wxPolygonFillMode fillStyle = wxODDEVEN_RULE );
1454
1455 // draws a path by first filling and then stroking
1456 virtual void DrawPath( const wxGraphicsPath &path, wxPolygonFillMode fillStyle = wxODDEVEN_RULE );
1457
1458 virtual bool ShouldOffset() const
1459 {
1460 int penwidth = 0 ;
1461 if ( !m_pen.IsNull() )
1462 {
1463 penwidth = (int)((wxMacCoreGraphicsPenData*)m_pen.GetRefData())->GetWidth();
1464 if ( penwidth == 0 )
1465 penwidth = 1;
1466 }
1467 return ( penwidth % 2 ) == 1;
1468 }
1469 //
1470 // text
1471 //
1472
1473 virtual void GetTextExtent( const wxString &text, wxDouble *width, wxDouble *height,
1474 wxDouble *descent, wxDouble *externalLeading ) const;
1475
1476 virtual void GetPartialTextExtents(const wxString& text, wxArrayDouble& widths) const;
1477
1478 //
1479 // image support
1480 //
1481
1482 virtual void DrawBitmap( const wxBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h );
1483
1484 virtual void DrawBitmap( const wxGraphicsBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h );
1485
1486 virtual void DrawIcon( const wxIcon &icon, wxDouble x, wxDouble y, wxDouble w, wxDouble h );
1487
1488 void SetNativeContext( CGContextRef cg );
1489
1490 DECLARE_DYNAMIC_CLASS_NO_COPY(wxMacCoreGraphicsContext)
1491
1492 private:
1493 bool EnsureIsValid();
1494
1495 virtual void DoDrawText( const wxString &str, wxDouble x, wxDouble y );
1496 virtual void DoDrawRotatedText( const wxString &str, wxDouble x, wxDouble y, wxDouble angle );
1497
1498 CGContextRef m_cgContext;
1499 #if wxOSX_USE_CARBON
1500 WindowRef m_windowRef;
1501 #else
1502 WXWidget m_view;
1503 #endif
1504 bool m_contextSynthesized;
1505 CGAffineTransform m_windowTransform;
1506 bool m_invisible;
1507
1508 #if wxOSX_USE_COCOA_OR_CARBON
1509 wxCFRef<HIShapeRef> m_clipRgn;
1510 #endif
1511 };
1512
1513 //-----------------------------------------------------------------------------
1514 // device context implementation
1515 //
1516 // more and more of the dc functionality should be implemented by calling
1517 // the appropricate wxMacCoreGraphicsContext, but we will have to do that step by step
1518 // also coordinate conversions should be moved to native matrix ops
1519 //-----------------------------------------------------------------------------
1520
1521 // we always stock two context states, one at entry, to be able to preserve the
1522 // state we were called with, the other one after changing to HI Graphics orientation
1523 // (this one is used for getting back clippings etc)
1524
1525 //-----------------------------------------------------------------------------
1526 // wxMacCoreGraphicsContext implementation
1527 //-----------------------------------------------------------------------------
1528
1529 IMPLEMENT_DYNAMIC_CLASS(wxMacCoreGraphicsContext, wxGraphicsContext)
1530
1531 class wxQuartzOffsetHelper
1532 {
1533 public :
1534 wxQuartzOffsetHelper( CGContextRef cg , bool offset )
1535 {
1536 m_cg = cg;
1537 m_offset = offset;
1538 if ( m_offset )
1539 {
1540 m_userOffset = CGContextConvertSizeToUserSpace( m_cg, CGSizeMake( 0.5 , 0.5 ) );
1541 CGContextTranslateCTM( m_cg, m_userOffset.width , m_userOffset.height );
1542 }
1543 else
1544 {
1545 m_userOffset = CGSizeMake(0.0, 0.0);
1546 }
1547
1548 }
1549 ~wxQuartzOffsetHelper( )
1550 {
1551 if ( m_offset )
1552 CGContextTranslateCTM( m_cg, -m_userOffset.width , -m_userOffset.height );
1553 }
1554 public :
1555 CGSize m_userOffset;
1556 CGContextRef m_cg;
1557 bool m_offset;
1558 } ;
1559
1560 void wxMacCoreGraphicsContext::Init()
1561 {
1562 m_cgContext = NULL;
1563 m_contextSynthesized = false;
1564 m_width = 0;
1565 m_height = 0;
1566 #if wxOSX_USE_CARBON
1567 m_windowRef = NULL;
1568 #endif
1569 #if wxOSX_USE_COCOA_OR_IPHONE
1570 m_view = NULL;
1571 #endif
1572 m_invisible = false;
1573 }
1574
1575 wxMacCoreGraphicsContext::wxMacCoreGraphicsContext( wxGraphicsRenderer* renderer, CGContextRef cgcontext, wxDouble width, wxDouble height ) : wxGraphicsContext(renderer)
1576 {
1577 Init();
1578 SetNativeContext(cgcontext);
1579 m_width = width;
1580 m_height = height;
1581 }
1582
1583 #if wxOSX_USE_CARBON
1584 wxMacCoreGraphicsContext::wxMacCoreGraphicsContext( wxGraphicsRenderer* renderer, WindowRef window ): wxGraphicsContext(renderer)
1585 {
1586 Init();
1587 m_windowRef = window;
1588 }
1589 #endif
1590
1591 wxMacCoreGraphicsContext::wxMacCoreGraphicsContext( wxGraphicsRenderer* renderer, wxWindow* window ): wxGraphicsContext(renderer)
1592 {
1593 Init();
1594
1595 wxSize sz = window->GetSize();
1596 m_width = sz.x;
1597 m_height = sz.y;
1598
1599 #if wxOSX_USE_COCOA_OR_IPHONE
1600 m_view = window->GetHandle();
1601
1602 #if wxOSX_USE_COCOA
1603 if ( ! window->GetPeer()->IsFlipped() )
1604 {
1605 m_windowTransform = CGAffineTransformMakeTranslation( 0 , m_height );
1606 m_windowTransform = CGAffineTransformScale( m_windowTransform , 1 , -1 );
1607 }
1608 else
1609 #endif
1610 {
1611 m_windowTransform = CGAffineTransformIdentity;
1612 }
1613 #else
1614 int originX , originY;
1615 originX = originY = 0;
1616 Rect bounds = { 0,0,0,0 };
1617 m_windowRef = (WindowRef) window->MacGetTopLevelWindowRef();
1618 window->MacWindowToRootWindow( &originX , &originY );
1619 GetWindowBounds( m_windowRef, kWindowContentRgn, &bounds );
1620 m_windowTransform = CGAffineTransformMakeTranslation( 0 , bounds.bottom - bounds.top );
1621 m_windowTransform = CGAffineTransformScale( m_windowTransform , 1 , -1 );
1622 m_windowTransform = CGAffineTransformTranslate( m_windowTransform, originX, originY ) ;
1623 #endif
1624 }
1625
1626 wxMacCoreGraphicsContext::wxMacCoreGraphicsContext(wxGraphicsRenderer* renderer) : wxGraphicsContext(renderer)
1627 {
1628 Init();
1629 }
1630
1631 wxMacCoreGraphicsContext::wxMacCoreGraphicsContext() : wxGraphicsContext(NULL)
1632 {
1633 Init();
1634 wxLogDebug(wxT("Illegal Constructor called"));
1635 }
1636
1637 wxMacCoreGraphicsContext::~wxMacCoreGraphicsContext()
1638 {
1639 SetNativeContext(NULL);
1640 }
1641
1642
1643 void wxMacCoreGraphicsContext::StartPage( wxDouble width, wxDouble height )
1644 {
1645 CGRect r;
1646 if ( width != 0 && height != 0)
1647 r = CGRectMake( (CGFloat) 0.0 , (CGFloat) 0.0 , (CGFloat) width , (CGFloat) height );
1648 else
1649 r = CGRectMake( (CGFloat) 0.0 , (CGFloat) 0.0 , (CGFloat) m_width , (CGFloat) m_height );
1650
1651 CGContextBeginPage(m_cgContext, &r );
1652 // CGContextTranslateCTM( m_cgContext , 0 , height == 0 ? m_height : height );
1653 // CGContextScaleCTM( m_cgContext , 1 , -1 );
1654 }
1655
1656 void wxMacCoreGraphicsContext::EndPage()
1657 {
1658 CGContextEndPage(m_cgContext);
1659 }
1660
1661 void wxMacCoreGraphicsContext::Flush()
1662 {
1663 CGContextFlush(m_cgContext);
1664 }
1665
1666 bool wxMacCoreGraphicsContext::EnsureIsValid()
1667 {
1668 if ( !m_cgContext )
1669 {
1670 if (m_invisible)
1671 return false;
1672
1673 #if wxOSX_USE_COCOA
1674 if ( wxOSXLockFocus(m_view) )
1675 {
1676 m_cgContext = wxOSXGetContextFromCurrentContext();
1677 wxASSERT_MSG( m_cgContext != NULL, wxT("Unable to retrieve drawing context from View"));
1678 }
1679 else
1680 {
1681 m_invisible = true;
1682 }
1683 #endif
1684 #if wxOSX_USE_IPHONE
1685 m_cgContext = wxOSXGetContextFromCurrentContext();
1686 if ( m_cgContext == NULL )
1687 {
1688 m_invisible = true;
1689 }
1690 #endif
1691 #if wxOSX_USE_CARBON
1692 OSStatus status = QDBeginCGContext( GetWindowPort( m_windowRef ) , &m_cgContext );
1693 if ( status != noErr )
1694 {
1695 wxFAIL_MSG("Cannot nest wxDCs on the same window");
1696 }
1697 #endif
1698 if ( m_cgContext )
1699 {
1700 CGContextSaveGState( m_cgContext );
1701 CGContextConcatCTM( m_cgContext, m_windowTransform );
1702 CGContextSetTextMatrix( m_cgContext, CGAffineTransformIdentity );
1703 m_contextSynthesized = true;
1704 #if wxOSX_USE_COCOA_OR_CARBON
1705 if ( m_clipRgn.get() )
1706 {
1707 // the clip region is in device coordinates, so we convert this again to user coordinates
1708 wxCFRef<HIMutableShapeRef> hishape( HIShapeCreateMutableCopy( m_clipRgn ) );
1709 CGPoint transformedOrigin = CGPointApplyAffineTransform( CGPointZero,m_windowTransform);
1710 HIShapeOffset( hishape, -transformedOrigin.x, -transformedOrigin.y );
1711 // if the shape is empty, HIShapeReplacePathInCGContext doesn't work
1712 if ( HIShapeIsEmpty(hishape))
1713 {
1714 CGRect empty = CGRectMake( 0,0,0,0 );
1715 CGContextClipToRect( m_cgContext, empty );
1716 }
1717 else
1718 {
1719 HIShapeReplacePathInCGContext( hishape, m_cgContext );
1720 CGContextClip( m_cgContext );
1721 }
1722 }
1723 #endif
1724 CGContextSaveGState( m_cgContext );
1725
1726 #if 0 // turn on for debugging of clientdc
1727 static float color = 0.5 ;
1728 static int channel = 0 ;
1729 CGRect bounds = CGRectMake(-1000,-1000,2000,2000);
1730 CGContextSetRGBFillColor( m_cgContext, channel == 0 ? color : 0.5 ,
1731 channel == 1 ? color : 0.5 , channel == 2 ? color : 0.5 , 1 );
1732 CGContextFillRect( m_cgContext, bounds );
1733 color += 0.1 ;
1734 if ( color > 0.9 )
1735 {
1736 color = 0.5 ;
1737 channel++ ;
1738 if ( channel == 3 )
1739 channel = 0 ;
1740 }
1741 #endif
1742 }
1743 }
1744 return m_cgContext != NULL;
1745 }
1746
1747 bool wxMacCoreGraphicsContext::SetAntialiasMode(wxAntialiasMode antialias)
1748 {
1749 if (!EnsureIsValid())
1750 return true;
1751
1752 if (m_antialias == antialias)
1753 return true;
1754
1755 m_antialias = antialias;
1756
1757 bool antialiasMode;
1758 switch (antialias)
1759 {
1760 case wxANTIALIAS_DEFAULT:
1761 antialiasMode = true;
1762 break;
1763 case wxANTIALIAS_NONE:
1764 antialiasMode = false;
1765 break;
1766 default:
1767 return false;
1768 }
1769 CGContextSetShouldAntialias(m_cgContext, antialiasMode);
1770 return true;
1771 }
1772
1773 bool wxMacCoreGraphicsContext::SetCompositionMode(wxCompositionMode op)
1774 {
1775 if (!EnsureIsValid())
1776 return true;
1777
1778 if ( m_composition == op )
1779 return true;
1780
1781 m_composition = op;
1782
1783 if (m_composition == wxCOMPOSITION_DEST)
1784 return true;
1785
1786 #if wxOSX_USE_COCOA_OR_CARBON
1787 if ( UMAGetSystemVersion() < 0x1060 )
1788 {
1789 CGCompositeOperation cop = kCGCompositeOperationSourceOver;
1790 CGBlendMode mode = kCGBlendModeNormal;
1791 switch( op )
1792 {
1793 case wxCOMPOSITION_CLEAR:
1794 cop = kCGCompositeOperationClear;
1795 break;
1796 case wxCOMPOSITION_SOURCE:
1797 cop = kCGCompositeOperationCopy;
1798 break;
1799 case wxCOMPOSITION_OVER:
1800 mode = kCGBlendModeNormal;
1801 break;
1802 case wxCOMPOSITION_IN:
1803 cop = kCGCompositeOperationSourceIn;
1804 break;
1805 case wxCOMPOSITION_OUT:
1806 cop = kCGCompositeOperationSourceOut;
1807 break;
1808 case wxCOMPOSITION_ATOP:
1809 cop = kCGCompositeOperationSourceAtop;
1810 break;
1811 case wxCOMPOSITION_DEST_OVER:
1812 cop = kCGCompositeOperationDestinationOver;
1813 break;
1814 case wxCOMPOSITION_DEST_IN:
1815 cop = kCGCompositeOperationDestinationIn;
1816 break;
1817 case wxCOMPOSITION_DEST_OUT:
1818 cop = kCGCompositeOperationDestinationOut;
1819 break;
1820 case wxCOMPOSITION_DEST_ATOP:
1821 cop = kCGCompositeOperationDestinationAtop;
1822 break;
1823 case wxCOMPOSITION_XOR:
1824 cop = kCGCompositeOperationXOR;
1825 break;
1826 #if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5
1827 case wxCOMPOSITION_ADD:
1828 mode = kCGBlendModePlusLighter ;
1829 break;
1830 #endif
1831 default:
1832 return false;
1833 }
1834 if ( cop != kCGCompositeOperationSourceOver )
1835 CGContextSetCompositeOperation(m_cgContext, cop);
1836 else
1837 CGContextSetBlendMode(m_cgContext, mode);
1838 }
1839 #endif
1840 #if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5
1841 else
1842 {
1843 CGBlendMode mode = kCGBlendModeNormal;
1844 switch( op )
1845 {
1846 case wxCOMPOSITION_CLEAR:
1847 mode = kCGBlendModeClear;
1848 break;
1849 case wxCOMPOSITION_SOURCE:
1850 mode = kCGBlendModeCopy;
1851 break;
1852 case wxCOMPOSITION_OVER:
1853 mode = kCGBlendModeNormal;
1854 break;
1855 case wxCOMPOSITION_IN:
1856 mode = kCGBlendModeSourceIn;
1857 break;
1858 case wxCOMPOSITION_OUT:
1859 mode = kCGBlendModeSourceOut;
1860 break;
1861 case wxCOMPOSITION_ATOP:
1862 mode = kCGBlendModeSourceAtop;
1863 break;
1864 case wxCOMPOSITION_DEST_OVER:
1865 mode = kCGBlendModeDestinationOver;
1866 break;
1867 case wxCOMPOSITION_DEST_IN:
1868 mode = kCGBlendModeDestinationIn;
1869 break;
1870 case wxCOMPOSITION_DEST_OUT:
1871 mode = kCGBlendModeDestinationOut;
1872 break;
1873 case wxCOMPOSITION_DEST_ATOP:
1874 mode = kCGBlendModeDestinationAtop;
1875 break;
1876 case wxCOMPOSITION_XOR:
1877 mode = kCGBlendModeXOR;
1878 break;
1879
1880 case wxCOMPOSITION_ADD:
1881 mode = kCGBlendModePlusLighter ;
1882 break;
1883 default:
1884 return false;
1885 }
1886 CGContextSetBlendMode(m_cgContext, mode);
1887 }
1888 #endif
1889 return true;
1890 }
1891
1892 void wxMacCoreGraphicsContext::BeginLayer(wxDouble opacity)
1893 {
1894 CGContextSaveGState(m_cgContext);
1895 CGContextSetAlpha(m_cgContext, (CGFloat) opacity);
1896 CGContextBeginTransparencyLayer(m_cgContext, 0);
1897 }
1898
1899 void wxMacCoreGraphicsContext::EndLayer()
1900 {
1901 CGContextEndTransparencyLayer(m_cgContext);
1902 CGContextRestoreGState(m_cgContext);
1903 }
1904
1905 void wxMacCoreGraphicsContext::Clip( const wxRegion &region )
1906 {
1907 #if wxOSX_USE_COCOA_OR_CARBON
1908 if( m_cgContext )
1909 {
1910 wxCFRef<HIShapeRef> shape = wxCFRefFromGet(region.GetWXHRGN());
1911 // if the shape is empty, HIShapeReplacePathInCGContext doesn't work
1912 if ( HIShapeIsEmpty(shape))
1913 {
1914 CGRect empty = CGRectMake( 0,0,0,0 );
1915 CGContextClipToRect( m_cgContext, empty );
1916 }
1917 else
1918 {
1919 HIShapeReplacePathInCGContext( shape, m_cgContext );
1920 CGContextClip( m_cgContext );
1921 }
1922 }
1923 else
1924 {
1925 // this offsetting to device coords is not really correct, but since we cannot apply affine transforms
1926 // to regions we try at least to have correct translations
1927 HIMutableShapeRef mutableShape = HIShapeCreateMutableCopy( region.GetWXHRGN() );
1928
1929 CGPoint transformedOrigin = CGPointApplyAffineTransform( CGPointZero, m_windowTransform );
1930 HIShapeOffset( mutableShape, transformedOrigin.x, transformedOrigin.y );
1931 m_clipRgn.reset(mutableShape);
1932 }
1933 #else
1934 // allow usage as measuring context
1935 // wxASSERT_MSG( m_cgContext != NULL, "Needs a valid context for clipping" );
1936 #endif
1937 }
1938
1939 // clips drawings to the rect
1940 void wxMacCoreGraphicsContext::Clip( wxDouble x, wxDouble y, wxDouble w, wxDouble h )
1941 {
1942 CGRect r = CGRectMake( (CGFloat) x , (CGFloat) y , (CGFloat) w , (CGFloat) h );
1943 if ( m_cgContext )
1944 {
1945 CGContextClipToRect( m_cgContext, r );
1946 }
1947 else
1948 {
1949 #if wxOSX_USE_COCOA_OR_CARBON
1950 // the clipping itself must be stored as device coordinates, otherwise
1951 // we cannot apply it back correctly
1952 r.origin= CGPointApplyAffineTransform( r.origin, m_windowTransform );
1953 m_clipRgn.reset(HIShapeCreateWithRect(&r));
1954 #else
1955 // allow usage as measuring context
1956 // wxFAIL_MSG( "Needs a valid context for clipping" );
1957 #endif
1958 }
1959 }
1960
1961 // resets the clipping to original extent
1962 void wxMacCoreGraphicsContext::ResetClip()
1963 {
1964 if ( m_cgContext )
1965 {
1966 // there is no way for clearing the clip, we can only revert to the stored
1967 // state, but then we have to make sure everything else is NOT restored
1968 CGAffineTransform transform = CGContextGetCTM( m_cgContext );
1969 CGContextRestoreGState( m_cgContext );
1970 CGContextSaveGState( m_cgContext );
1971 CGAffineTransform transformNew = CGContextGetCTM( m_cgContext );
1972 transformNew = CGAffineTransformInvert( transformNew ) ;
1973 CGContextConcatCTM( m_cgContext, transformNew);
1974 CGContextConcatCTM( m_cgContext, transform);
1975 }
1976 else
1977 {
1978 #if wxOSX_USE_COCOA_OR_CARBON
1979 m_clipRgn.reset();
1980 #else
1981 // allow usage as measuring context
1982 // wxFAIL_MSG( "Needs a valid context for clipping" );
1983 #endif
1984 }
1985 }
1986
1987 void wxMacCoreGraphicsContext::StrokePath( const wxGraphicsPath &path )
1988 {
1989 if ( m_pen.IsNull() )
1990 return ;
1991
1992 if (!EnsureIsValid())
1993 return;
1994
1995 if (m_composition == wxCOMPOSITION_DEST)
1996 return;
1997
1998 wxQuartzOffsetHelper helper( m_cgContext , ShouldOffset() );
1999
2000 ((wxMacCoreGraphicsPenData*)m_pen.GetRefData())->Apply(this);
2001 CGContextAddPath( m_cgContext , (CGPathRef) path.GetNativePath() );
2002 CGContextStrokePath( m_cgContext );
2003 }
2004
2005 void wxMacCoreGraphicsContext::DrawPath( const wxGraphicsPath &path , wxPolygonFillMode fillStyle )
2006 {
2007 if (!EnsureIsValid())
2008 return;
2009
2010 if (m_composition == wxCOMPOSITION_DEST)
2011 return;
2012
2013 if ( !m_brush.IsNull() && ((wxMacCoreGraphicsBrushData*)m_brush.GetRefData())->IsShading() )
2014 {
2015 // when using shading, we cannot draw pen and brush at the same time
2016 // revert to the base implementation of first filling and then stroking
2017 wxGraphicsContext::DrawPath( path, fillStyle );
2018 return;
2019 }
2020
2021 CGPathDrawingMode mode = kCGPathFill ;
2022 if ( m_brush.IsNull() )
2023 {
2024 if ( m_pen.IsNull() )
2025 return;
2026 else
2027 mode = kCGPathStroke;
2028 }
2029 else
2030 {
2031 if ( m_pen.IsNull() )
2032 {
2033 if ( fillStyle == wxODDEVEN_RULE )
2034 mode = kCGPathEOFill;
2035 else
2036 mode = kCGPathFill;
2037 }
2038 else
2039 {
2040 if ( fillStyle == wxODDEVEN_RULE )
2041 mode = kCGPathEOFillStroke;
2042 else
2043 mode = kCGPathFillStroke;
2044 }
2045 }
2046
2047 if ( !m_brush.IsNull() )
2048 ((wxMacCoreGraphicsBrushData*)m_brush.GetRefData())->Apply(this);
2049 if ( !m_pen.IsNull() )
2050 ((wxMacCoreGraphicsPenData*)m_pen.GetRefData())->Apply(this);
2051
2052 wxQuartzOffsetHelper helper( m_cgContext , ShouldOffset() );
2053
2054 CGContextAddPath( m_cgContext , (CGPathRef) path.GetNativePath() );
2055 CGContextDrawPath( m_cgContext , mode );
2056 }
2057
2058 void wxMacCoreGraphicsContext::FillPath( const wxGraphicsPath &path , wxPolygonFillMode fillStyle )
2059 {
2060 if ( m_brush.IsNull() )
2061 return;
2062
2063 if (!EnsureIsValid())
2064 return;
2065
2066 if (m_composition == wxCOMPOSITION_DEST)
2067 return;
2068
2069 if ( ((wxMacCoreGraphicsBrushData*)m_brush.GetRefData())->IsShading() )
2070 {
2071 CGContextSaveGState( m_cgContext );
2072 CGContextAddPath( m_cgContext , (CGPathRef) path.GetNativePath() );
2073 CGContextClip( m_cgContext );
2074 CGContextDrawShading( m_cgContext, ((wxMacCoreGraphicsBrushData*)m_brush.GetRefData())->GetShading() );
2075 CGContextRestoreGState( m_cgContext);
2076 }
2077 else
2078 {
2079 ((wxMacCoreGraphicsBrushData*)m_brush.GetRefData())->Apply(this);
2080 CGContextAddPath( m_cgContext , (CGPathRef) path.GetNativePath() );
2081 if ( fillStyle == wxODDEVEN_RULE )
2082 CGContextEOFillPath( m_cgContext );
2083 else
2084 CGContextFillPath( m_cgContext );
2085 }
2086 }
2087
2088 void wxMacCoreGraphicsContext::SetNativeContext( CGContextRef cg )
2089 {
2090 // we allow either setting or clearing but not replacing
2091 wxASSERT( m_cgContext == NULL || cg == NULL );
2092
2093 if ( m_cgContext )
2094 {
2095 CGContextRestoreGState( m_cgContext );
2096 CGContextRestoreGState( m_cgContext );
2097 if ( m_contextSynthesized )
2098 {
2099 #if wxOSX_USE_CARBON
2100 QDEndCGContext( GetWindowPort( m_windowRef ) , &m_cgContext);
2101 #endif
2102 #if wxOSX_USE_COCOA
2103 wxOSXUnlockFocus(m_view);
2104 #endif
2105 }
2106 else
2107 CGContextRelease(m_cgContext);
2108 }
2109
2110 m_cgContext = cg;
2111
2112 // FIXME: This check is needed because currently we need to use a DC/GraphicsContext
2113 // in order to get font properties, like wxFont::GetPixelSize, but since we don't have
2114 // a native window attached to use, I create a wxGraphicsContext with a NULL CGContextRef
2115 // for this one operation.
2116
2117 // When wxFont::GetPixelSize on Mac no longer needs a graphics context, this check
2118 // can be removed.
2119 if (m_cgContext)
2120 {
2121 CGContextRetain(m_cgContext);
2122 CGContextSaveGState( m_cgContext );
2123 CGContextSetTextMatrix( m_cgContext, CGAffineTransformIdentity );
2124 CGContextSaveGState( m_cgContext );
2125 m_contextSynthesized = false;
2126 }
2127 }
2128
2129 void wxMacCoreGraphicsContext::Translate( wxDouble dx , wxDouble dy )
2130 {
2131 if ( m_cgContext )
2132 CGContextTranslateCTM( m_cgContext, (CGFloat) dx, (CGFloat) dy );
2133 else
2134 m_windowTransform = CGAffineTransformTranslate(m_windowTransform, (CGFloat) dx, (CGFloat) dy);
2135 }
2136
2137 void wxMacCoreGraphicsContext::Scale( wxDouble xScale , wxDouble yScale )
2138 {
2139 if ( m_cgContext )
2140 CGContextScaleCTM( m_cgContext , (CGFloat) xScale , (CGFloat) yScale );
2141 else
2142 m_windowTransform = CGAffineTransformScale(m_windowTransform, (CGFloat) xScale, (CGFloat) yScale);
2143 }
2144
2145 void wxMacCoreGraphicsContext::Rotate( wxDouble angle )
2146 {
2147 if ( m_cgContext )
2148 CGContextRotateCTM( m_cgContext , (CGFloat) angle );
2149 else
2150 m_windowTransform = CGAffineTransformRotate(m_windowTransform, (CGFloat) angle);
2151 }
2152
2153 void wxMacCoreGraphicsContext::DrawBitmap( const wxBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h )
2154 {
2155 wxGraphicsBitmap bitmap = GetRenderer()->CreateBitmap(bmp);
2156 DrawBitmap(bitmap, x, y, w, h);
2157 }
2158
2159 void wxMacCoreGraphicsContext::DrawBitmap( const wxGraphicsBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h )
2160 {
2161 if (!EnsureIsValid())
2162 return;
2163
2164 if (m_composition == wxCOMPOSITION_DEST)
2165 return;
2166
2167 #ifdef __WXMAC__
2168 wxMacCoreGraphicsBitmapData* refdata =static_cast<wxMacCoreGraphicsBitmapData*>(bmp.GetRefData());
2169 CGImageRef image = refdata->GetBitmap();
2170 CGRect r = CGRectMake( (CGFloat) x , (CGFloat) y , (CGFloat) w , (CGFloat) h );
2171 if ( refdata->IsMonochrome() == 1 )
2172 {
2173 // is is a mask, the '1' in the mask tell where to draw the current brush
2174 if ( !m_brush.IsNull() )
2175 {
2176 if ( ((wxMacCoreGraphicsBrushData*)m_brush.GetRefData())->IsShading() )
2177 {
2178 // TODO clip to mask
2179 /*
2180 CGContextSaveGState( m_cgContext );
2181 CGContextAddPath( m_cgContext , (CGPathRef) path.GetNativePath() );
2182 CGContextClip( m_cgContext );
2183 CGContextDrawShading( m_cgContext, ((wxMacCoreGraphicsBrushData*)m_brush.GetRefData())->GetShading() );
2184 CGContextRestoreGState( m_cgContext);
2185 */
2186 }
2187 else
2188 {
2189 ((wxMacCoreGraphicsBrushData*)m_brush.GetRefData())->Apply(this);
2190 wxMacDrawCGImage( m_cgContext , &r , image );
2191 }
2192 }
2193 }
2194 else
2195 {
2196 wxMacDrawCGImage( m_cgContext , &r , image );
2197 }
2198 #endif
2199 }
2200
2201 void wxMacCoreGraphicsContext::DrawIcon( const wxIcon &icon, wxDouble x, wxDouble y, wxDouble w, wxDouble h )
2202 {
2203 if (!EnsureIsValid())
2204 return;
2205
2206 if (m_composition == wxCOMPOSITION_DEST)
2207 return;
2208
2209 CGRect r = CGRectMake( (CGFloat) 0.0 , (CGFloat) 0.0 , (CGFloat) w , (CGFloat) h );
2210 CGContextSaveGState( m_cgContext );
2211 CGContextTranslateCTM( m_cgContext,(CGFloat) x ,(CGFloat) (y + h) );
2212 CGContextScaleCTM( m_cgContext, 1, -1 );
2213 #if wxOSX_USE_COCOA_OR_CARBON
2214 PlotIconRefInContext( m_cgContext , &r , kAlignNone , kTransformNone ,
2215 NULL , kPlotIconRefNormalFlags , icon.GetHICON() );
2216 #endif
2217 CGContextRestoreGState( m_cgContext );
2218 }
2219
2220 void wxMacCoreGraphicsContext::PushState()
2221 {
2222 if (!EnsureIsValid())
2223 return;
2224
2225 CGContextSaveGState( m_cgContext );
2226 }
2227
2228 void wxMacCoreGraphicsContext::PopState()
2229 {
2230 if (!EnsureIsValid())
2231 return;
2232
2233 CGContextRestoreGState( m_cgContext );
2234 }
2235
2236 void wxMacCoreGraphicsContext::DoDrawText( const wxString &str, wxDouble x, wxDouble y )
2237 {
2238 wxCHECK_RET( !m_font.IsNull(), wxT("wxMacCoreGraphicsContext::DrawText - no valid font set") );
2239
2240 if (!EnsureIsValid())
2241 return;
2242
2243 if (m_composition == wxCOMPOSITION_DEST)
2244 return;
2245
2246 #if wxOSX_USE_CORE_TEXT
2247 if ( UMAGetSystemVersion() >= 0x1050 )
2248 {
2249 wxMacCoreGraphicsFontData* fref = (wxMacCoreGraphicsFontData*)m_font.GetRefData();
2250 wxCFStringRef text(str, wxLocale::GetSystemEncoding() );
2251 CTFontRef font = fref->OSXGetCTFont();
2252 CGColorRef col = wxMacCreateCGColor( fref->GetColour() );
2253 CTUnderlineStyle ustyle = fref->GetUnderlined() ? kCTUnderlineStyleSingle : kCTUnderlineStyleNone ;
2254 wxCFRef<CFNumberRef> underlined( CFNumberCreate(NULL, kCFNumberSInt32Type, &ustyle) );
2255 CFStringRef keys[] = { kCTFontAttributeName , kCTForegroundColorAttributeName, kCTUnderlineStyleAttributeName };
2256 CFTypeRef values[] = { font, col, underlined };
2257 wxCFRef<CFDictionaryRef> attributes( CFDictionaryCreate(kCFAllocatorDefault, (const void**) &keys, (const void**) &values,
2258 WXSIZEOF( keys ), &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks) );
2259 wxCFRef<CFAttributedStringRef> attrtext( CFAttributedStringCreate(kCFAllocatorDefault, text, attributes) );
2260 wxCFRef<CTLineRef> line( CTLineCreateWithAttributedString(attrtext) );
2261
2262 y += CTFontGetAscent(font);
2263
2264 CGContextSaveGState(m_cgContext);
2265 CGContextTranslateCTM(m_cgContext, (CGFloat) x, (CGFloat) y);
2266 CGContextScaleCTM(m_cgContext, 1, -1);
2267 CGContextSetTextPosition(m_cgContext, 0, 0);
2268 CTLineDraw( line, m_cgContext );
2269 CGContextRestoreGState(m_cgContext);
2270 CFRelease( col );
2271 return;
2272 }
2273 #endif
2274 #if wxOSX_USE_ATSU_TEXT
2275 {
2276 DrawText(str, x, y, 0.0);
2277 return;
2278 }
2279 #endif
2280 #if wxOSX_USE_IPHONE
2281 wxMacCoreGraphicsFontData* fref = (wxMacCoreGraphicsFontData*)m_font.GetRefData();
2282
2283 CGContextSaveGState(m_cgContext);
2284
2285 CGColorRef col = wxMacCreateCGColor( fref->GetColour() );
2286 CGContextSetTextDrawingMode (m_cgContext, kCGTextFill);
2287 CGContextSetFillColorWithColor( m_cgContext, col );
2288
2289 wxCFStringRef text(str, wxLocale::GetSystemEncoding() );
2290 DrawTextInContext( m_cgContext, CGPointMake( x, y ), fref->GetUIFont() , text.AsNSString() );
2291
2292 CGContextRestoreGState(m_cgContext);
2293 CFRelease( col );
2294 #endif
2295 }
2296
2297 void wxMacCoreGraphicsContext::DoDrawRotatedText(const wxString &str,
2298 wxDouble x, wxDouble y,
2299 wxDouble angle)
2300 {
2301 wxCHECK_RET( !m_font.IsNull(), wxT("wxMacCoreGraphicsContext::DrawText - no valid font set") );
2302
2303 if (!EnsureIsValid())
2304 return;
2305
2306 if (m_composition == wxCOMPOSITION_DEST)
2307 return;
2308
2309 #if wxOSX_USE_CORE_TEXT
2310 if ( UMAGetSystemVersion() >= 0x1050 )
2311 {
2312 // default implementation takes care of rotation and calls non rotated DrawText afterwards
2313 wxGraphicsContext::DoDrawRotatedText( str, x, y, angle );
2314 return;
2315 }
2316 #endif
2317 #if wxOSX_USE_ATSU_TEXT
2318 {
2319 OSStatus status = noErr;
2320 ATSUTextLayout atsuLayout;
2321 wxMacUniCharBuffer unibuf( str );
2322 UniCharCount chars = unibuf.GetChars();
2323
2324 ATSUStyle style = (((wxMacCoreGraphicsFontData*)m_font.GetRefData())->GetATSUStyle());
2325 status = ::ATSUCreateTextLayoutWithTextPtr( unibuf.GetBuffer() , 0 , chars , chars , 1 ,
2326 &chars , &style , &atsuLayout );
2327
2328 wxASSERT_MSG( status == noErr , wxT("couldn't create the layout of the rotated text") );
2329
2330 status = ::ATSUSetTransientFontMatching( atsuLayout , true );
2331 wxASSERT_MSG( status == noErr , wxT("couldn't setup transient font matching") );
2332
2333 int iAngle = int( angle * RAD2DEG );
2334 if ( abs(iAngle) > 0 )
2335 {
2336 Fixed atsuAngle = IntToFixed( iAngle );
2337 ATSUAttributeTag atsuTags[] =
2338 {
2339 kATSULineRotationTag ,
2340 };
2341 ByteCount atsuSizes[WXSIZEOF(atsuTags)] =
2342 {
2343 sizeof( Fixed ) ,
2344 };
2345 ATSUAttributeValuePtr atsuValues[WXSIZEOF(atsuTags)] =
2346 {
2347 &atsuAngle ,
2348 };
2349 status = ::ATSUSetLayoutControls(atsuLayout , WXSIZEOF(atsuTags),
2350 atsuTags, atsuSizes, atsuValues );
2351 }
2352
2353 {
2354 ATSUAttributeTag atsuTags[] =
2355 {
2356 kATSUCGContextTag ,
2357 };
2358 ByteCount atsuSizes[WXSIZEOF(atsuTags)] =
2359 {
2360 sizeof( CGContextRef ) ,
2361 };
2362 ATSUAttributeValuePtr atsuValues[WXSIZEOF(atsuTags)] =
2363 {
2364 &m_cgContext ,
2365 };
2366 status = ::ATSUSetLayoutControls(atsuLayout , WXSIZEOF(atsuTags),
2367 atsuTags, atsuSizes, atsuValues );
2368 }
2369
2370 ATSUTextMeasurement textBefore, textAfter;
2371 ATSUTextMeasurement ascent, descent;
2372
2373 status = ::ATSUGetUnjustifiedBounds( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd,
2374 &textBefore , &textAfter, &ascent , &descent );
2375
2376 wxASSERT_MSG( status == noErr , wxT("couldn't measure the rotated text") );
2377
2378 Rect rect;
2379 x += (int)(sin(angle) * FixedToFloat(ascent));
2380 y += (int)(cos(angle) * FixedToFloat(ascent));
2381
2382 status = ::ATSUMeasureTextImage( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd,
2383 IntToFixed(x) , IntToFixed(y) , &rect );
2384 wxASSERT_MSG( status == noErr , wxT("couldn't measure the rotated text") );
2385
2386 CGContextSaveGState(m_cgContext);
2387 CGContextTranslateCTM(m_cgContext, (CGFloat) x, (CGFloat) y);
2388 CGContextScaleCTM(m_cgContext, 1, -1);
2389 status = ::ATSUDrawText( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd,
2390 IntToFixed(0) , IntToFixed(0) );
2391
2392 wxASSERT_MSG( status == noErr , wxT("couldn't draw the rotated text") );
2393
2394 CGContextRestoreGState(m_cgContext);
2395
2396 ::ATSUDisposeTextLayout(atsuLayout);
2397
2398 return;
2399 }
2400 #endif
2401 #if wxOSX_USE_IPHONE
2402 // default implementation takes care of rotation and calls non rotated DrawText afterwards
2403 wxGraphicsContext::DoDrawRotatedText( str, x, y, angle );
2404 #endif
2405 }
2406
2407 void wxMacCoreGraphicsContext::GetTextExtent( const wxString &str, wxDouble *width, wxDouble *height,
2408 wxDouble *descent, wxDouble *externalLeading ) const
2409 {
2410 wxCHECK_RET( !m_font.IsNull(), wxT("wxMacCoreGraphicsContext::GetTextExtent - no valid font set") );
2411
2412 if ( width )
2413 *width = 0;
2414 if ( height )
2415 *height = 0;
2416 if ( descent )
2417 *descent = 0;
2418 if ( externalLeading )
2419 *externalLeading = 0;
2420
2421 if (str.empty())
2422 return;
2423
2424 #if wxOSX_USE_CORE_TEXT
2425 if ( UMAGetSystemVersion() >= 0x1050 )
2426 {
2427 wxMacCoreGraphicsFontData* fref = (wxMacCoreGraphicsFontData*)m_font.GetRefData();
2428 CTFontRef font = fref->OSXGetCTFont();
2429
2430 wxCFStringRef text(str, wxLocale::GetSystemEncoding() );
2431 CFStringRef keys[] = { kCTFontAttributeName };
2432 CFTypeRef values[] = { font };
2433 wxCFRef<CFDictionaryRef> attributes( CFDictionaryCreate(kCFAllocatorDefault, (const void**) &keys, (const void**) &values,
2434 WXSIZEOF( keys ), &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks) );
2435 wxCFRef<CFAttributedStringRef> attrtext( CFAttributedStringCreate(kCFAllocatorDefault, text, attributes) );
2436 wxCFRef<CTLineRef> line( CTLineCreateWithAttributedString(attrtext) );
2437
2438 CGFloat a, d, l, w;
2439 w = CTLineGetTypographicBounds(line, &a, &d, &l);
2440
2441 if ( height )
2442 *height = a+d+l;
2443 if ( descent )
2444 *descent = d;
2445 if ( externalLeading )
2446 *externalLeading = l;
2447 if ( width )
2448 *width = w;
2449 return;
2450 }
2451 #endif
2452 #if wxOSX_USE_ATSU_TEXT
2453 {
2454 OSStatus status = noErr;
2455
2456 ATSUTextLayout atsuLayout;
2457 wxMacUniCharBuffer unibuf( str );
2458 UniCharCount chars = unibuf.GetChars();
2459
2460 ATSUStyle style = (((wxMacCoreGraphicsFontData*)m_font.GetRefData())->GetATSUStyle());
2461 status = ::ATSUCreateTextLayoutWithTextPtr( unibuf.GetBuffer() , 0 , chars , chars , 1 ,
2462 &chars , &style , &atsuLayout );
2463
2464 wxASSERT_MSG( status == noErr , wxT("couldn't create the layout of the text") );
2465
2466 status = ::ATSUSetTransientFontMatching( atsuLayout , true );
2467 wxASSERT_MSG( status == noErr , wxT("couldn't setup transient font matching") );
2468
2469 ATSUTextMeasurement textBefore, textAfter;
2470 ATSUTextMeasurement textAscent, textDescent;
2471
2472 status = ::ATSUGetUnjustifiedBounds( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd,
2473 &textBefore , &textAfter, &textAscent , &textDescent );
2474
2475 if ( height )
2476 *height = FixedToFloat(textAscent + textDescent);
2477 if ( descent )
2478 *descent = FixedToFloat(textDescent);
2479 if ( externalLeading )
2480 *externalLeading = 0;
2481 if ( width )
2482 *width = FixedToFloat(textAfter - textBefore);
2483
2484 ::ATSUDisposeTextLayout(atsuLayout);
2485
2486 return;
2487 }
2488 #endif
2489 #if wxOSX_USE_IPHONE
2490 wxMacCoreGraphicsFontData* fref = (wxMacCoreGraphicsFontData*)m_font.GetRefData();
2491
2492 wxCFStringRef text(str, wxLocale::GetSystemEncoding() );
2493 CGSize sz = MeasureTextInContext( fref->GetUIFont() , text.AsNSString() );
2494
2495 if ( height )
2496 *height = sz.height;
2497 /*
2498 if ( descent )
2499 *descent = FixedToFloat(textDescent);
2500 if ( externalLeading )
2501 *externalLeading = 0;
2502 */
2503 if ( width )
2504 *width = sz.width;
2505 #endif
2506 }
2507
2508 void wxMacCoreGraphicsContext::GetPartialTextExtents(const wxString& text, wxArrayDouble& widths) const
2509 {
2510 widths.Empty();
2511 widths.Add(0, text.length());
2512
2513 wxCHECK_RET( !m_font.IsNull(), wxT("wxMacCoreGraphicsContext::DrawText - no valid font set") );
2514
2515 if (text.empty())
2516 return;
2517
2518 #if wxOSX_USE_CORE_TEXT
2519 {
2520 wxMacCoreGraphicsFontData* fref = (wxMacCoreGraphicsFontData*)m_font.GetRefData();
2521 CTFontRef font = fref->OSXGetCTFont();
2522
2523 wxCFStringRef t(text, wxLocale::GetSystemEncoding() );
2524 CFStringRef keys[] = { kCTFontAttributeName };
2525 CFTypeRef values[] = { font };
2526 wxCFRef<CFDictionaryRef> attributes( CFDictionaryCreate(kCFAllocatorDefault, (const void**) &keys, (const void**) &values,
2527 WXSIZEOF( keys ), &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks) );
2528 wxCFRef<CFAttributedStringRef> attrtext( CFAttributedStringCreate(kCFAllocatorDefault, t, attributes) );
2529 wxCFRef<CTLineRef> line( CTLineCreateWithAttributedString(attrtext) );
2530
2531 int chars = text.length();
2532 for ( int pos = 0; pos < (int)chars; pos ++ )
2533 {
2534 widths[pos] = CTLineGetOffsetForStringIndex( line, pos+1 , NULL );
2535 }
2536
2537 return;
2538 }
2539 #endif
2540 #if wxOSX_USE_ATSU_TEXT
2541 {
2542 OSStatus status = noErr;
2543 ATSUTextLayout atsuLayout;
2544 wxMacUniCharBuffer unibuf( text );
2545 UniCharCount chars = unibuf.GetChars();
2546
2547 ATSUStyle style = (((wxMacCoreGraphicsFontData*)m_font.GetRefData())->GetATSUStyle());
2548 status = ::ATSUCreateTextLayoutWithTextPtr( unibuf.GetBuffer() , 0 , chars , chars , 1 ,
2549 &chars , &style , &atsuLayout );
2550
2551 wxASSERT_MSG( status == noErr , wxT("couldn't create the layout of the text") );
2552
2553 status = ::ATSUSetTransientFontMatching( atsuLayout , true );
2554 wxASSERT_MSG( status == noErr , wxT("couldn't setup transient font matching") );
2555
2556 // new implementation from JS, keep old one just in case
2557 #if 0
2558 for ( int pos = 0; pos < (int)chars; pos ++ )
2559 {
2560 unsigned long actualNumberOfBounds = 0;
2561 ATSTrapezoid glyphBounds;
2562
2563 // We get a single bound, since the text should only require one. If it requires more, there is an issue
2564 OSStatus result;
2565 result = ATSUGetGlyphBounds( atsuLayout, 0, 0, kATSUFromTextBeginning, pos + 1,
2566 kATSUseDeviceOrigins, 1, &glyphBounds, &actualNumberOfBounds );
2567 if (result != noErr || actualNumberOfBounds != 1 )
2568 return;
2569
2570 widths[pos] = FixedToFloat( glyphBounds.upperRight.x - glyphBounds.upperLeft.x );
2571 //unsigned char uch = s[i];
2572 }
2573 #else
2574 ATSLayoutRecord *layoutRecords = NULL;
2575 ItemCount glyphCount = 0;
2576
2577 // Get the glyph extents
2578 OSStatus err = ::ATSUDirectGetLayoutDataArrayPtrFromTextLayout(atsuLayout,
2579 0,
2580 kATSUDirectDataLayoutRecordATSLayoutRecordCurrent,
2581 (void **)
2582 &layoutRecords,
2583 &glyphCount);
2584 wxASSERT(glyphCount == (text.length()+1));
2585
2586 if ( err == noErr && glyphCount == (text.length()+1))
2587 {
2588 for ( int pos = 1; pos < (int)glyphCount ; pos ++ )
2589 {
2590 widths[pos-1] = FixedToFloat( layoutRecords[pos].realPos );
2591 }
2592 }
2593
2594 ::ATSUDirectReleaseLayoutDataArrayPtr(NULL,
2595 kATSUDirectDataLayoutRecordATSLayoutRecordCurrent,
2596 (void **) &layoutRecords);
2597 #endif
2598 ::ATSUDisposeTextLayout(atsuLayout);
2599 }
2600 #endif
2601 #if wxOSX_USE_IPHONE
2602 // TODO core graphics text implementation here
2603 #endif
2604 }
2605
2606 void * wxMacCoreGraphicsContext::GetNativeContext()
2607 {
2608 return m_cgContext;
2609 }
2610
2611 // concatenates this transform with the current transform of this context
2612 void wxMacCoreGraphicsContext::ConcatTransform( const wxGraphicsMatrix& matrix )
2613 {
2614 if ( m_cgContext )
2615 CGContextConcatCTM( m_cgContext, *(CGAffineTransform*) matrix.GetNativeMatrix());
2616 else
2617 m_windowTransform = CGAffineTransformConcat(*(CGAffineTransform*) matrix.GetNativeMatrix(), m_windowTransform);
2618 }
2619
2620 // sets the transform of this context
2621 void wxMacCoreGraphicsContext::SetTransform( const wxGraphicsMatrix& matrix )
2622 {
2623 if ( m_cgContext )
2624 {
2625 CGAffineTransform transform = CGContextGetCTM( m_cgContext );
2626 transform = CGAffineTransformInvert( transform ) ;
2627 CGContextConcatCTM( m_cgContext, transform);
2628 CGContextConcatCTM( m_cgContext, *(CGAffineTransform*) matrix.GetNativeMatrix());
2629 }
2630 else
2631 {
2632 m_windowTransform = *(CGAffineTransform*) matrix.GetNativeMatrix();
2633 }
2634 }
2635
2636 // gets the matrix of this context
2637 wxGraphicsMatrix wxMacCoreGraphicsContext::GetTransform() const
2638 {
2639 wxGraphicsMatrix m = CreateMatrix();
2640 *((CGAffineTransform*) m.GetNativeMatrix()) = ( m_cgContext == NULL ? m_windowTransform :
2641 CGContextGetCTM( m_cgContext ));
2642 return m;
2643 }
2644
2645 //
2646 // Renderer
2647 //
2648
2649 //-----------------------------------------------------------------------------
2650 // wxMacCoreGraphicsRenderer declaration
2651 //-----------------------------------------------------------------------------
2652
2653 class WXDLLIMPEXP_CORE wxMacCoreGraphicsRenderer : public wxGraphicsRenderer
2654 {
2655 public :
2656 wxMacCoreGraphicsRenderer() {}
2657
2658 virtual ~wxMacCoreGraphicsRenderer() {}
2659
2660 // Context
2661
2662 virtual wxGraphicsContext * CreateContext( const wxWindowDC& dc);
2663 virtual wxGraphicsContext * CreateContext( const wxMemoryDC& dc);
2664 #if wxUSE_PRINTING_ARCHITECTURE
2665 virtual wxGraphicsContext * CreateContext( const wxPrinterDC& dc);
2666 #endif
2667
2668 virtual wxGraphicsContext * CreateContextFromNativeContext( void * context );
2669
2670 virtual wxGraphicsContext * CreateContextFromNativeWindow( void * window );
2671
2672 virtual wxGraphicsContext * CreateContext( wxWindow* window );
2673
2674 virtual wxGraphicsContext * CreateMeasuringContext();
2675
2676 // Path
2677
2678 virtual wxGraphicsPath CreatePath();
2679
2680 // Matrix
2681
2682 virtual wxGraphicsMatrix CreateMatrix( wxDouble a=1.0, wxDouble b=0.0, wxDouble c=0.0, wxDouble d=1.0,
2683 wxDouble tx=0.0, wxDouble ty=0.0);
2684
2685
2686 virtual wxGraphicsPen CreatePen(const wxPen& pen) ;
2687
2688 virtual wxGraphicsBrush CreateBrush(const wxBrush& brush ) ;
2689
2690 virtual wxGraphicsBrush
2691 CreateLinearGradientBrush(wxDouble x1, wxDouble y1,
2692 wxDouble x2, wxDouble y2,
2693 const wxGraphicsGradientStops& stops);
2694
2695 virtual wxGraphicsBrush
2696 CreateRadialGradientBrush(wxDouble xo, wxDouble yo,
2697 wxDouble xc, wxDouble yc,
2698 wxDouble radius,
2699 const wxGraphicsGradientStops& stops);
2700
2701 // sets the font
2702 virtual wxGraphicsFont CreateFont( const wxFont &font , const wxColour &col = *wxBLACK ) ;
2703
2704 // create a native bitmap representation
2705 virtual wxGraphicsBitmap CreateBitmap( const wxBitmap &bitmap ) ;
2706
2707 // create a graphics bitmap from a native bitmap
2708 virtual wxGraphicsBitmap CreateBitmapFromNativeBitmap( void* bitmap );
2709
2710 // create a native bitmap representation
2711 virtual wxGraphicsBitmap CreateSubBitmap( const wxGraphicsBitmap &bitmap, wxDouble x, wxDouble y, wxDouble w, wxDouble h ) ;
2712 private :
2713 DECLARE_DYNAMIC_CLASS_NO_COPY(wxMacCoreGraphicsRenderer)
2714 } ;
2715
2716 //-----------------------------------------------------------------------------
2717 // wxMacCoreGraphicsRenderer implementation
2718 //-----------------------------------------------------------------------------
2719
2720 IMPLEMENT_DYNAMIC_CLASS(wxMacCoreGraphicsRenderer,wxGraphicsRenderer)
2721
2722 static wxMacCoreGraphicsRenderer gs_MacCoreGraphicsRenderer;
2723
2724 wxGraphicsRenderer* wxGraphicsRenderer::GetDefaultRenderer()
2725 {
2726 return &gs_MacCoreGraphicsRenderer;
2727 }
2728
2729 wxGraphicsContext * wxMacCoreGraphicsRenderer::CreateContext( const wxWindowDC& dc )
2730 {
2731 const wxDCImpl* impl = dc.GetImpl();
2732 wxWindowDCImpl *win_impl = wxDynamicCast( impl, wxWindowDCImpl );
2733 if (win_impl)
2734 {
2735 int w, h;
2736 win_impl->GetSize( &w, &h );
2737 CGContextRef cgctx = 0;
2738
2739 wxASSERT_MSG(win_impl->GetWindow(), "Invalid wxWindow in wxMacCoreGraphicsRenderer::CreateContext");
2740 if (win_impl->GetWindow())
2741 cgctx = (CGContextRef)(win_impl->GetWindow()->MacGetCGContextRef());
2742
2743 // having a cgctx being NULL is fine (will be created on demand)
2744 // this is the case for all wxWindowDCs except wxPaintDC
2745 return new wxMacCoreGraphicsContext( this, cgctx, (wxDouble) w, (wxDouble) h );
2746 }
2747 return NULL;
2748 }
2749
2750 wxGraphicsContext * wxMacCoreGraphicsRenderer::CreateContext( const wxMemoryDC& dc )
2751 {
2752 #ifdef __WXMAC__
2753 const wxDCImpl* impl = dc.GetImpl();
2754 wxMemoryDCImpl *mem_impl = wxDynamicCast( impl, wxMemoryDCImpl );
2755 if (mem_impl)
2756 {
2757 int w, h;
2758 mem_impl->GetSize( &w, &h );
2759 return new wxMacCoreGraphicsContext( this,
2760 (CGContextRef)(mem_impl->GetGraphicsContext()->GetNativeContext()), (wxDouble) w, (wxDouble) h );
2761 }
2762 #endif
2763 return NULL;
2764 }
2765
2766 #if wxUSE_PRINTING_ARCHITECTURE
2767 wxGraphicsContext * wxMacCoreGraphicsRenderer::CreateContext( const wxPrinterDC& dc )
2768 {
2769 #ifdef __WXMAC__
2770 const wxDCImpl* impl = dc.GetImpl();
2771 wxPrinterDCImpl *print_impl = wxDynamicCast( impl, wxPrinterDCImpl );
2772 if (print_impl)
2773 {
2774 int w, h;
2775 print_impl->GetSize( &w, &h );
2776 return new wxMacCoreGraphicsContext( this,
2777 (CGContextRef)(print_impl->GetGraphicsContext()->GetNativeContext()), (wxDouble) w, (wxDouble) h );
2778 }
2779 #endif
2780 return NULL;
2781 }
2782 #endif
2783
2784 wxGraphicsContext * wxMacCoreGraphicsRenderer::CreateContextFromNativeContext( void * context )
2785 {
2786 return new wxMacCoreGraphicsContext(this,(CGContextRef)context);
2787 }
2788
2789 wxGraphicsContext * wxMacCoreGraphicsRenderer::CreateContextFromNativeWindow( void * window )
2790 {
2791 #if wxOSX_USE_CARBON
2792 return new wxMacCoreGraphicsContext(this,(WindowRef)window);
2793 #else
2794 wxUnusedVar(window);
2795 return NULL;
2796 #endif
2797 }
2798
2799 wxGraphicsContext * wxMacCoreGraphicsRenderer::CreateContext( wxWindow* window )
2800 {
2801 return new wxMacCoreGraphicsContext(this, window );
2802 }
2803
2804 wxGraphicsContext * wxMacCoreGraphicsRenderer::CreateMeasuringContext()
2805 {
2806 return new wxMacCoreGraphicsContext(this);
2807 }
2808
2809 // Path
2810
2811 wxGraphicsPath wxMacCoreGraphicsRenderer::CreatePath()
2812 {
2813 wxGraphicsPath m;
2814 m.SetRefData( new wxMacCoreGraphicsPathData(this));
2815 return m;
2816 }
2817
2818
2819 // Matrix
2820
2821 wxGraphicsMatrix wxMacCoreGraphicsRenderer::CreateMatrix( wxDouble a, wxDouble b, wxDouble c, wxDouble d,
2822 wxDouble tx, wxDouble ty)
2823 {
2824 wxGraphicsMatrix m;
2825 wxMacCoreGraphicsMatrixData* data = new wxMacCoreGraphicsMatrixData( this );
2826 data->Set( a,b,c,d,tx,ty ) ;
2827 m.SetRefData(data);
2828 return m;
2829 }
2830
2831 wxGraphicsPen wxMacCoreGraphicsRenderer::CreatePen(const wxPen& pen)
2832 {
2833 if ( !pen.Ok() || pen.GetStyle() == wxTRANSPARENT )
2834 return wxNullGraphicsPen;
2835 else
2836 {
2837 wxGraphicsPen p;
2838 p.SetRefData(new wxMacCoreGraphicsPenData( this, pen ));
2839 return p;
2840 }
2841 }
2842
2843 wxGraphicsBrush wxMacCoreGraphicsRenderer::CreateBrush(const wxBrush& brush )
2844 {
2845 if ( !brush.Ok() || brush.GetStyle() == wxTRANSPARENT )
2846 return wxNullGraphicsBrush;
2847 else
2848 {
2849 wxGraphicsBrush p;
2850 p.SetRefData(new wxMacCoreGraphicsBrushData( this, brush ));
2851 return p;
2852 }
2853 }
2854
2855 wxGraphicsBitmap wxMacCoreGraphicsRenderer::CreateBitmap( const wxBitmap& bmp )
2856 {
2857 if ( bmp.Ok() )
2858 {
2859 wxGraphicsBitmap p;
2860 p.SetRefData(new wxMacCoreGraphicsBitmapData( this , bmp.CreateCGImage(), bmp.GetDepth() == 1 ) );
2861 return p;
2862 }
2863 else
2864 return wxNullGraphicsBitmap;
2865 }
2866
2867 wxGraphicsBitmap wxMacCoreGraphicsRenderer::CreateBitmapFromNativeBitmap( void* bitmap )
2868 {
2869 if ( bitmap != NULL )
2870 {
2871 wxGraphicsBitmap p;
2872 p.SetRefData(new wxMacCoreGraphicsBitmapData( this , (CGImageRef) bitmap, false ));
2873 return p;
2874 }
2875 else
2876 return wxNullGraphicsBitmap;
2877 }
2878
2879 wxGraphicsBitmap wxMacCoreGraphicsRenderer::CreateSubBitmap( const wxGraphicsBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h )
2880 {
2881 wxMacCoreGraphicsBitmapData* refdata =static_cast<wxMacCoreGraphicsBitmapData*>(bmp.GetRefData());
2882 CGImageRef img = refdata->GetBitmap();
2883 if ( img )
2884 {
2885 wxGraphicsBitmap p;
2886 CGImageRef subimg = CGImageCreateWithImageInRect(img,CGRectMake( (CGFloat) x , (CGFloat) y , (CGFloat) w , (CGFloat) h ));
2887 p.SetRefData(new wxMacCoreGraphicsBitmapData( this , subimg, refdata->IsMonochrome() ) );
2888 return p;
2889 }
2890 else
2891 return wxNullGraphicsBitmap;
2892 }
2893
2894 wxGraphicsBrush
2895 wxMacCoreGraphicsRenderer::CreateLinearGradientBrush(wxDouble x1, wxDouble y1,
2896 wxDouble x2, wxDouble y2,
2897 const wxGraphicsGradientStops& stops)
2898 {
2899 wxGraphicsBrush p;
2900 wxMacCoreGraphicsBrushData* d = new wxMacCoreGraphicsBrushData( this );
2901 d->CreateLinearGradientBrush(x1, y1, x2, y2, stops);
2902 p.SetRefData(d);
2903 return p;
2904 }
2905
2906 wxGraphicsBrush
2907 wxMacCoreGraphicsRenderer::CreateRadialGradientBrush(wxDouble xo, wxDouble yo,
2908 wxDouble xc, wxDouble yc,
2909 wxDouble radius,
2910 const wxGraphicsGradientStops& stops)
2911 {
2912 wxGraphicsBrush p;
2913 wxMacCoreGraphicsBrushData* d = new wxMacCoreGraphicsBrushData( this );
2914 d->CreateRadialGradientBrush(xo, yo, xc, yc, radius, stops);
2915 p.SetRefData(d);
2916 return p;
2917 }
2918
2919 // sets the font
2920 wxGraphicsFont wxMacCoreGraphicsRenderer::CreateFont( const wxFont &font , const wxColour &col )
2921 {
2922 if ( font.Ok() )
2923 {
2924 wxGraphicsFont p;
2925 p.SetRefData(new wxMacCoreGraphicsFontData( this , font, col ));
2926 return p;
2927 }
2928 else
2929 return wxNullGraphicsFont;
2930 }
2931
2932 //
2933 // CoreGraphics Helper Methods
2934 //
2935
2936 // Data Providers and Consumers
2937
2938 size_t UMAPutBytesCFRefCallback( void *info, const void *bytes, size_t count )
2939 {
2940 CFMutableDataRef data = (CFMutableDataRef) info;
2941 if ( data )
2942 {
2943 CFDataAppendBytes( data, (const UInt8*) bytes, count );
2944 }
2945 return count;
2946 }
2947
2948 void wxMacReleaseCFDataProviderCallback(void *info,
2949 const void *WXUNUSED(data),
2950 size_t WXUNUSED(count))
2951 {
2952 if ( info )
2953 CFRelease( (CFDataRef) info );
2954 }
2955
2956 void wxMacReleaseCFDataConsumerCallback( void *info )
2957 {
2958 if ( info )
2959 CFRelease( (CFDataRef) info );
2960 }
2961
2962 CGDataProviderRef wxMacCGDataProviderCreateWithCFData( CFDataRef data )
2963 {
2964 if ( data == NULL )
2965 return NULL;
2966
2967 return CGDataProviderCreateWithCFData( data );
2968 }
2969
2970 CGDataConsumerRef wxMacCGDataConsumerCreateWithCFData( CFMutableDataRef data )
2971 {
2972 if ( data == NULL )
2973 return NULL;
2974
2975 return CGDataConsumerCreateWithCFData( data );
2976 }
2977
2978 void
2979 wxMacReleaseMemoryBufferProviderCallback(void *info,
2980 const void * WXUNUSED_UNLESS_DEBUG(data),
2981 size_t WXUNUSED(size))
2982 {
2983 wxMemoryBuffer* membuf = (wxMemoryBuffer*) info ;
2984
2985 wxASSERT( data == membuf->GetData() ) ;
2986
2987 delete membuf ;
2988 }
2989
2990 CGDataProviderRef wxMacCGDataProviderCreateWithMemoryBuffer( const wxMemoryBuffer& buf )
2991 {
2992 wxMemoryBuffer* b = new wxMemoryBuffer( buf );
2993 if ( b->GetDataLen() == 0 )
2994 return NULL;
2995
2996 return CGDataProviderCreateWithData( b , (const void *) b->GetData() , b->GetDataLen() ,
2997 wxMacReleaseMemoryBufferProviderCallback );
2998 }
wxWidgets (Impactor)