]>
Commit | Line | Data |
---|---|---|
489468fe | 1 | ///////////////////////////////////////////////////////////////////////////// |
524c47aa | 2 | // Name: src/osx/carbon/dccg.cpp |
489468fe SC |
3 | // Purpose: wxDC class |
4 | // Author: Stefan Csomor | |
5 | // Modified by: | |
6 | // Created: 01/02/97 | |
7 | // RCS-ID: $Id$ | |
bf02a7f9 | 8 | // copyright: (c) Stefan Csomor |
489468fe SC |
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__ | |
b2680ced | 38 | #include "wx/osx/private.h" |
1f0c8f31 | 39 | #include "wx/osx/dcprint.h" |
b2680ced SC |
40 | #include "wx/osx/dcclient.h" |
41 | #include "wx/osx/dcmemory.h" | |
f28b6f06 | 42 | #include "wx/osx/private.h" |
489468fe SC |
43 | #else |
44 | #include "CoreServices/CoreServices.h" | |
45 | #include "ApplicationServices/ApplicationServices.h" | |
1f0c8f31 | 46 | #include "wx/osx/core/cfstring.h" |
489468fe SC |
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 | ||
292e5e1f | 70 | #define wxOSX_USE_CORE_TEXT 1 |
489468fe SC |
71 | |
72 | #endif | |
73 | ||
15fc716c | 74 | #if wxOSX_USE_COCOA_OR_IPHONE |
b4ff8b3e SC |
75 | extern CGContextRef wxOSXGetContextFromCurrentContext() ; |
76 | #if wxOSX_USE_COCOA | |
f28b6f06 | 77 | extern bool wxOSXLockFocus( WXWidget view) ; |
15fc716c SC |
78 | extern void wxOSXUnlockFocus( WXWidget view) ; |
79 | #endif | |
b4ff8b3e | 80 | #endif |
15fc716c | 81 | |
bf02a7f9 SC |
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, | |
03647350 | 101 | // NS only, unsupported by CG : Highlight |
bf02a7f9 SC |
102 | kCGCompositeOperationPlusLighter = 12 |
103 | } CGCompositeOperation ; | |
104 | ||
105 | extern "C" | |
106 | { | |
107 | CG_EXTERN void CGContextSetCompositeOperation (CGContextRef context, int operation); | |
108 | } ; | |
109 | ||
110 | #endif | |
15fc716c | 111 | |
489468fe SC |
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 | { | |
b2680ced SC |
136 | #if wxOSX_USE_CARBON |
137 | return HIViewDrawCGImage( inContext, inBounds, inImage ); | |
138 | #else | |
021db427 SC |
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); | |
489468fe | 146 | return noErr; |
489468fe SC |
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 | ||
292e5e1f | 171 | #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5 && wxOSX_USE_CORE_TEXT |
489468fe SC |
172 | |
173 | CTFontRef wxMacCreateCTFont( const wxFont& font ) | |
174 | { | |
175 | #ifdef __WXMAC__ | |
aa6208d9 | 176 | return wxCFRetain((CTFontRef) font.OSXGetCTFont()); |
489468fe SC |
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 | { | |
ab451f97 | 456 | case wxPENSTYLE_SOLID: |
489468fe SC |
457 | break; |
458 | ||
ab451f97 | 459 | case wxPENSTYLE_DOT: |
489468fe SC |
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 | ||
ab451f97 | 466 | case wxPENSTYLE_LONG_DASH: |
489468fe SC |
467 | m_count = WXSIZEOF(dashed); |
468 | m_lengths = dashed; | |
469 | break; | |
470 | ||
ab451f97 | 471 | case wxPENSTYLE_SHORT_DASH: |
489468fe SC |
472 | m_count = WXSIZEOF(short_dashed); |
473 | m_lengths = short_dashed; | |
474 | break; | |
475 | ||
ab451f97 | 476 | case wxPENSTYLE_DOT_DASH: |
489468fe SC |
477 | m_count = WXSIZEOF(dotted_dashed); |
478 | m_lengths = dotted_dashed; | |
479 | break; | |
480 | ||
ab451f97 | 481 | case wxPENSTYLE_USER_DASH: |
489468fe SC |
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 | ||
ab451f97 | 500 | case wxPENSTYLE_STIPPLE: |
489468fe SC |
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 | { | |
bf02a7f9 | 568 | CGContextSetStrokeColorWithColor( cg , m_color ); |
489468fe SC |
569 | } |
570 | } | |
571 | ||
572 | // | |
573 | // Brush | |
574 | // | |
575 | ||
489468fe SC |
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 ); | |
4ee4c7b9 VZ |
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); | |
489468fe SC |
675 | |
676 | virtual bool IsShading() { return m_isShading; } | |
677 | CGShadingRef GetShading() { return m_shading; } | |
678 | protected: | |
4ee4c7b9 VZ |
679 | CGFunctionRef CreateGradientFunction(const wxGraphicsGradientStops& stops); |
680 | ||
489468fe SC |
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; | |
ca1f7cb5 VZ |
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; | |
489468fe SC |
725 | }; |
726 | ||
727 | wxMacCoreGraphicsBrushData::wxMacCoreGraphicsBrushData( wxGraphicsRenderer* renderer) : wxGraphicsObjectRefData( renderer ) | |
728 | { | |
729 | Init(); | |
730 | } | |
731 | ||
4ee4c7b9 VZ |
732 | void |
733 | wxMacCoreGraphicsBrushData::CreateLinearGradientBrush(wxDouble x1, wxDouble y1, | |
734 | wxDouble x2, wxDouble y2, | |
735 | const wxGraphicsGradientStops& stops) | |
489468fe | 736 | { |
4ee4c7b9 | 737 | m_gradientFunction = CreateGradientFunction(stops); |
489468fe SC |
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 | ||
4ee4c7b9 VZ |
743 | void |
744 | wxMacCoreGraphicsBrushData::CreateRadialGradientBrush(wxDouble xo, wxDouble yo, | |
745 | wxDouble xc, wxDouble yc, | |
746 | wxDouble radius, | |
747 | const wxGraphicsGradientStops& stops) | |
489468fe | 748 | { |
4ee4c7b9 | 749 | m_gradientFunction = CreateGradientFunction(stops); |
0b7dce54 | 750 | m_shading = CGShadingCreateRadial( wxMacGetGenericRGBColorSpace(), CGPointMake((CGFloat) xo,(CGFloat) yo), 0, |
489468fe SC |
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); | |
489468fe SC |
769 | } |
770 | ||
771 | void wxMacCoreGraphicsBrushData::Init() | |
772 | { | |
773 | m_gradientFunction = NULL; | |
774 | m_shading = NULL; | |
489468fe SC |
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 | { | |
ca1f7cb5 VZ |
794 | const GradientComponents& stops = *(GradientComponents*) info ; |
795 | ||
489468fe | 796 | CGFloat f = *in; |
ca1f7cb5 | 797 | if (f <= 0.0) |
489468fe | 798 | { |
ca1f7cb5 VZ |
799 | // Start |
800 | out[0] = stops.comps[0].red; | |
801 | out[1] = stops.comps[1].green; | |
802 | out[2] = stops.comps[2].blue; | |
803 | out[3] = stops.comps[3].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; | |
e32454ea SC |
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; | |
489468fe SC |
832 | } |
833 | } | |
834 | ||
4ee4c7b9 VZ |
835 | CGFunctionRef |
836 | wxMacCoreGraphicsBrushData::CreateGradientFunction(const wxGraphicsGradientStops& stops) | |
489468fe | 837 | { |
4ee4c7b9 | 838 | |
489468fe SC |
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 }; | |
ca1f7cb5 VZ |
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, | |
489468fe SC |
858 | input_value_range, |
859 | 4, | |
860 | output_value_ranges, | |
861 | &callbacks); | |
862 | } | |
863 | ||
864 | // | |
865 | // Font | |
866 | // | |
867 | ||
b2680ced SC |
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 | ||
489468fe SC |
876 | class wxMacCoreGraphicsFontData : public wxGraphicsObjectRefData |
877 | { | |
878 | public: | |
879 | wxMacCoreGraphicsFontData( wxGraphicsRenderer* renderer, const wxFont &font, const wxColour& col ); | |
880 | ~wxMacCoreGraphicsFontData(); | |
881 | ||
292e5e1f | 882 | #if wxOSX_USE_ATSU_TEXT |
489468fe SC |
883 | virtual ATSUStyle GetATSUStyle() { return m_macATSUIStyle; } |
884 | #endif | |
292e5e1f | 885 | #if wxOSX_USE_CORE_TEXT |
aa6208d9 | 886 | CTFontRef OSXGetCTFont() const { return m_ctFont ; } |
489468fe SC |
887 | #endif |
888 | wxColour GetColour() const { return m_colour ; } | |
889 | ||
890 | bool GetUnderlined() const { return m_underlined ; } | |
b2680ced SC |
891 | #if wxOSX_USE_IPHONE |
892 | UIFont* GetUIFont() const { return m_uiFont; } | |
893 | #endif | |
489468fe SC |
894 | private : |
895 | wxColour m_colour; | |
896 | bool m_underlined; | |
292e5e1f | 897 | #if wxOSX_USE_ATSU_TEXT |
489468fe SC |
898 | ATSUStyle m_macATSUIStyle; |
899 | #endif | |
292e5e1f | 900 | #if wxOSX_USE_CORE_TEXT |
489468fe SC |
901 | wxCFRef< CTFontRef > m_ctFont; |
902 | #endif | |
b2680ced SC |
903 | #if wxOSX_USE_IPHONE |
904 | UIFont* m_uiFont; | |
905 | #endif | |
489468fe SC |
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 | ||
292e5e1f | 913 | #if wxOSX_USE_CORE_TEXT |
489468fe SC |
914 | m_ctFont.reset( wxMacCreateCTFont( font ) ); |
915 | #endif | |
b2680ced SC |
916 | #if wxOSX_USE_IPHONE |
917 | m_uiFont = CreateUIFont(font); | |
918 | wxMacCocoaRetain( m_uiFont ); | |
919 | #endif | |
292e5e1f | 920 | #if wxOSX_USE_ATSU_TEXT |
489468fe SC |
921 | OSStatus status = noErr; |
922 | m_macATSUIStyle = NULL; | |
923 | ||
140f2027 | 924 | status = ATSUCreateAndCopyStyle( (ATSUStyle) font.MacGetATSUStyle() , &m_macATSUIStyle ); |
489468fe SC |
925 | |
926 | wxASSERT_MSG( status == noErr, wxT("couldn't create ATSU style") ); | |
927 | ||
928 | // we need the scale here ... | |
929 | ||
f1c40652 | 930 | Fixed atsuSize = IntToFixed( int( 1 * font.GetPointSize()) ); |
489468fe SC |
931 | RGBColor atsuColor ; |
932 | col.GetRGBColor( &atsuColor ); | |
933 | ATSUAttributeTag atsuTags[] = | |
934 | { | |
935 | kATSUSizeTag , | |
936 | kATSUColorTag , | |
937 | }; | |
9611b797 | 938 | ByteCount atsuSizes[WXSIZEOF(atsuTags)] = |
489468fe SC |
939 | { |
940 | sizeof( Fixed ) , | |
941 | sizeof( RGBColor ) , | |
942 | }; | |
9611b797 | 943 | ATSUAttributeValuePtr atsuValues[WXSIZEOF(atsuTags)] = |
489468fe SC |
944 | { |
945 | &atsuSize , | |
946 | &atsuColor , | |
947 | }; | |
948 | ||
949 | status = ::ATSUSetAttributes( | |
9611b797 | 950 | m_macATSUIStyle, WXSIZEOF(atsuTags), |
489468fe SC |
951 | atsuTags, atsuSizes, atsuValues); |
952 | ||
953 | wxASSERT_MSG( status == noErr , wxT("couldn't modify ATSU style") ); | |
954 | #endif | |
489468fe SC |
955 | } |
956 | ||
957 | wxMacCoreGraphicsFontData::~wxMacCoreGraphicsFontData() | |
958 | { | |
292e5e1f | 959 | #if wxOSX_USE_CORE_TEXT |
489468fe | 960 | #endif |
292e5e1f | 961 | #if wxOSX_USE_ATSU_TEXT |
489468fe SC |
962 | if ( m_macATSUIStyle ) |
963 | { | |
964 | ::ATSUDisposeStyle((ATSUStyle)m_macATSUIStyle); | |
965 | m_macATSUIStyle = NULL; | |
966 | } | |
967 | #endif | |
b2680ced SC |
968 | #if wxOSX_USE_IPHONE |
969 | wxMacCocoaRelease( m_uiFont ); | |
489468fe SC |
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(m_matrix, *((CGAffineTransform*) t->GetNativeMatrix()) ); | |
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 | ||
4ee4c7b9 | 1221 | // appends a circle as a new closed subpath |
489468fe SC |
1222 | virtual void AddCircle( wxDouble x, wxDouble y, wxDouble r ); |
1223 | ||
9f43f269 SC |
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 | ||
489468fe SC |
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 *y) const; | |
1244 | ||
94a007ec | 1245 | virtual bool Contains( wxDouble x, wxDouble y, wxPolygonFillMode fillStyle = wxODDEVEN_RULE) const; |
489468fe SC |
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 | { | |
9f43f269 SC |
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)); | |
489468fe SC |
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 | ||
33ef0bdb | 1361 | bool wxMacCoreGraphicsPathData::Contains( wxDouble x, wxDouble y, wxPolygonFillMode fillStyle) const |
489468fe SC |
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 | ||
b2680ced | 1379 | #if wxOSX_USE_CARBON |
489468fe | 1380 | wxMacCoreGraphicsContext( wxGraphicsRenderer* renderer, WindowRef window ); |
b2680ced | 1381 | #endif |
489468fe SC |
1382 | |
1383 | wxMacCoreGraphicsContext( wxGraphicsRenderer* renderer, wxWindow* window ); | |
1384 | ||
1385 | wxMacCoreGraphicsContext( wxGraphicsRenderer* renderer); | |
1386 | ||
1387 | wxMacCoreGraphicsContext(); | |
1388 | ||
1389 | ~wxMacCoreGraphicsContext(); | |
1390 | ||
1391 | void Init(); | |
1392 | ||
1393 | // returns the size of the graphics context in device coordinates | |
1394 | virtual void GetSize( wxDouble* width, wxDouble* height); | |
1395 | ||
1396 | virtual void StartPage( wxDouble width, wxDouble height ); | |
1397 | ||
1398 | virtual void EndPage(); | |
1399 | ||
1400 | virtual void Flush(); | |
1401 | ||
1402 | // push the current state of the context, ie the transformation matrix on a stack | |
1403 | virtual void PushState(); | |
1404 | ||
1405 | // pops a stored state from the stack | |
1406 | virtual void PopState(); | |
1407 | ||
1408 | // clips drawings to the region | |
1409 | virtual void Clip( const wxRegion ®ion ); | |
1410 | ||
1411 | // clips drawings to the rect | |
1412 | virtual void Clip( wxDouble x, wxDouble y, wxDouble w, wxDouble h ); | |
1413 | ||
1414 | // resets the clipping to original extent | |
1415 | virtual void ResetClip(); | |
1416 | ||
1417 | virtual void * GetNativeContext(); | |
1418 | ||
bf02a7f9 SC |
1419 | virtual bool SetAntialiasMode(wxAntialiasMode antialias); |
1420 | ||
1421 | virtual bool SetCompositionMode(wxCompositionMode op); | |
1422 | ||
1423 | virtual void BeginLayer(wxDouble opacity); | |
1424 | ||
1425 | virtual void EndLayer(); | |
03647350 | 1426 | |
489468fe SC |
1427 | // |
1428 | // transformation | |
1429 | // | |
1430 | ||
1431 | // translate | |
1432 | virtual void Translate( wxDouble dx , wxDouble dy ); | |
1433 | ||
1434 | // scale | |
1435 | virtual void Scale( wxDouble xScale , wxDouble yScale ); | |
1436 | ||
1437 | // rotate (radians) | |
1438 | virtual void Rotate( wxDouble angle ); | |
1439 | ||
1440 | // concatenates this transform with the current transform of this context | |
1441 | virtual void ConcatTransform( const wxGraphicsMatrix& matrix ); | |
1442 | ||
1443 | // sets the transform of this context | |
1444 | virtual void SetTransform( const wxGraphicsMatrix& matrix ); | |
1445 | ||
1446 | // gets the matrix of this context | |
1447 | virtual wxGraphicsMatrix GetTransform() const; | |
1448 | // | |
1449 | // setting the paint | |
1450 | // | |
1451 | ||
1452 | // strokes along a path with the current pen | |
1453 | virtual void StrokePath( const wxGraphicsPath &path ); | |
1454 | ||
1455 | // fills a path with the current brush | |
33ef0bdb | 1456 | virtual void FillPath( const wxGraphicsPath &path, wxPolygonFillMode fillStyle = wxODDEVEN_RULE ); |
489468fe SC |
1457 | |
1458 | // draws a path by first filling and then stroking | |
33ef0bdb | 1459 | virtual void DrawPath( const wxGraphicsPath &path, wxPolygonFillMode fillStyle = wxODDEVEN_RULE ); |
489468fe SC |
1460 | |
1461 | virtual bool ShouldOffset() const | |
1462 | { | |
1463 | int penwidth = 0 ; | |
1464 | if ( !m_pen.IsNull() ) | |
1465 | { | |
1466 | penwidth = (int)((wxMacCoreGraphicsPenData*)m_pen.GetRefData())->GetWidth(); | |
1467 | if ( penwidth == 0 ) | |
1468 | penwidth = 1; | |
1469 | } | |
1470 | return ( penwidth % 2 ) == 1; | |
1471 | } | |
1472 | // | |
1473 | // text | |
1474 | // | |
1475 | ||
489468fe SC |
1476 | virtual void GetTextExtent( const wxString &text, wxDouble *width, wxDouble *height, |
1477 | wxDouble *descent, wxDouble *externalLeading ) const; | |
1478 | ||
1479 | virtual void GetPartialTextExtents(const wxString& text, wxArrayDouble& widths) const; | |
1480 | ||
1481 | // | |
1482 | // image support | |
1483 | // | |
1484 | ||
1485 | virtual void DrawBitmap( const wxBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h ); | |
1486 | ||
1487 | virtual void DrawBitmap( const wxGraphicsBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h ); | |
1488 | ||
1489 | virtual void DrawIcon( const wxIcon &icon, wxDouble x, wxDouble y, wxDouble w, wxDouble h ); | |
1490 | ||
1491 | void SetNativeContext( CGContextRef cg ); | |
1492 | ||
b2680ced | 1493 | DECLARE_DYNAMIC_CLASS_NO_COPY(wxMacCoreGraphicsContext) |
489468fe SC |
1494 | |
1495 | private: | |
f28b6f06 | 1496 | bool EnsureIsValid(); |
489468fe | 1497 | |
0b7dce54 VZ |
1498 | virtual void DoDrawText( const wxString &str, wxDouble x, wxDouble y ); |
1499 | virtual void DoDrawRotatedText( const wxString &str, wxDouble x, wxDouble y, wxDouble angle ); | |
1500 | ||
489468fe | 1501 | CGContextRef m_cgContext; |
b2680ced | 1502 | #if wxOSX_USE_CARBON |
489468fe | 1503 | WindowRef m_windowRef; |
15fc716c SC |
1504 | #else |
1505 | WXWidget m_view; | |
b2680ced | 1506 | #endif |
15fc716c | 1507 | bool m_contextSynthesized; |
489468fe SC |
1508 | CGAffineTransform m_windowTransform; |
1509 | wxDouble m_width; | |
1510 | wxDouble m_height; | |
f28b6f06 | 1511 | bool m_invisible; |
489468fe | 1512 | |
15fc716c | 1513 | #if wxOSX_USE_COCOA_OR_CARBON |
489468fe | 1514 | wxCFRef<HIShapeRef> m_clipRgn; |
b2680ced | 1515 | #endif |
489468fe SC |
1516 | }; |
1517 | ||
1518 | //----------------------------------------------------------------------------- | |
1519 | // device context implementation | |
1520 | // | |
1521 | // more and more of the dc functionality should be implemented by calling | |
1522 | // the appropricate wxMacCoreGraphicsContext, but we will have to do that step by step | |
1523 | // also coordinate conversions should be moved to native matrix ops | |
1524 | //----------------------------------------------------------------------------- | |
1525 | ||
1526 | // we always stock two context states, one at entry, to be able to preserve the | |
1527 | // state we were called with, the other one after changing to HI Graphics orientation | |
1528 | // (this one is used for getting back clippings etc) | |
1529 | ||
1530 | //----------------------------------------------------------------------------- | |
1531 | // wxMacCoreGraphicsContext implementation | |
1532 | //----------------------------------------------------------------------------- | |
1533 | ||
1534 | IMPLEMENT_DYNAMIC_CLASS(wxMacCoreGraphicsContext, wxGraphicsContext) | |
1535 | ||
1536 | class wxQuartzOffsetHelper | |
1537 | { | |
1538 | public : | |
1539 | wxQuartzOffsetHelper( CGContextRef cg , bool offset ) | |
1540 | { | |
1541 | m_cg = cg; | |
1542 | m_offset = offset; | |
1543 | if ( m_offset ) | |
e812e279 SC |
1544 | { |
1545 | m_userOffset = CGContextConvertSizeToUserSpace( m_cg, CGSizeMake( 0.5 , 0.5 ) ); | |
1546 | CGContextTranslateCTM( m_cg, m_userOffset.width , m_userOffset.height ); | |
1547 | } | |
24e67779 SC |
1548 | else |
1549 | { | |
1550 | m_userOffset = CGSizeMake(0.0, 0.0); | |
1551 | } | |
1552 | ||
489468fe SC |
1553 | } |
1554 | ~wxQuartzOffsetHelper( ) | |
1555 | { | |
1556 | if ( m_offset ) | |
e812e279 | 1557 | CGContextTranslateCTM( m_cg, -m_userOffset.width , -m_userOffset.height ); |
489468fe SC |
1558 | } |
1559 | public : | |
e812e279 | 1560 | CGSize m_userOffset; |
489468fe SC |
1561 | CGContextRef m_cg; |
1562 | bool m_offset; | |
1563 | } ; | |
1564 | ||
1565 | void wxMacCoreGraphicsContext::Init() | |
1566 | { | |
1567 | m_cgContext = NULL; | |
15fc716c SC |
1568 | m_contextSynthesized = false; |
1569 | m_width = 0; | |
1570 | m_height = 0; | |
b2680ced | 1571 | #if wxOSX_USE_CARBON |
489468fe | 1572 | m_windowRef = NULL; |
b2680ced | 1573 | #endif |
15fc716c SC |
1574 | #if wxOSX_USE_COCOA_OR_IPHONE |
1575 | m_view = NULL; | |
1576 | #endif | |
f28b6f06 | 1577 | m_invisible = false; |
489468fe SC |
1578 | } |
1579 | ||
1580 | wxMacCoreGraphicsContext::wxMacCoreGraphicsContext( wxGraphicsRenderer* renderer, CGContextRef cgcontext, wxDouble width, wxDouble height ) : wxGraphicsContext(renderer) | |
1581 | { | |
1582 | Init(); | |
1583 | SetNativeContext(cgcontext); | |
1584 | m_width = width; | |
1585 | m_height = height; | |
1586 | } | |
1587 | ||
b2680ced | 1588 | #if wxOSX_USE_CARBON |
489468fe SC |
1589 | wxMacCoreGraphicsContext::wxMacCoreGraphicsContext( wxGraphicsRenderer* renderer, WindowRef window ): wxGraphicsContext(renderer) |
1590 | { | |
1591 | Init(); | |
1592 | m_windowRef = window; | |
1593 | } | |
b2680ced | 1594 | #endif |
489468fe SC |
1595 | |
1596 | wxMacCoreGraphicsContext::wxMacCoreGraphicsContext( wxGraphicsRenderer* renderer, wxWindow* window ): wxGraphicsContext(renderer) | |
1597 | { | |
1598 | Init(); | |
1599 | ||
15fc716c SC |
1600 | wxSize sz = window->GetSize(); |
1601 | m_width = sz.x; | |
1602 | m_height = sz.y; | |
1603 | ||
1604 | #if wxOSX_USE_COCOA_OR_IPHONE | |
1605 | m_view = window->GetHandle(); | |
1606 | ||
b4ff8b3e SC |
1607 | #if wxOSX_USE_COCOA |
1608 | if ( ! window->GetPeer()->IsFlipped() ) | |
15fc716c SC |
1609 | { |
1610 | m_windowTransform = CGAffineTransformMakeTranslation( 0 , m_height ); | |
1611 | m_windowTransform = CGAffineTransformScale( m_windowTransform , 1 , -1 ); | |
1612 | } | |
1613 | else | |
b4ff8b3e | 1614 | #endif |
15fc716c SC |
1615 | { |
1616 | m_windowTransform = CGAffineTransformIdentity; | |
1617 | } | |
1618 | #else | |
489468fe SC |
1619 | int originX , originY; |
1620 | originX = originY = 0; | |
489468fe | 1621 | Rect bounds = { 0,0,0,0 }; |
489468fe SC |
1622 | m_windowRef = (WindowRef) window->MacGetTopLevelWindowRef(); |
1623 | window->MacWindowToRootWindow( &originX , &originY ); | |
1624 | GetWindowBounds( m_windowRef, kWindowContentRgn, &bounds ); | |
489468fe SC |
1625 | m_windowTransform = CGAffineTransformMakeTranslation( 0 , bounds.bottom - bounds.top ); |
1626 | m_windowTransform = CGAffineTransformScale( m_windowTransform , 1 , -1 ); | |
1627 | m_windowTransform = CGAffineTransformTranslate( m_windowTransform, originX, originY ) ; | |
15fc716c | 1628 | #endif |
489468fe SC |
1629 | } |
1630 | ||
1631 | wxMacCoreGraphicsContext::wxMacCoreGraphicsContext(wxGraphicsRenderer* renderer) : wxGraphicsContext(renderer) | |
1632 | { | |
1633 | Init(); | |
1634 | } | |
1635 | ||
1636 | wxMacCoreGraphicsContext::wxMacCoreGraphicsContext() : wxGraphicsContext(NULL) | |
1637 | { | |
1638 | Init(); | |
1639 | wxLogDebug(wxT("Illegal Constructor called")); | |
1640 | } | |
1641 | ||
1642 | wxMacCoreGraphicsContext::~wxMacCoreGraphicsContext() | |
1643 | { | |
1644 | SetNativeContext(NULL); | |
1645 | } | |
1646 | ||
1647 | void wxMacCoreGraphicsContext::GetSize( wxDouble* width, wxDouble* height) | |
1648 | { | |
1649 | *width = m_width; | |
1650 | *height = m_height; | |
1651 | } | |
1652 | ||
1653 | ||
1654 | void wxMacCoreGraphicsContext::StartPage( wxDouble width, wxDouble height ) | |
1655 | { | |
1656 | CGRect r; | |
1657 | if ( width != 0 && height != 0) | |
1658 | r = CGRectMake( (CGFloat) 0.0 , (CGFloat) 0.0 , (CGFloat) width , (CGFloat) height ); | |
1659 | else | |
1660 | r = CGRectMake( (CGFloat) 0.0 , (CGFloat) 0.0 , (CGFloat) m_width , (CGFloat) m_height ); | |
1661 | ||
1662 | CGContextBeginPage(m_cgContext, &r ); | |
1663 | // CGContextTranslateCTM( m_cgContext , 0 , height == 0 ? m_height : height ); | |
1664 | // CGContextScaleCTM( m_cgContext , 1 , -1 ); | |
1665 | } | |
1666 | ||
1667 | void wxMacCoreGraphicsContext::EndPage() | |
1668 | { | |
1669 | CGContextEndPage(m_cgContext); | |
1670 | } | |
1671 | ||
1672 | void wxMacCoreGraphicsContext::Flush() | |
1673 | { | |
1674 | CGContextFlush(m_cgContext); | |
1675 | } | |
1676 | ||
f28b6f06 | 1677 | bool wxMacCoreGraphicsContext::EnsureIsValid() |
489468fe SC |
1678 | { |
1679 | if ( !m_cgContext ) | |
1680 | { | |
f28b6f06 SC |
1681 | if (m_invisible) |
1682 | return false; | |
03647350 | 1683 | |
b4ff8b3e | 1684 | #if wxOSX_USE_COCOA |
f28b6f06 SC |
1685 | if ( wxOSXLockFocus(m_view) ) |
1686 | { | |
b4ff8b3e | 1687 | m_cgContext = wxOSXGetContextFromCurrentContext(); |
9a83f860 | 1688 | wxASSERT_MSG( m_cgContext != NULL, wxT("Unable to retrieve drawing context from View")); |
f28b6f06 SC |
1689 | } |
1690 | else | |
1691 | { | |
1692 | m_invisible = true; | |
1693 | } | |
15fc716c | 1694 | #endif |
b4ff8b3e SC |
1695 | #if wxOSX_USE_IPHONE |
1696 | m_cgContext = wxOSXGetContextFromCurrentContext(); | |
1697 | if ( m_cgContext == NULL ) | |
1698 | { | |
1699 | m_invisible = true; | |
1700 | } | |
1701 | #endif | |
15fc716c | 1702 | #if wxOSX_USE_CARBON |
b2680ced | 1703 | OSStatus status = QDBeginCGContext( GetWindowPort( m_windowRef ) , &m_cgContext ); |
489468fe SC |
1704 | if ( status != noErr ) |
1705 | { | |
1706 | wxFAIL_MSG("Cannot nest wxDCs on the same window"); | |
1707 | } | |
15fc716c | 1708 | #endif |
f28b6f06 | 1709 | if ( m_cgContext ) |
489468fe | 1710 | { |
f28b6f06 | 1711 | CGContextSaveGState( m_cgContext ); |
6bd1764f SC |
1712 | CGContextConcatCTM( m_cgContext, m_windowTransform ); |
1713 | CGContextSetTextMatrix( m_cgContext, CGAffineTransformIdentity ); | |
f28b6f06 | 1714 | m_contextSynthesized = true; |
b4ff8b3e | 1715 | #if wxOSX_USE_COCOA_OR_CARBON |
f28b6f06 | 1716 | if ( m_clipRgn.get() ) |
489468fe | 1717 | { |
f28b6f06 SC |
1718 | // the clip region is in device coordinates, so we convert this again to user coordinates |
1719 | wxCFRef<HIMutableShapeRef> hishape( HIShapeCreateMutableCopy( m_clipRgn ) ); | |
1720 | CGPoint transformedOrigin = CGPointApplyAffineTransform( CGPointZero,m_windowTransform); | |
1721 | HIShapeOffset( hishape, -transformedOrigin.x, -transformedOrigin.y ); | |
1722 | // if the shape is empty, HIShapeReplacePathInCGContext doesn't work | |
1723 | if ( HIShapeIsEmpty(hishape)) | |
1724 | { | |
1725 | CGRect empty = CGRectMake( 0,0,0,0 ); | |
1726 | CGContextClipToRect( m_cgContext, empty ); | |
1727 | } | |
1728 | else | |
1729 | { | |
1730 | HIShapeReplacePathInCGContext( hishape, m_cgContext ); | |
1731 | CGContextClip( m_cgContext ); | |
1732 | } | |
489468fe | 1733 | } |
b4ff8b3e | 1734 | #endif |
f28b6f06 | 1735 | CGContextSaveGState( m_cgContext ); |
03647350 | 1736 | |
f28b6f06 SC |
1737 | #if 0 // turn on for debugging of clientdc |
1738 | static float color = 0.5 ; | |
1739 | static int channel = 0 ; | |
1740 | CGRect bounds = CGRectMake(-1000,-1000,2000,2000); | |
1741 | CGContextSetRGBFillColor( m_cgContext, channel == 0 ? color : 0.5 , | |
1742 | channel == 1 ? color : 0.5 , channel == 2 ? color : 0.5 , 1 ); | |
1743 | CGContextFillRect( m_cgContext, bounds ); | |
1744 | color += 0.1 ; | |
1745 | if ( color > 0.9 ) | |
489468fe | 1746 | { |
f28b6f06 SC |
1747 | color = 0.5 ; |
1748 | channel++ ; | |
1749 | if ( channel == 3 ) | |
1750 | channel = 0 ; | |
489468fe | 1751 | } |
b2680ced | 1752 | #endif |
f28b6f06 | 1753 | } |
489468fe | 1754 | } |
f28b6f06 | 1755 | return m_cgContext != NULL; |
489468fe SC |
1756 | } |
1757 | ||
bf02a7f9 | 1758 | bool wxMacCoreGraphicsContext::SetAntialiasMode(wxAntialiasMode antialias) |
489468fe | 1759 | { |
ab451f97 | 1760 | if (!EnsureIsValid()) |
bf02a7f9 SC |
1761 | return true; |
1762 | ||
1763 | if (m_antialias == antialias) | |
489468fe | 1764 | return true; |
03647350 | 1765 | |
bf02a7f9 | 1766 | m_antialias = antialias; |
03647350 | 1767 | |
bf02a7f9 SC |
1768 | bool antialiasMode; |
1769 | switch (antialias) | |
1770 | { | |
1771 | case wxANTIALIAS_DEFAULT: | |
1772 | antialiasMode = true; | |
1773 | break; | |
1774 | case wxANTIALIAS_NONE: | |
1775 | antialiasMode = false; | |
1776 | break; | |
1777 | default: | |
1778 | return false; | |
1779 | } | |
1780 | CGContextSetShouldAntialias(m_cgContext, antialiasMode); | |
1781 | return true; | |
1782 | } | |
489468fe | 1783 | |
bf02a7f9 SC |
1784 | bool wxMacCoreGraphicsContext::SetCompositionMode(wxCompositionMode op) |
1785 | { | |
ab451f97 | 1786 | if (!EnsureIsValid()) |
f28b6f06 | 1787 | return true; |
489468fe | 1788 | |
bf02a7f9 SC |
1789 | if ( m_composition == op ) |
1790 | return true; | |
03647350 | 1791 | |
bf02a7f9 | 1792 | m_composition = op; |
03647350 | 1793 | |
bf02a7f9 SC |
1794 | if (m_composition == wxCOMPOSITION_DEST) |
1795 | return true; | |
03647350 | 1796 | |
bf02a7f9 | 1797 | #if wxOSX_USE_COCOA_OR_CARBON |
bf02a7f9 | 1798 | if ( UMAGetSystemVersion() < 0x1060 ) |
489468fe | 1799 | { |
bf02a7f9 SC |
1800 | CGCompositeOperation cop = kCGCompositeOperationSourceOver; |
1801 | CGBlendMode mode = kCGBlendModeNormal; | |
1802 | switch( op ) | |
489468fe | 1803 | { |
bf02a7f9 | 1804 | case wxCOMPOSITION_CLEAR: |
03647350 | 1805 | cop = kCGCompositeOperationClear; |
bf02a7f9 SC |
1806 | break; |
1807 | case wxCOMPOSITION_SOURCE: | |
03647350 | 1808 | cop = kCGCompositeOperationCopy; |
bf02a7f9 SC |
1809 | break; |
1810 | case wxCOMPOSITION_OVER: | |
03647350 | 1811 | mode = kCGBlendModeNormal; |
bf02a7f9 SC |
1812 | break; |
1813 | case wxCOMPOSITION_IN: | |
03647350 | 1814 | cop = kCGCompositeOperationSourceIn; |
bf02a7f9 SC |
1815 | break; |
1816 | case wxCOMPOSITION_OUT: | |
03647350 | 1817 | cop = kCGCompositeOperationSourceOut; |
bf02a7f9 SC |
1818 | break; |
1819 | case wxCOMPOSITION_ATOP: | |
03647350 | 1820 | cop = kCGCompositeOperationSourceAtop; |
bf02a7f9 SC |
1821 | break; |
1822 | case wxCOMPOSITION_DEST_OVER: | |
03647350 | 1823 | cop = kCGCompositeOperationDestinationOver; |
bf02a7f9 SC |
1824 | break; |
1825 | case wxCOMPOSITION_DEST_IN: | |
03647350 | 1826 | cop = kCGCompositeOperationDestinationIn; |
bf02a7f9 SC |
1827 | break; |
1828 | case wxCOMPOSITION_DEST_OUT: | |
03647350 | 1829 | cop = kCGCompositeOperationDestinationOut; |
bf02a7f9 SC |
1830 | break; |
1831 | case wxCOMPOSITION_DEST_ATOP: | |
03647350 | 1832 | cop = kCGCompositeOperationDestinationAtop; |
bf02a7f9 SC |
1833 | break; |
1834 | case wxCOMPOSITION_XOR: | |
03647350 | 1835 | cop = kCGCompositeOperationXOR; |
bf02a7f9 | 1836 | break; |
c0b5b33b | 1837 | #if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5 |
bf02a7f9 SC |
1838 | case wxCOMPOSITION_ADD: |
1839 | mode = kCGBlendModePlusLighter ; | |
1840 | break; | |
c0b5b33b | 1841 | #endif |
bf02a7f9 SC |
1842 | default: |
1843 | return false; | |
489468fe | 1844 | } |
bf02a7f9 SC |
1845 | if ( cop != kCGCompositeOperationSourceOver ) |
1846 | CGContextSetCompositeOperation(m_cgContext, cop); | |
1847 | else | |
1848 | CGContextSetBlendMode(m_cgContext, mode); | |
489468fe | 1849 | } |
489468fe | 1850 | #endif |
f72e03b2 KO |
1851 | #if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5 |
1852 | else | |
489468fe | 1853 | { |
bf02a7f9 SC |
1854 | CGBlendMode mode = kCGBlendModeNormal; |
1855 | switch( op ) | |
489468fe | 1856 | { |
bf02a7f9 | 1857 | case wxCOMPOSITION_CLEAR: |
03647350 | 1858 | mode = kCGBlendModeClear; |
bf02a7f9 SC |
1859 | break; |
1860 | case wxCOMPOSITION_SOURCE: | |
03647350 | 1861 | mode = kCGBlendModeCopy; |
bf02a7f9 SC |
1862 | break; |
1863 | case wxCOMPOSITION_OVER: | |
03647350 | 1864 | mode = kCGBlendModeNormal; |
bf02a7f9 SC |
1865 | break; |
1866 | case wxCOMPOSITION_IN: | |
03647350 | 1867 | mode = kCGBlendModeSourceIn; |
bf02a7f9 SC |
1868 | break; |
1869 | case wxCOMPOSITION_OUT: | |
03647350 | 1870 | mode = kCGBlendModeSourceOut; |
bf02a7f9 SC |
1871 | break; |
1872 | case wxCOMPOSITION_ATOP: | |
03647350 | 1873 | mode = kCGBlendModeSourceAtop; |
bf02a7f9 SC |
1874 | break; |
1875 | case wxCOMPOSITION_DEST_OVER: | |
03647350 | 1876 | mode = kCGBlendModeDestinationOver; |
bf02a7f9 SC |
1877 | break; |
1878 | case wxCOMPOSITION_DEST_IN: | |
03647350 | 1879 | mode = kCGBlendModeDestinationIn; |
bf02a7f9 SC |
1880 | break; |
1881 | case wxCOMPOSITION_DEST_OUT: | |
03647350 | 1882 | mode = kCGBlendModeDestinationOut; |
bf02a7f9 SC |
1883 | break; |
1884 | case wxCOMPOSITION_DEST_ATOP: | |
03647350 | 1885 | mode = kCGBlendModeDestinationAtop; |
bf02a7f9 SC |
1886 | break; |
1887 | case wxCOMPOSITION_XOR: | |
03647350 | 1888 | mode = kCGBlendModeXOR; |
bf02a7f9 | 1889 | break; |
03647350 | 1890 | |
bf02a7f9 SC |
1891 | case wxCOMPOSITION_ADD: |
1892 | mode = kCGBlendModePlusLighter ; | |
1893 | break; | |
1894 | default: | |
1895 | return false; | |
489468fe | 1896 | } |
bf02a7f9 | 1897 | CGContextSetBlendMode(m_cgContext, mode); |
489468fe | 1898 | } |
f72e03b2 | 1899 | #endif |
bf02a7f9 SC |
1900 | return true; |
1901 | } | |
489468fe | 1902 | |
bf02a7f9 SC |
1903 | void wxMacCoreGraphicsContext::BeginLayer(wxDouble opacity) |
1904 | { | |
1905 | CGContextSaveGState(m_cgContext); | |
de0d2095 | 1906 | CGContextSetAlpha(m_cgContext, (CGFloat) opacity); |
bf02a7f9 SC |
1907 | CGContextBeginTransparencyLayer(m_cgContext, 0); |
1908 | } | |
1909 | ||
1910 | void wxMacCoreGraphicsContext::EndLayer() | |
1911 | { | |
1912 | CGContextEndTransparencyLayer(m_cgContext); | |
1913 | CGContextRestoreGState(m_cgContext); | |
489468fe SC |
1914 | } |
1915 | ||
1916 | void wxMacCoreGraphicsContext::Clip( const wxRegion ®ion ) | |
1917 | { | |
15fc716c | 1918 | #if wxOSX_USE_COCOA_OR_CARBON |
489468fe SC |
1919 | if( m_cgContext ) |
1920 | { | |
1921 | wxCFRef<HIShapeRef> shape = wxCFRefFromGet(region.GetWXHRGN()); | |
1922 | // if the shape is empty, HIShapeReplacePathInCGContext doesn't work | |
1923 | if ( HIShapeIsEmpty(shape)) | |
1924 | { | |
1925 | CGRect empty = CGRectMake( 0,0,0,0 ); | |
1926 | CGContextClipToRect( m_cgContext, empty ); | |
1927 | } | |
1928 | else | |
1929 | { | |
1930 | HIShapeReplacePathInCGContext( shape, m_cgContext ); | |
1931 | CGContextClip( m_cgContext ); | |
1932 | } | |
1933 | } | |
1934 | else | |
1935 | { | |
1936 | // this offsetting to device coords is not really correct, but since we cannot apply affine transforms | |
1937 | // to regions we try at least to have correct translations | |
1938 | HIMutableShapeRef mutableShape = HIShapeCreateMutableCopy( region.GetWXHRGN() ); | |
1939 | ||
1940 | CGPoint transformedOrigin = CGPointApplyAffineTransform( CGPointZero, m_windowTransform ); | |
1941 | HIShapeOffset( mutableShape, transformedOrigin.x, transformedOrigin.y ); | |
1942 | m_clipRgn.reset(mutableShape); | |
1943 | } | |
b2680ced SC |
1944 | #else |
1945 | // allow usage as measuring context | |
1946 | // wxASSERT_MSG( m_cgContext != NULL, "Needs a valid context for clipping" ); | |
489468fe SC |
1947 | #endif |
1948 | } | |
1949 | ||
1950 | // clips drawings to the rect | |
1951 | void wxMacCoreGraphicsContext::Clip( wxDouble x, wxDouble y, wxDouble w, wxDouble h ) | |
1952 | { | |
1953 | CGRect r = CGRectMake( (CGFloat) x , (CGFloat) y , (CGFloat) w , (CGFloat) h ); | |
1954 | if ( m_cgContext ) | |
1955 | { | |
1956 | CGContextClipToRect( m_cgContext, r ); | |
1957 | } | |
1958 | else | |
1959 | { | |
15fc716c | 1960 | #if wxOSX_USE_COCOA_OR_CARBON |
489468fe SC |
1961 | // the clipping itself must be stored as device coordinates, otherwise |
1962 | // we cannot apply it back correctly | |
1963 | r.origin= CGPointApplyAffineTransform( r.origin, m_windowTransform ); | |
1964 | m_clipRgn.reset(HIShapeCreateWithRect(&r)); | |
b2680ced SC |
1965 | #else |
1966 | // allow usage as measuring context | |
1967 | // wxFAIL_MSG( "Needs a valid context for clipping" ); | |
1968 | #endif | |
489468fe SC |
1969 | } |
1970 | } | |
1971 | ||
1972 | // resets the clipping to original extent | |
1973 | void wxMacCoreGraphicsContext::ResetClip() | |
1974 | { | |
1975 | if ( m_cgContext ) | |
1976 | { | |
1977 | // there is no way for clearing the clip, we can only revert to the stored | |
1978 | // state, but then we have to make sure everything else is NOT restored | |
1979 | CGAffineTransform transform = CGContextGetCTM( m_cgContext ); | |
1980 | CGContextRestoreGState( m_cgContext ); | |
1981 | CGContextSaveGState( m_cgContext ); | |
1982 | CGAffineTransform transformNew = CGContextGetCTM( m_cgContext ); | |
1983 | transformNew = CGAffineTransformInvert( transformNew ) ; | |
1984 | CGContextConcatCTM( m_cgContext, transformNew); | |
1985 | CGContextConcatCTM( m_cgContext, transform); | |
1986 | } | |
1987 | else | |
1988 | { | |
15fc716c | 1989 | #if wxOSX_USE_COCOA_OR_CARBON |
489468fe | 1990 | m_clipRgn.reset(); |
b2680ced SC |
1991 | #else |
1992 | // allow usage as measuring context | |
1993 | // wxFAIL_MSG( "Needs a valid context for clipping" ); | |
1994 | #endif | |
489468fe SC |
1995 | } |
1996 | } | |
1997 | ||
1998 | void wxMacCoreGraphicsContext::StrokePath( const wxGraphicsPath &path ) | |
1999 | { | |
2000 | if ( m_pen.IsNull() ) | |
2001 | return ; | |
2002 | ||
ab451f97 | 2003 | if (!EnsureIsValid()) |
f28b6f06 | 2004 | return; |
03647350 | 2005 | |
bf02a7f9 SC |
2006 | if (m_composition == wxCOMPOSITION_DEST) |
2007 | return; | |
2008 | ||
489468fe SC |
2009 | wxQuartzOffsetHelper helper( m_cgContext , ShouldOffset() ); |
2010 | ||
2011 | ((wxMacCoreGraphicsPenData*)m_pen.GetRefData())->Apply(this); | |
2012 | CGContextAddPath( m_cgContext , (CGPathRef) path.GetNativePath() ); | |
2013 | CGContextStrokePath( m_cgContext ); | |
2014 | } | |
2015 | ||
33ef0bdb | 2016 | void wxMacCoreGraphicsContext::DrawPath( const wxGraphicsPath &path , wxPolygonFillMode fillStyle ) |
489468fe | 2017 | { |
ab451f97 | 2018 | if (!EnsureIsValid()) |
f28b6f06 | 2019 | return; |
03647350 | 2020 | |
bf02a7f9 SC |
2021 | if (m_composition == wxCOMPOSITION_DEST) |
2022 | return; | |
2023 | ||
489468fe SC |
2024 | if ( !m_brush.IsNull() && ((wxMacCoreGraphicsBrushData*)m_brush.GetRefData())->IsShading() ) |
2025 | { | |
2026 | // when using shading, we cannot draw pen and brush at the same time | |
2027 | // revert to the base implementation of first filling and then stroking | |
2028 | wxGraphicsContext::DrawPath( path, fillStyle ); | |
2029 | return; | |
2030 | } | |
2031 | ||
2032 | CGPathDrawingMode mode = kCGPathFill ; | |
2033 | if ( m_brush.IsNull() ) | |
2034 | { | |
2035 | if ( m_pen.IsNull() ) | |
2036 | return; | |
2037 | else | |
2038 | mode = kCGPathStroke; | |
2039 | } | |
2040 | else | |
2041 | { | |
2042 | if ( m_pen.IsNull() ) | |
2043 | { | |
2044 | if ( fillStyle == wxODDEVEN_RULE ) | |
2045 | mode = kCGPathEOFill; | |
2046 | else | |
2047 | mode = kCGPathFill; | |
2048 | } | |
2049 | else | |
2050 | { | |
2051 | if ( fillStyle == wxODDEVEN_RULE ) | |
2052 | mode = kCGPathEOFillStroke; | |
2053 | else | |
2054 | mode = kCGPathFillStroke; | |
2055 | } | |
2056 | } | |
2057 | ||
489468fe SC |
2058 | if ( !m_brush.IsNull() ) |
2059 | ((wxMacCoreGraphicsBrushData*)m_brush.GetRefData())->Apply(this); | |
2060 | if ( !m_pen.IsNull() ) | |
2061 | ((wxMacCoreGraphicsPenData*)m_pen.GetRefData())->Apply(this); | |
2062 | ||
2063 | wxQuartzOffsetHelper helper( m_cgContext , ShouldOffset() ); | |
2064 | ||
2065 | CGContextAddPath( m_cgContext , (CGPathRef) path.GetNativePath() ); | |
2066 | CGContextDrawPath( m_cgContext , mode ); | |
2067 | } | |
2068 | ||
33ef0bdb | 2069 | void wxMacCoreGraphicsContext::FillPath( const wxGraphicsPath &path , wxPolygonFillMode fillStyle ) |
489468fe SC |
2070 | { |
2071 | if ( m_brush.IsNull() ) | |
2072 | return; | |
2073 | ||
ab451f97 | 2074 | if (!EnsureIsValid()) |
f28b6f06 | 2075 | return; |
03647350 | 2076 | |
bf02a7f9 SC |
2077 | if (m_composition == wxCOMPOSITION_DEST) |
2078 | return; | |
2079 | ||
489468fe SC |
2080 | if ( ((wxMacCoreGraphicsBrushData*)m_brush.GetRefData())->IsShading() ) |
2081 | { | |
2082 | CGContextSaveGState( m_cgContext ); | |
2083 | CGContextAddPath( m_cgContext , (CGPathRef) path.GetNativePath() ); | |
2084 | CGContextClip( m_cgContext ); | |
2085 | CGContextDrawShading( m_cgContext, ((wxMacCoreGraphicsBrushData*)m_brush.GetRefData())->GetShading() ); | |
2086 | CGContextRestoreGState( m_cgContext); | |
2087 | } | |
2088 | else | |
2089 | { | |
2090 | ((wxMacCoreGraphicsBrushData*)m_brush.GetRefData())->Apply(this); | |
2091 | CGContextAddPath( m_cgContext , (CGPathRef) path.GetNativePath() ); | |
2092 | if ( fillStyle == wxODDEVEN_RULE ) | |
2093 | CGContextEOFillPath( m_cgContext ); | |
2094 | else | |
2095 | CGContextFillPath( m_cgContext ); | |
2096 | } | |
2097 | } | |
2098 | ||
2099 | void wxMacCoreGraphicsContext::SetNativeContext( CGContextRef cg ) | |
2100 | { | |
2101 | // we allow either setting or clearing but not replacing | |
2102 | wxASSERT( m_cgContext == NULL || cg == NULL ); | |
2103 | ||
2104 | if ( m_cgContext ) | |
2105 | { | |
489468fe SC |
2106 | CGContextRestoreGState( m_cgContext ); |
2107 | CGContextRestoreGState( m_cgContext ); | |
15fc716c | 2108 | if ( m_contextSynthesized ) |
489468fe | 2109 | { |
b2680ced | 2110 | #if wxOSX_USE_CARBON |
489468fe | 2111 | QDEndCGContext( GetWindowPort( m_windowRef ) , &m_cgContext); |
15fc716c | 2112 | #endif |
b4ff8b3e | 2113 | #if wxOSX_USE_COCOA |
15fc716c | 2114 | wxOSXUnlockFocus(m_view); |
489468fe SC |
2115 | #endif |
2116 | } | |
2117 | else | |
2118 | CGContextRelease(m_cgContext); | |
2119 | } | |
2120 | ||
489468fe SC |
2121 | m_cgContext = cg; |
2122 | ||
2123 | // FIXME: This check is needed because currently we need to use a DC/GraphicsContext | |
2124 | // in order to get font properties, like wxFont::GetPixelSize, but since we don't have | |
2125 | // a native window attached to use, I create a wxGraphicsContext with a NULL CGContextRef | |
2126 | // for this one operation. | |
2127 | ||
2128 | // When wxFont::GetPixelSize on Mac no longer needs a graphics context, this check | |
2129 | // can be removed. | |
2130 | if (m_cgContext) | |
2131 | { | |
2132 | CGContextRetain(m_cgContext); | |
2133 | CGContextSaveGState( m_cgContext ); | |
2134 | CGContextSetTextMatrix( m_cgContext, CGAffineTransformIdentity ); | |
2135 | CGContextSaveGState( m_cgContext ); | |
15fc716c | 2136 | m_contextSynthesized = false; |
489468fe SC |
2137 | } |
2138 | } | |
2139 | ||
2140 | void wxMacCoreGraphicsContext::Translate( wxDouble dx , wxDouble dy ) | |
2141 | { | |
2142 | if ( m_cgContext ) | |
2143 | CGContextTranslateCTM( m_cgContext, (CGFloat) dx, (CGFloat) dy ); | |
2144 | else | |
2145 | m_windowTransform = CGAffineTransformTranslate(m_windowTransform, (CGFloat) dx, (CGFloat) dy); | |
2146 | } | |
2147 | ||
2148 | void wxMacCoreGraphicsContext::Scale( wxDouble xScale , wxDouble yScale ) | |
2149 | { | |
2150 | if ( m_cgContext ) | |
2151 | CGContextScaleCTM( m_cgContext , (CGFloat) xScale , (CGFloat) yScale ); | |
2152 | else | |
2153 | m_windowTransform = CGAffineTransformScale(m_windowTransform, (CGFloat) xScale, (CGFloat) yScale); | |
2154 | } | |
2155 | ||
2156 | void wxMacCoreGraphicsContext::Rotate( wxDouble angle ) | |
2157 | { | |
2158 | if ( m_cgContext ) | |
2159 | CGContextRotateCTM( m_cgContext , (CGFloat) angle ); | |
2160 | else | |
2161 | m_windowTransform = CGAffineTransformRotate(m_windowTransform, (CGFloat) angle); | |
2162 | } | |
2163 | ||
2164 | void wxMacCoreGraphicsContext::DrawBitmap( const wxBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h ) | |
2165 | { | |
2166 | wxGraphicsBitmap bitmap = GetRenderer()->CreateBitmap(bmp); | |
2167 | DrawBitmap(bitmap, x, y, w, h); | |
2168 | } | |
2169 | ||
2170 | void wxMacCoreGraphicsContext::DrawBitmap( const wxGraphicsBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h ) | |
2171 | { | |
ab451f97 | 2172 | if (!EnsureIsValid()) |
f28b6f06 | 2173 | return; |
bf02a7f9 SC |
2174 | |
2175 | if (m_composition == wxCOMPOSITION_DEST) | |
2176 | return; | |
03647350 | 2177 | |
489468fe SC |
2178 | #ifdef __WXMAC__ |
2179 | wxMacCoreGraphicsBitmapData* refdata =static_cast<wxMacCoreGraphicsBitmapData*>(bmp.GetRefData()); | |
2180 | CGImageRef image = refdata->GetBitmap(); | |
2181 | CGRect r = CGRectMake( (CGFloat) x , (CGFloat) y , (CGFloat) w , (CGFloat) h ); | |
2182 | if ( refdata->IsMonochrome() == 1 ) | |
2183 | { | |
2184 | // is is a mask, the '1' in the mask tell where to draw the current brush | |
2185 | if ( !m_brush.IsNull() ) | |
2186 | { | |
2187 | if ( ((wxMacCoreGraphicsBrushData*)m_brush.GetRefData())->IsShading() ) | |
2188 | { | |
2189 | // TODO clip to mask | |
2190 | /* | |
2191 | CGContextSaveGState( m_cgContext ); | |
2192 | CGContextAddPath( m_cgContext , (CGPathRef) path.GetNativePath() ); | |
2193 | CGContextClip( m_cgContext ); | |
2194 | CGContextDrawShading( m_cgContext, ((wxMacCoreGraphicsBrushData*)m_brush.GetRefData())->GetShading() ); | |
2195 | CGContextRestoreGState( m_cgContext); | |
2196 | */ | |
2197 | } | |
2198 | else | |
2199 | { | |
2200 | ((wxMacCoreGraphicsBrushData*)m_brush.GetRefData())->Apply(this); | |
2201 | wxMacDrawCGImage( m_cgContext , &r , image ); | |
2202 | } | |
2203 | } | |
2204 | } | |
2205 | else | |
2206 | { | |
2207 | wxMacDrawCGImage( m_cgContext , &r , image ); | |
2208 | } | |
2209 | #endif | |
2210 | } | |
2211 | ||
2212 | void wxMacCoreGraphicsContext::DrawIcon( const wxIcon &icon, wxDouble x, wxDouble y, wxDouble w, wxDouble h ) | |
2213 | { | |
ab451f97 | 2214 | if (!EnsureIsValid()) |
f28b6f06 | 2215 | return; |
03647350 | 2216 | |
bf02a7f9 SC |
2217 | if (m_composition == wxCOMPOSITION_DEST) |
2218 | return; | |
2219 | ||
489468fe SC |
2220 | CGRect r = CGRectMake( (CGFloat) 0.0 , (CGFloat) 0.0 , (CGFloat) w , (CGFloat) h ); |
2221 | CGContextSaveGState( m_cgContext ); | |
2222 | CGContextTranslateCTM( m_cgContext,(CGFloat) x ,(CGFloat) (y + h) ); | |
2223 | CGContextScaleCTM( m_cgContext, 1, -1 ); | |
f28b6f06 | 2224 | #if wxOSX_USE_COCOA_OR_CARBON |
489468fe | 2225 | PlotIconRefInContext( m_cgContext , &r , kAlignNone , kTransformNone , |
f28b6f06 | 2226 | NULL , kPlotIconRefNormalFlags , icon.GetHICON() ); |
489468fe SC |
2227 | #endif |
2228 | CGContextRestoreGState( m_cgContext ); | |
2229 | } | |
2230 | ||
2231 | void wxMacCoreGraphicsContext::PushState() | |
2232 | { | |
ab451f97 | 2233 | if (!EnsureIsValid()) |
f28b6f06 | 2234 | return; |
03647350 | 2235 | |
489468fe SC |
2236 | CGContextSaveGState( m_cgContext ); |
2237 | } | |
2238 | ||
2239 | void wxMacCoreGraphicsContext::PopState() | |
2240 | { | |
ab451f97 | 2241 | if (!EnsureIsValid()) |
f28b6f06 | 2242 | return; |
03647350 | 2243 | |
489468fe SC |
2244 | CGContextRestoreGState( m_cgContext ); |
2245 | } | |
2246 | ||
0b7dce54 | 2247 | void wxMacCoreGraphicsContext::DoDrawText( const wxString &str, wxDouble x, wxDouble y ) |
489468fe | 2248 | { |
1011fbeb | 2249 | wxCHECK_RET( !m_font.IsNull(), wxT("wxMacCoreGraphicsContext::DrawText - no valid font set") ); |
489468fe | 2250 | |
ab451f97 | 2251 | if (!EnsureIsValid()) |
f28b6f06 | 2252 | return; |
03647350 | 2253 | |
bf02a7f9 SC |
2254 | if (m_composition == wxCOMPOSITION_DEST) |
2255 | return; | |
2256 | ||
292e5e1f | 2257 | #if wxOSX_USE_CORE_TEXT |
489468fe SC |
2258 | if ( UMAGetSystemVersion() >= 0x1050 ) |
2259 | { | |
2260 | wxMacCoreGraphicsFontData* fref = (wxMacCoreGraphicsFontData*)m_font.GetRefData(); | |
2261 | wxCFStringRef text(str, wxLocale::GetSystemEncoding() ); | |
aa6208d9 | 2262 | CTFontRef font = fref->OSXGetCTFont(); |
489468fe SC |
2263 | CGColorRef col = wxMacCreateCGColor( fref->GetColour() ); |
2264 | CTUnderlineStyle ustyle = fref->GetUnderlined() ? kCTUnderlineStyleSingle : kCTUnderlineStyleNone ; | |
2265 | wxCFRef<CFNumberRef> underlined( CFNumberCreate(NULL, kCFNumberSInt32Type, &ustyle) ); | |
2266 | CFStringRef keys[] = { kCTFontAttributeName , kCTForegroundColorAttributeName, kCTUnderlineStyleAttributeName }; | |
2267 | CFTypeRef values[] = { font, col, underlined }; | |
2268 | wxCFRef<CFDictionaryRef> attributes( CFDictionaryCreate(kCFAllocatorDefault, (const void**) &keys, (const void**) &values, | |
2269 | WXSIZEOF( keys ), &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks) ); | |
2270 | wxCFRef<CFAttributedStringRef> attrtext( CFAttributedStringCreate(kCFAllocatorDefault, text, attributes) ); | |
2271 | wxCFRef<CTLineRef> line( CTLineCreateWithAttributedString(attrtext) ); | |
2272 | ||
2273 | y += CTFontGetAscent(font); | |
2274 | ||
2275 | CGContextSaveGState(m_cgContext); | |
de0d2095 | 2276 | CGContextTranslateCTM(m_cgContext, (CGFloat) x, (CGFloat) y); |
489468fe SC |
2277 | CGContextScaleCTM(m_cgContext, 1, -1); |
2278 | CGContextSetTextPosition(m_cgContext, 0, 0); | |
2279 | CTLineDraw( line, m_cgContext ); | |
2280 | CGContextRestoreGState(m_cgContext); | |
2281 | CFRelease( col ); | |
2282 | return; | |
2283 | } | |
2284 | #endif | |
292e5e1f | 2285 | #if wxOSX_USE_ATSU_TEXT |
489468fe SC |
2286 | { |
2287 | DrawText(str, x, y, 0.0); | |
2288 | return; | |
2289 | } | |
2290 | #endif | |
292e5e1f | 2291 | #if wxOSX_USE_IPHONE |
b2680ced SC |
2292 | wxMacCoreGraphicsFontData* fref = (wxMacCoreGraphicsFontData*)m_font.GetRefData(); |
2293 | ||
2294 | CGContextSaveGState(m_cgContext); | |
2295 | ||
2296 | CGColorRef col = wxMacCreateCGColor( fref->GetColour() ); | |
0b7dce54 | 2297 | CGContextSetTextDrawingMode (m_cgContext, kCGTextFill); |
b2680ced SC |
2298 | CGContextSetFillColorWithColor( m_cgContext, col ); |
2299 | ||
2300 | wxCFStringRef text(str, wxLocale::GetSystemEncoding() ); | |
2301 | DrawTextInContext( m_cgContext, CGPointMake( x, y ), fref->GetUIFont() , text.AsNSString() ); | |
2302 | ||
2303 | CGContextRestoreGState(m_cgContext); | |
2304 | CFRelease( col ); | |
489468fe SC |
2305 | #endif |
2306 | } | |
2307 | ||
0b7dce54 VZ |
2308 | void wxMacCoreGraphicsContext::DoDrawRotatedText(const wxString &str, |
2309 | wxDouble x, wxDouble y, | |
2310 | wxDouble angle) | |
489468fe | 2311 | { |
1011fbeb | 2312 | wxCHECK_RET( !m_font.IsNull(), wxT("wxMacCoreGraphicsContext::DrawText - no valid font set") ); |
489468fe | 2313 | |
ab451f97 | 2314 | if (!EnsureIsValid()) |
f28b6f06 | 2315 | return; |
03647350 | 2316 | |
bf02a7f9 SC |
2317 | if (m_composition == wxCOMPOSITION_DEST) |
2318 | return; | |
2319 | ||
292e5e1f | 2320 | #if wxOSX_USE_CORE_TEXT |
489468fe SC |
2321 | if ( UMAGetSystemVersion() >= 0x1050 ) |
2322 | { | |
2323 | // default implementation takes care of rotation and calls non rotated DrawText afterwards | |
02fd8b9b | 2324 | wxGraphicsContext::DoDrawRotatedText( str, x, y, angle ); |
489468fe SC |
2325 | return; |
2326 | } | |
2327 | #endif | |
292e5e1f | 2328 | #if wxOSX_USE_ATSU_TEXT |
489468fe SC |
2329 | { |
2330 | OSStatus status = noErr; | |
2331 | ATSUTextLayout atsuLayout; | |
2332 | wxMacUniCharBuffer unibuf( str ); | |
2333 | UniCharCount chars = unibuf.GetChars(); | |
2334 | ||
2335 | ATSUStyle style = (((wxMacCoreGraphicsFontData*)m_font.GetRefData())->GetATSUStyle()); | |
2336 | status = ::ATSUCreateTextLayoutWithTextPtr( unibuf.GetBuffer() , 0 , chars , chars , 1 , | |
2337 | &chars , &style , &atsuLayout ); | |
2338 | ||
2339 | wxASSERT_MSG( status == noErr , wxT("couldn't create the layout of the rotated text") ); | |
2340 | ||
2341 | status = ::ATSUSetTransientFontMatching( atsuLayout , true ); | |
2342 | wxASSERT_MSG( status == noErr , wxT("couldn't setup transient font matching") ); | |
2343 | ||
2344 | int iAngle = int( angle * RAD2DEG ); | |
2345 | if ( abs(iAngle) > 0 ) | |
2346 | { | |
2347 | Fixed atsuAngle = IntToFixed( iAngle ); | |
2348 | ATSUAttributeTag atsuTags[] = | |
2349 | { | |
2350 | kATSULineRotationTag , | |
2351 | }; | |
9611b797 | 2352 | ByteCount atsuSizes[WXSIZEOF(atsuTags)] = |
489468fe SC |
2353 | { |
2354 | sizeof( Fixed ) , | |
2355 | }; | |
9611b797 | 2356 | ATSUAttributeValuePtr atsuValues[WXSIZEOF(atsuTags)] = |
489468fe SC |
2357 | { |
2358 | &atsuAngle , | |
2359 | }; | |
9611b797 | 2360 | status = ::ATSUSetLayoutControls(atsuLayout , WXSIZEOF(atsuTags), |
489468fe SC |
2361 | atsuTags, atsuSizes, atsuValues ); |
2362 | } | |
2363 | ||
2364 | { | |
2365 | ATSUAttributeTag atsuTags[] = | |
2366 | { | |
2367 | kATSUCGContextTag , | |
2368 | }; | |
9611b797 | 2369 | ByteCount atsuSizes[WXSIZEOF(atsuTags)] = |
489468fe SC |
2370 | { |
2371 | sizeof( CGContextRef ) , | |
2372 | }; | |
9611b797 | 2373 | ATSUAttributeValuePtr atsuValues[WXSIZEOF(atsuTags)] = |
489468fe SC |
2374 | { |
2375 | &m_cgContext , | |
2376 | }; | |
9611b797 | 2377 | status = ::ATSUSetLayoutControls(atsuLayout , WXSIZEOF(atsuTags), |
489468fe SC |
2378 | atsuTags, atsuSizes, atsuValues ); |
2379 | } | |
2380 | ||
2381 | ATSUTextMeasurement textBefore, textAfter; | |
2382 | ATSUTextMeasurement ascent, descent; | |
2383 | ||
2384 | status = ::ATSUGetUnjustifiedBounds( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd, | |
2385 | &textBefore , &textAfter, &ascent , &descent ); | |
2386 | ||
2387 | wxASSERT_MSG( status == noErr , wxT("couldn't measure the rotated text") ); | |
2388 | ||
2389 | Rect rect; | |
2390 | x += (int)(sin(angle) * FixedToInt(ascent)); | |
2391 | y += (int)(cos(angle) * FixedToInt(ascent)); | |
2392 | ||
2393 | status = ::ATSUMeasureTextImage( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd, | |
2394 | IntToFixed(x) , IntToFixed(y) , &rect ); | |
2395 | wxASSERT_MSG( status == noErr , wxT("couldn't measure the rotated text") ); | |
2396 | ||
2397 | CGContextSaveGState(m_cgContext); | |
2398 | CGContextTranslateCTM(m_cgContext, (CGFloat) x, (CGFloat) y); | |
2399 | CGContextScaleCTM(m_cgContext, 1, -1); | |
2400 | status = ::ATSUDrawText( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd, | |
2401 | IntToFixed(0) , IntToFixed(0) ); | |
2402 | ||
2403 | wxASSERT_MSG( status == noErr , wxT("couldn't draw the rotated text") ); | |
2404 | ||
2405 | CGContextRestoreGState(m_cgContext); | |
2406 | ||
2407 | ::ATSUDisposeTextLayout(atsuLayout); | |
2408 | ||
2409 | return; | |
2410 | } | |
2411 | #endif | |
292e5e1f | 2412 | #if wxOSX_USE_IPHONE |
489468fe | 2413 | // default implementation takes care of rotation and calls non rotated DrawText afterwards |
0b7dce54 | 2414 | wxGraphicsContext::DoDrawRotatedText( str, x, y, angle ); |
489468fe SC |
2415 | #endif |
2416 | } | |
2417 | ||
2418 | void wxMacCoreGraphicsContext::GetTextExtent( const wxString &str, wxDouble *width, wxDouble *height, | |
2419 | wxDouble *descent, wxDouble *externalLeading ) const | |
2420 | { | |
1011fbeb | 2421 | wxCHECK_RET( !m_font.IsNull(), wxT("wxMacCoreGraphicsContext::GetTextExtent - no valid font set") ); |
489468fe SC |
2422 | |
2423 | if ( width ) | |
2424 | *width = 0; | |
2425 | if ( height ) | |
2426 | *height = 0; | |
2427 | if ( descent ) | |
2428 | *descent = 0; | |
2429 | if ( externalLeading ) | |
2430 | *externalLeading = 0; | |
2431 | ||
2432 | if (str.empty()) | |
2433 | return; | |
2434 | ||
292e5e1f | 2435 | #if wxOSX_USE_CORE_TEXT |
489468fe SC |
2436 | if ( UMAGetSystemVersion() >= 0x1050 ) |
2437 | { | |
2438 | wxMacCoreGraphicsFontData* fref = (wxMacCoreGraphicsFontData*)m_font.GetRefData(); | |
aa6208d9 | 2439 | CTFontRef font = fref->OSXGetCTFont(); |
489468fe SC |
2440 | |
2441 | wxCFStringRef text(str, wxLocale::GetSystemEncoding() ); | |
2442 | CFStringRef keys[] = { kCTFontAttributeName }; | |
2443 | CFTypeRef values[] = { font }; | |
2444 | wxCFRef<CFDictionaryRef> attributes( CFDictionaryCreate(kCFAllocatorDefault, (const void**) &keys, (const void**) &values, | |
2445 | WXSIZEOF( keys ), &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks) ); | |
2446 | wxCFRef<CFAttributedStringRef> attrtext( CFAttributedStringCreate(kCFAllocatorDefault, text, attributes) ); | |
2447 | wxCFRef<CTLineRef> line( CTLineCreateWithAttributedString(attrtext) ); | |
2448 | ||
0738b901 VZ |
2449 | // round the returned extent: this is probably more correct anyhow but |
2450 | // we also need to do it to be consistent with GetPartialTextExtents() | |
2451 | // below and avoid strange situation when the last partial extent | |
2452 | // returned by it could have been greater than the full extent returned | |
2453 | // by us | |
de0d2095 | 2454 | CGFloat a, d, l; |
0738b901 | 2455 | int w = CTLineGetTypographicBounds(line, &a, &d, &l) + 0.5; |
489468fe SC |
2456 | |
2457 | if ( height ) | |
2458 | *height = a+d+l; | |
2459 | if ( descent ) | |
2460 | *descent = d; | |
2461 | if ( externalLeading ) | |
2462 | *externalLeading = l; | |
2463 | if ( width ) | |
2464 | *width = w; | |
2465 | return; | |
2466 | } | |
2467 | #endif | |
292e5e1f | 2468 | #if wxOSX_USE_ATSU_TEXT |
489468fe SC |
2469 | { |
2470 | OSStatus status = noErr; | |
2471 | ||
2472 | ATSUTextLayout atsuLayout; | |
2473 | wxMacUniCharBuffer unibuf( str ); | |
2474 | UniCharCount chars = unibuf.GetChars(); | |
2475 | ||
2476 | ATSUStyle style = (((wxMacCoreGraphicsFontData*)m_font.GetRefData())->GetATSUStyle()); | |
2477 | status = ::ATSUCreateTextLayoutWithTextPtr( unibuf.GetBuffer() , 0 , chars , chars , 1 , | |
2478 | &chars , &style , &atsuLayout ); | |
2479 | ||
2480 | wxASSERT_MSG( status == noErr , wxT("couldn't create the layout of the text") ); | |
2481 | ||
2482 | status = ::ATSUSetTransientFontMatching( atsuLayout , true ); | |
2483 | wxASSERT_MSG( status == noErr , wxT("couldn't setup transient font matching") ); | |
2484 | ||
2485 | ATSUTextMeasurement textBefore, textAfter; | |
2486 | ATSUTextMeasurement textAscent, textDescent; | |
2487 | ||
2488 | status = ::ATSUGetUnjustifiedBounds( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd, | |
2489 | &textBefore , &textAfter, &textAscent , &textDescent ); | |
2490 | ||
2491 | if ( height ) | |
2492 | *height = FixedToInt(textAscent + textDescent); | |
2493 | if ( descent ) | |
2494 | *descent = FixedToInt(textDescent); | |
2495 | if ( externalLeading ) | |
2496 | *externalLeading = 0; | |
2497 | if ( width ) | |
2498 | *width = FixedToInt(textAfter - textBefore); | |
2499 | ||
2500 | ::ATSUDisposeTextLayout(atsuLayout); | |
2501 | ||
2502 | return; | |
2503 | } | |
2504 | #endif | |
292e5e1f | 2505 | #if wxOSX_USE_IPHONE |
b2680ced SC |
2506 | wxMacCoreGraphicsFontData* fref = (wxMacCoreGraphicsFontData*)m_font.GetRefData(); |
2507 | ||
2508 | wxCFStringRef text(str, wxLocale::GetSystemEncoding() ); | |
2509 | CGSize sz = MeasureTextInContext( fref->GetUIFont() , text.AsNSString() ); | |
0b7dce54 | 2510 | |
b2680ced SC |
2511 | if ( height ) |
2512 | *height = sz.height; | |
2513 | /* | |
2514 | if ( descent ) | |
2515 | *descent = FixedToInt(textDescent); | |
2516 | if ( externalLeading ) | |
2517 | *externalLeading = 0; | |
2518 | */ | |
2519 | if ( width ) | |
2520 | *width = sz.width; | |
489468fe SC |
2521 | #endif |
2522 | } | |
2523 | ||
2524 | void wxMacCoreGraphicsContext::GetPartialTextExtents(const wxString& text, wxArrayDouble& widths) const | |
2525 | { | |
2526 | widths.Empty(); | |
2527 | widths.Add(0, text.length()); | |
2528 | ||
1011fbeb SC |
2529 | wxCHECK_RET( !m_font.IsNull(), wxT("wxMacCoreGraphicsContext::DrawText - no valid font set") ); |
2530 | ||
489468fe SC |
2531 | if (text.empty()) |
2532 | return; | |
2533 | ||
292e5e1f | 2534 | #if wxOSX_USE_CORE_TEXT |
489468fe SC |
2535 | { |
2536 | wxMacCoreGraphicsFontData* fref = (wxMacCoreGraphicsFontData*)m_font.GetRefData(); | |
aa6208d9 | 2537 | CTFontRef font = fref->OSXGetCTFont(); |
489468fe SC |
2538 | |
2539 | wxCFStringRef t(text, wxLocale::GetSystemEncoding() ); | |
2540 | CFStringRef keys[] = { kCTFontAttributeName }; | |
2541 | CFTypeRef values[] = { font }; | |
2542 | wxCFRef<CFDictionaryRef> attributes( CFDictionaryCreate(kCFAllocatorDefault, (const void**) &keys, (const void**) &values, | |
2543 | WXSIZEOF( keys ), &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks) ); | |
2544 | wxCFRef<CFAttributedStringRef> attrtext( CFAttributedStringCreate(kCFAllocatorDefault, t, attributes) ); | |
2545 | wxCFRef<CTLineRef> line( CTLineCreateWithAttributedString(attrtext) ); | |
2546 | ||
2547 | int chars = text.length(); | |
2548 | for ( int pos = 0; pos < (int)chars; pos ++ ) | |
2549 | { | |
0738b901 | 2550 | widths[pos] = CTLineGetOffsetForStringIndex( line, pos+1 , NULL ); |
489468fe SC |
2551 | } |
2552 | ||
2553 | return; | |
2554 | } | |
2555 | #endif | |
292e5e1f | 2556 | #if wxOSX_USE_ATSU_TEXT |
489468fe SC |
2557 | { |
2558 | OSStatus status = noErr; | |
2559 | ATSUTextLayout atsuLayout; | |
2560 | wxMacUniCharBuffer unibuf( text ); | |
2561 | UniCharCount chars = unibuf.GetChars(); | |
2562 | ||
2563 | ATSUStyle style = (((wxMacCoreGraphicsFontData*)m_font.GetRefData())->GetATSUStyle()); | |
2564 | status = ::ATSUCreateTextLayoutWithTextPtr( unibuf.GetBuffer() , 0 , chars , chars , 1 , | |
2565 | &chars , &style , &atsuLayout ); | |
2566 | ||
2567 | wxASSERT_MSG( status == noErr , wxT("couldn't create the layout of the text") ); | |
2568 | ||
2569 | status = ::ATSUSetTransientFontMatching( atsuLayout , true ); | |
2570 | wxASSERT_MSG( status == noErr , wxT("couldn't setup transient font matching") ); | |
2571 | ||
2572 | // new implementation from JS, keep old one just in case | |
2573 | #if 0 | |
2574 | for ( int pos = 0; pos < (int)chars; pos ++ ) | |
2575 | { | |
2576 | unsigned long actualNumberOfBounds = 0; | |
2577 | ATSTrapezoid glyphBounds; | |
2578 | ||
2579 | // We get a single bound, since the text should only require one. If it requires more, there is an issue | |
2580 | OSStatus result; | |
2581 | result = ATSUGetGlyphBounds( atsuLayout, 0, 0, kATSUFromTextBeginning, pos + 1, | |
2582 | kATSUseDeviceOrigins, 1, &glyphBounds, &actualNumberOfBounds ); | |
2583 | if (result != noErr || actualNumberOfBounds != 1 ) | |
2584 | return; | |
2585 | ||
2586 | widths[pos] = FixedToInt( glyphBounds.upperRight.x - glyphBounds.upperLeft.x ); | |
2587 | //unsigned char uch = s[i]; | |
2588 | } | |
2589 | #else | |
2590 | ATSLayoutRecord *layoutRecords = NULL; | |
2591 | ItemCount glyphCount = 0; | |
0b7dce54 | 2592 | |
489468fe SC |
2593 | // Get the glyph extents |
2594 | OSStatus err = ::ATSUDirectGetLayoutDataArrayPtrFromTextLayout(atsuLayout, | |
2595 | 0, | |
2596 | kATSUDirectDataLayoutRecordATSLayoutRecordCurrent, | |
2597 | (void **) | |
2598 | &layoutRecords, | |
2599 | &glyphCount); | |
2600 | wxASSERT(glyphCount == (text.length()+1)); | |
0b7dce54 | 2601 | |
489468fe SC |
2602 | if ( err == noErr && glyphCount == (text.length()+1)) |
2603 | { | |
2604 | for ( int pos = 1; pos < (int)glyphCount ; pos ++ ) | |
2605 | { | |
2606 | widths[pos-1] = FixedToInt( layoutRecords[pos].realPos ); | |
2607 | } | |
2608 | } | |
0b7dce54 | 2609 | |
489468fe SC |
2610 | ::ATSUDirectReleaseLayoutDataArrayPtr(NULL, |
2611 | kATSUDirectDataLayoutRecordATSLayoutRecordCurrent, | |
2612 | (void **) &layoutRecords); | |
2613 | #endif | |
2614 | ::ATSUDisposeTextLayout(atsuLayout); | |
2615 | } | |
2616 | #endif | |
292e5e1f | 2617 | #if wxOSX_USE_IPHONE |
489468fe SC |
2618 | // TODO core graphics text implementation here |
2619 | #endif | |
2620 | } | |
2621 | ||
2622 | void * wxMacCoreGraphicsContext::GetNativeContext() | |
2623 | { | |
2624 | return m_cgContext; | |
2625 | } | |
2626 | ||
2627 | // concatenates this transform with the current transform of this context | |
2628 | void wxMacCoreGraphicsContext::ConcatTransform( const wxGraphicsMatrix& matrix ) | |
2629 | { | |
2630 | if ( m_cgContext ) | |
2631 | CGContextConcatCTM( m_cgContext, *(CGAffineTransform*) matrix.GetNativeMatrix()); | |
2632 | else | |
2633 | m_windowTransform = CGAffineTransformConcat(m_windowTransform, *(CGAffineTransform*) matrix.GetNativeMatrix()); | |
2634 | } | |
2635 | ||
2636 | // sets the transform of this context | |
2637 | void wxMacCoreGraphicsContext::SetTransform( const wxGraphicsMatrix& matrix ) | |
2638 | { | |
2639 | if ( m_cgContext ) | |
2640 | { | |
2641 | CGAffineTransform transform = CGContextGetCTM( m_cgContext ); | |
2642 | transform = CGAffineTransformInvert( transform ) ; | |
2643 | CGContextConcatCTM( m_cgContext, transform); | |
2644 | CGContextConcatCTM( m_cgContext, *(CGAffineTransform*) matrix.GetNativeMatrix()); | |
2645 | } | |
2646 | else | |
2647 | { | |
2648 | m_windowTransform = *(CGAffineTransform*) matrix.GetNativeMatrix(); | |
2649 | } | |
2650 | } | |
2651 | ||
2652 | // gets the matrix of this context | |
2653 | wxGraphicsMatrix wxMacCoreGraphicsContext::GetTransform() const | |
2654 | { | |
2655 | wxGraphicsMatrix m = CreateMatrix(); | |
2656 | *((CGAffineTransform*) m.GetNativeMatrix()) = ( m_cgContext == NULL ? m_windowTransform : | |
2657 | CGContextGetCTM( m_cgContext )); | |
2658 | return m; | |
2659 | } | |
2660 | ||
2661 | // | |
2662 | // Renderer | |
2663 | // | |
2664 | ||
2665 | //----------------------------------------------------------------------------- | |
2666 | // wxMacCoreGraphicsRenderer declaration | |
2667 | //----------------------------------------------------------------------------- | |
2668 | ||
2669 | class WXDLLIMPEXP_CORE wxMacCoreGraphicsRenderer : public wxGraphicsRenderer | |
2670 | { | |
2671 | public : | |
2672 | wxMacCoreGraphicsRenderer() {} | |
2673 | ||
2674 | virtual ~wxMacCoreGraphicsRenderer() {} | |
2675 | ||
2676 | // Context | |
2677 | ||
2678 | virtual wxGraphicsContext * CreateContext( const wxWindowDC& dc); | |
2679 | virtual wxGraphicsContext * CreateContext( const wxMemoryDC& dc); | |
9535b479 | 2680 | #if wxUSE_PRINTING_ARCHITECTURE |
489468fe | 2681 | virtual wxGraphicsContext * CreateContext( const wxPrinterDC& dc); |
9535b479 | 2682 | #endif |
489468fe SC |
2683 | |
2684 | virtual wxGraphicsContext * CreateContextFromNativeContext( void * context ); | |
2685 | ||
2686 | virtual wxGraphicsContext * CreateContextFromNativeWindow( void * window ); | |
2687 | ||
2688 | virtual wxGraphicsContext * CreateContext( wxWindow* window ); | |
2689 | ||
2690 | virtual wxGraphicsContext * CreateMeasuringContext(); | |
2691 | ||
2692 | // Path | |
2693 | ||
2694 | virtual wxGraphicsPath CreatePath(); | |
2695 | ||
2696 | // Matrix | |
2697 | ||
2698 | virtual wxGraphicsMatrix CreateMatrix( wxDouble a=1.0, wxDouble b=0.0, wxDouble c=0.0, wxDouble d=1.0, | |
2699 | wxDouble tx=0.0, wxDouble ty=0.0); | |
2700 | ||
2701 | ||
2702 | virtual wxGraphicsPen CreatePen(const wxPen& pen) ; | |
2703 | ||
2704 | virtual wxGraphicsBrush CreateBrush(const wxBrush& brush ) ; | |
2705 | ||
4ee4c7b9 VZ |
2706 | virtual wxGraphicsBrush |
2707 | CreateLinearGradientBrush(wxDouble x1, wxDouble y1, | |
2708 | wxDouble x2, wxDouble y2, | |
2709 | const wxGraphicsGradientStops& stops); | |
489468fe | 2710 | |
4ee4c7b9 VZ |
2711 | virtual wxGraphicsBrush |
2712 | CreateRadialGradientBrush(wxDouble xo, wxDouble yo, | |
2713 | wxDouble xc, wxDouble yc, | |
2714 | wxDouble radius, | |
2715 | const wxGraphicsGradientStops& stops); | |
489468fe SC |
2716 | |
2717 | // sets the font | |
2718 | virtual wxGraphicsFont CreateFont( const wxFont &font , const wxColour &col = *wxBLACK ) ; | |
2719 | ||
2720 | // create a native bitmap representation | |
2721 | virtual wxGraphicsBitmap CreateBitmap( const wxBitmap &bitmap ) ; | |
2722 | ||
2986eb86 SC |
2723 | // create a graphics bitmap from a native bitmap |
2724 | virtual wxGraphicsBitmap CreateBitmapFromNativeBitmap( void* bitmap ); | |
2725 | ||
489468fe SC |
2726 | // create a native bitmap representation |
2727 | virtual wxGraphicsBitmap CreateSubBitmap( const wxGraphicsBitmap &bitmap, wxDouble x, wxDouble y, wxDouble w, wxDouble h ) ; | |
2728 | private : | |
2729 | DECLARE_DYNAMIC_CLASS_NO_COPY(wxMacCoreGraphicsRenderer) | |
2730 | } ; | |
2731 | ||
2732 | //----------------------------------------------------------------------------- | |
2733 | // wxMacCoreGraphicsRenderer implementation | |
2734 | //----------------------------------------------------------------------------- | |
2735 | ||
2736 | IMPLEMENT_DYNAMIC_CLASS(wxMacCoreGraphicsRenderer,wxGraphicsRenderer) | |
2737 | ||
2738 | static wxMacCoreGraphicsRenderer gs_MacCoreGraphicsRenderer; | |
2739 | ||
2740 | wxGraphicsRenderer* wxGraphicsRenderer::GetDefaultRenderer() | |
2741 | { | |
2742 | return &gs_MacCoreGraphicsRenderer; | |
2743 | } | |
2744 | ||
489468fe SC |
2745 | wxGraphicsContext * wxMacCoreGraphicsRenderer::CreateContext( const wxWindowDC& dc ) |
2746 | { | |
2747 | const wxDCImpl* impl = dc.GetImpl(); | |
2748 | wxWindowDCImpl *win_impl = wxDynamicCast( impl, wxWindowDCImpl ); | |
2749 | if (win_impl) | |
2750 | { | |
2751 | int w, h; | |
2752 | win_impl->GetSize( &w, &h ); | |
2753 | CGContextRef cgctx = 0; | |
15fc716c | 2754 | |
0600cf3a KO |
2755 | wxASSERT_MSG(win_impl->GetWindow(), "Invalid wxWindow in wxMacCoreGraphicsRenderer::CreateContext"); |
2756 | if (win_impl->GetWindow()) | |
2757 | cgctx = (CGContextRef)(win_impl->GetWindow()->MacGetCGContextRef()); | |
15fc716c | 2758 | |
0600cf3a KO |
2759 | if (cgctx != 0) |
2760 | return new wxMacCoreGraphicsContext( this, cgctx, (wxDouble) w, (wxDouble) h ); | |
489468fe SC |
2761 | } |
2762 | return NULL; | |
2763 | } | |
2764 | ||
2765 | wxGraphicsContext * wxMacCoreGraphicsRenderer::CreateContext( const wxMemoryDC& dc ) | |
2766 | { | |
2767 | #ifdef __WXMAC__ | |
2768 | const wxDCImpl* impl = dc.GetImpl(); | |
2769 | wxMemoryDCImpl *mem_impl = wxDynamicCast( impl, wxMemoryDCImpl ); | |
2770 | if (mem_impl) | |
2771 | { | |
2772 | int w, h; | |
2773 | mem_impl->GetSize( &w, &h ); | |
2774 | return new wxMacCoreGraphicsContext( this, | |
2775 | (CGContextRef)(mem_impl->GetGraphicsContext()->GetNativeContext()), (wxDouble) w, (wxDouble) h ); | |
2776 | } | |
2777 | #endif | |
2778 | return NULL; | |
2779 | } | |
2780 | ||
9535b479 | 2781 | #if wxUSE_PRINTING_ARCHITECTURE |
489468fe SC |
2782 | wxGraphicsContext * wxMacCoreGraphicsRenderer::CreateContext( const wxPrinterDC& dc ) |
2783 | { | |
2784 | #ifdef __WXMAC__ | |
2785 | const wxDCImpl* impl = dc.GetImpl(); | |
2786 | wxPrinterDCImpl *print_impl = wxDynamicCast( impl, wxPrinterDCImpl ); | |
2787 | if (print_impl) | |
2788 | { | |
2789 | int w, h; | |
2790 | print_impl->GetSize( &w, &h ); | |
2791 | return new wxMacCoreGraphicsContext( this, | |
2792 | (CGContextRef)(print_impl->GetGraphicsContext()->GetNativeContext()), (wxDouble) w, (wxDouble) h ); | |
2793 | } | |
2794 | #endif | |
2795 | return NULL; | |
2796 | } | |
9535b479 | 2797 | #endif |
489468fe SC |
2798 | |
2799 | wxGraphicsContext * wxMacCoreGraphicsRenderer::CreateContextFromNativeContext( void * context ) | |
2800 | { | |
2801 | return new wxMacCoreGraphicsContext(this,(CGContextRef)context); | |
2802 | } | |
2803 | ||
489468fe SC |
2804 | wxGraphicsContext * wxMacCoreGraphicsRenderer::CreateContextFromNativeWindow( void * window ) |
2805 | { | |
b2680ced | 2806 | #if wxOSX_USE_CARBON |
489468fe | 2807 | return new wxMacCoreGraphicsContext(this,(WindowRef)window); |
b2680ced | 2808 | #else |
de0d2095 | 2809 | wxUnusedVar(window); |
b2680ced SC |
2810 | return NULL; |
2811 | #endif | |
489468fe SC |
2812 | } |
2813 | ||
2814 | wxGraphicsContext * wxMacCoreGraphicsRenderer::CreateContext( wxWindow* window ) | |
2815 | { | |
2816 | return new wxMacCoreGraphicsContext(this, window ); | |
2817 | } | |
2818 | ||
2819 | wxGraphicsContext * wxMacCoreGraphicsRenderer::CreateMeasuringContext() | |
2820 | { | |
2821 | return new wxMacCoreGraphicsContext(this); | |
2822 | } | |
2823 | ||
2824 | // Path | |
2825 | ||
2826 | wxGraphicsPath wxMacCoreGraphicsRenderer::CreatePath() | |
2827 | { | |
2828 | wxGraphicsPath m; | |
2829 | m.SetRefData( new wxMacCoreGraphicsPathData(this)); | |
2830 | return m; | |
2831 | } | |
2832 | ||
2833 | ||
2834 | // Matrix | |
2835 | ||
2836 | wxGraphicsMatrix wxMacCoreGraphicsRenderer::CreateMatrix( wxDouble a, wxDouble b, wxDouble c, wxDouble d, | |
2837 | wxDouble tx, wxDouble ty) | |
2838 | { | |
2839 | wxGraphicsMatrix m; | |
2840 | wxMacCoreGraphicsMatrixData* data = new wxMacCoreGraphicsMatrixData( this ); | |
2841 | data->Set( a,b,c,d,tx,ty ) ; | |
2842 | m.SetRefData(data); | |
2843 | return m; | |
2844 | } | |
2845 | ||
2846 | wxGraphicsPen wxMacCoreGraphicsRenderer::CreatePen(const wxPen& pen) | |
2847 | { | |
2848 | if ( !pen.Ok() || pen.GetStyle() == wxTRANSPARENT ) | |
2849 | return wxNullGraphicsPen; | |
2850 | else | |
2851 | { | |
2852 | wxGraphicsPen p; | |
2853 | p.SetRefData(new wxMacCoreGraphicsPenData( this, pen )); | |
2854 | return p; | |
2855 | } | |
2856 | } | |
2857 | ||
2858 | wxGraphicsBrush wxMacCoreGraphicsRenderer::CreateBrush(const wxBrush& brush ) | |
2859 | { | |
2860 | if ( !brush.Ok() || brush.GetStyle() == wxTRANSPARENT ) | |
2861 | return wxNullGraphicsBrush; | |
2862 | else | |
2863 | { | |
2864 | wxGraphicsBrush p; | |
2865 | p.SetRefData(new wxMacCoreGraphicsBrushData( this, brush )); | |
2866 | return p; | |
2867 | } | |
2868 | } | |
2869 | ||
2870 | wxGraphicsBitmap wxMacCoreGraphicsRenderer::CreateBitmap( const wxBitmap& bmp ) | |
2871 | { | |
2872 | if ( bmp.Ok() ) | |
2873 | { | |
2874 | wxGraphicsBitmap p; | |
489468fe | 2875 | p.SetRefData(new wxMacCoreGraphicsBitmapData( this , bmp.CreateCGImage(), bmp.GetDepth() == 1 ) ); |
2986eb86 SC |
2876 | return p; |
2877 | } | |
2878 | else | |
2879 | return wxNullGraphicsBitmap; | |
2880 | } | |
2881 | ||
2882 | wxGraphicsBitmap wxMacCoreGraphicsRenderer::CreateBitmapFromNativeBitmap( void* bitmap ) | |
2883 | { | |
2884 | if ( bitmap != NULL ) | |
2885 | { | |
2886 | wxGraphicsBitmap p; | |
2887 | p.SetRefData(new wxMacCoreGraphicsBitmapData( this , (CGImageRef) bitmap, false )); | |
489468fe SC |
2888 | return p; |
2889 | } | |
2890 | else | |
2891 | return wxNullGraphicsBitmap; | |
2892 | } | |
2893 | ||
2894 | wxGraphicsBitmap wxMacCoreGraphicsRenderer::CreateSubBitmap( const wxGraphicsBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h ) | |
2895 | { | |
2896 | wxMacCoreGraphicsBitmapData* refdata =static_cast<wxMacCoreGraphicsBitmapData*>(bmp.GetRefData()); | |
2897 | CGImageRef img = refdata->GetBitmap(); | |
2898 | if ( img ) | |
2899 | { | |
2900 | wxGraphicsBitmap p; | |
2901 | CGImageRef subimg = CGImageCreateWithImageInRect(img,CGRectMake( (CGFloat) x , (CGFloat) y , (CGFloat) w , (CGFloat) h )); | |
2902 | p.SetRefData(new wxMacCoreGraphicsBitmapData( this , subimg, refdata->IsMonochrome() ) ); | |
2903 | return p; | |
2904 | } | |
2905 | else | |
2906 | return wxNullGraphicsBitmap; | |
2907 | } | |
2908 | ||
4ee4c7b9 VZ |
2909 | wxGraphicsBrush |
2910 | wxMacCoreGraphicsRenderer::CreateLinearGradientBrush(wxDouble x1, wxDouble y1, | |
2911 | wxDouble x2, wxDouble y2, | |
2912 | const wxGraphicsGradientStops& stops) | |
489468fe SC |
2913 | { |
2914 | wxGraphicsBrush p; | |
2915 | wxMacCoreGraphicsBrushData* d = new wxMacCoreGraphicsBrushData( this ); | |
4ee4c7b9 | 2916 | d->CreateLinearGradientBrush(x1, y1, x2, y2, stops); |
489468fe SC |
2917 | p.SetRefData(d); |
2918 | return p; | |
2919 | } | |
2920 | ||
4ee4c7b9 VZ |
2921 | wxGraphicsBrush |
2922 | wxMacCoreGraphicsRenderer::CreateRadialGradientBrush(wxDouble xo, wxDouble yo, | |
2923 | wxDouble xc, wxDouble yc, | |
2924 | wxDouble radius, | |
2925 | const wxGraphicsGradientStops& stops) | |
489468fe SC |
2926 | { |
2927 | wxGraphicsBrush p; | |
2928 | wxMacCoreGraphicsBrushData* d = new wxMacCoreGraphicsBrushData( this ); | |
4ee4c7b9 | 2929 | d->CreateRadialGradientBrush(xo, yo, xc, yc, radius, stops); |
489468fe SC |
2930 | p.SetRefData(d); |
2931 | return p; | |
2932 | } | |
2933 | ||
2934 | // sets the font | |
2935 | wxGraphicsFont wxMacCoreGraphicsRenderer::CreateFont( const wxFont &font , const wxColour &col ) | |
2936 | { | |
2937 | if ( font.Ok() ) | |
2938 | { | |
2939 | wxGraphicsFont p; | |
2940 | p.SetRefData(new wxMacCoreGraphicsFontData( this , font, col )); | |
2941 | return p; | |
2942 | } | |
2943 | else | |
2944 | return wxNullGraphicsFont; | |
2945 | } | |
2946 | ||
2947 | // | |
2948 | // CoreGraphics Helper Methods | |
2949 | // | |
2950 | ||
2951 | // Data Providers and Consumers | |
2952 | ||
2953 | size_t UMAPutBytesCFRefCallback( void *info, const void *bytes, size_t count ) | |
2954 | { | |
2955 | CFMutableDataRef data = (CFMutableDataRef) info; | |
2956 | if ( data ) | |
2957 | { | |
2958 | CFDataAppendBytes( data, (const UInt8*) bytes, count ); | |
2959 | } | |
2960 | return count; | |
2961 | } | |
2962 | ||
2963 | void wxMacReleaseCFDataProviderCallback(void *info, | |
2964 | const void *WXUNUSED(data), | |
2965 | size_t WXUNUSED(count)) | |
2966 | { | |
2967 | if ( info ) | |
2968 | CFRelease( (CFDataRef) info ); | |
2969 | } | |
2970 | ||
2971 | void wxMacReleaseCFDataConsumerCallback( void *info ) | |
2972 | { | |
2973 | if ( info ) | |
2974 | CFRelease( (CFDataRef) info ); | |
2975 | } | |
2976 | ||
2977 | CGDataProviderRef wxMacCGDataProviderCreateWithCFData( CFDataRef data ) | |
2978 | { | |
2979 | if ( data == NULL ) | |
2980 | return NULL; | |
2981 | ||
2982 | return CGDataProviderCreateWithCFData( data ); | |
2983 | } | |
2984 | ||
2985 | CGDataConsumerRef wxMacCGDataConsumerCreateWithCFData( CFMutableDataRef data ) | |
2986 | { | |
2987 | if ( data == NULL ) | |
2988 | return NULL; | |
2989 | ||
2990 | return CGDataConsumerCreateWithCFData( data ); | |
2991 | } | |
2992 | ||
2993 | void | |
2994 | wxMacReleaseMemoryBufferProviderCallback(void *info, | |
2995 | const void * WXUNUSED_UNLESS_DEBUG(data), | |
2996 | size_t WXUNUSED(size)) | |
2997 | { | |
2998 | wxMemoryBuffer* membuf = (wxMemoryBuffer*) info ; | |
2999 | ||
3000 | wxASSERT( data == membuf->GetData() ) ; | |
3001 | ||
3002 | delete membuf ; | |
3003 | } | |
3004 | ||
3005 | CGDataProviderRef wxMacCGDataProviderCreateWithMemoryBuffer( const wxMemoryBuffer& buf ) | |
3006 | { | |
3007 | wxMemoryBuffer* b = new wxMemoryBuffer( buf ); | |
3008 | if ( b->GetDataLen() == 0 ) | |
3009 | return NULL; | |
3010 | ||
3011 | return CGDataProviderCreateWithData( b , (const void *) b->GetData() , b->GetDataLen() , | |
3012 | wxMacReleaseMemoryBufferProviderCallback ); | |
3013 | } |