1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/osx/carbon/graphics.cpp
4 // Author: Stefan Csomor
8 // copyright: (c) Stefan Csomor
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 #include "wx/wxprec.h"
14 #include "wx/graphics.h"
15 #include "wx/private/graphics.h"
18 #include "wx/dcclient.h"
19 #include "wx/dcmemory.h"
20 #include "wx/dcprint.h"
22 #include "wx/region.h"
31 // in case our functions were defined outside std, we make it known all the same
38 #include "wx/osx/private.h"
39 #include "wx/osx/dcprint.h"
40 #include "wx/osx/dcclient.h"
41 #include "wx/osx/dcmemory.h"
42 #include "wx/osx/private.h"
44 #include "CoreServices/CoreServices.h"
45 #include "ApplicationServices/ApplicationServices.h"
46 #include "wx/osx/core/cfstring.h"
47 #include "wx/cocoa/dcclient.h"
52 CGColorSpaceRef
wxMacGetGenericRGBColorSpace()
54 static wxCFRef
<CGColorSpaceRef
> genericRGBColorSpace
;
56 if (genericRGBColorSpace
== NULL
)
58 genericRGBColorSpace
.reset( CGColorSpaceCreateWithName( kCGColorSpaceGenericRGB
) );
61 return genericRGBColorSpace
;
64 int UMAGetSystemVersion()
70 #define wxOSX_USE_CORE_TEXT 1
74 #if wxOSX_USE_COCOA_OR_IPHONE
75 extern CGContextRef
wxOSXGetContextFromCurrentContext() ;
77 extern bool wxOSXLockFocus( WXWidget view
) ;
78 extern void wxOSXUnlockFocus( WXWidget view
) ;
82 #if 1 // MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5
84 // TODO test whether this private API also works under 10.3
86 // copying values from NSCompositingModes (see also webkit and cairo sources)
88 typedef enum CGCompositeOperation
{
89 kCGCompositeOperationClear
= 0,
90 kCGCompositeOperationCopy
= 1,
91 kCGCompositeOperationSourceOver
= 2,
92 kCGCompositeOperationSourceIn
= 3,
93 kCGCompositeOperationSourceOut
= 4,
94 kCGCompositeOperationSourceAtop
= 5,
95 kCGCompositeOperationDestinationOver
= 6,
96 kCGCompositeOperationDestinationIn
= 7,
97 kCGCompositeOperationDestinationOut
= 8,
98 kCGCompositeOperationDestinationAtop
= 9,
99 kCGCompositeOperationXOR
= 10,
100 kCGCompositeOperationPlusDarker
= 11,
101 // NS only, unsupported by CG : Highlight
102 kCGCompositeOperationPlusLighter
= 12
103 } CGCompositeOperation
;
107 CG_EXTERN
void CGContextSetCompositeOperation (CGContextRef context
, int operation
);
112 //-----------------------------------------------------------------------------
114 //-----------------------------------------------------------------------------
116 #if !defined( __DARWIN__ ) || defined(__MWERKS__)
118 const double M_PI
= 3.14159265358979;
122 static const double RAD2DEG
= 180.0 / M_PI
;
125 // Pen, Brushes and Fonts
129 #pragma mark wxMacCoreGraphicsPattern, ImagePattern, HatchPattern classes
131 OSStatus
wxMacDrawCGImage(
132 CGContextRef inContext
,
133 const CGRect
* inBounds
,
137 return HIViewDrawCGImage( inContext
, inBounds
, inImage
);
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
);
150 CGColorRef
wxMacCreateCGColor( const wxColour
& col
)
152 CGColorRef retval
= 0;
154 retval
= col
.CreateCGColor();
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 );
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
) ;
171 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5 && wxOSX_USE_CORE_TEXT
173 CTFontRef
wxMacCreateCTFont( const wxFont
& font
)
176 return wxCFRetain((CTFontRef
) font
.OSXGetCTFont());
178 return CTFontCreateWithName( wxCFStringRef( font
.GetFaceName(), wxLocale::GetSystemEncoding() ) , font
.GetPointSize() , NULL
);
184 // CGPattern wrapper class: always allocate on heap, never call destructor
186 class wxMacCoreGraphicsPattern
189 wxMacCoreGraphicsPattern() {}
191 // is guaranteed to be called only with a non-Null CGContextRef
192 virtual void Render( CGContextRef ctxRef
) = 0;
194 operator CGPatternRef() const { return m_patternRef
; }
197 virtual ~wxMacCoreGraphicsPattern()
199 // as this is called only when the m_patternRef is been released;
200 // don't release it again
203 static void _Render( void *info
, CGContextRef ctxRef
)
205 wxMacCoreGraphicsPattern
* self
= (wxMacCoreGraphicsPattern
*) info
;
206 if ( self
&& ctxRef
)
207 self
->Render( ctxRef
);
210 static void _Dispose( void *info
)
212 wxMacCoreGraphicsPattern
* self
= (wxMacCoreGraphicsPattern
*) info
;
216 CGPatternRef m_patternRef
;
218 static const CGPatternCallbacks ms_Callbacks
;
221 const CGPatternCallbacks
wxMacCoreGraphicsPattern::ms_Callbacks
= { 0, &wxMacCoreGraphicsPattern::_Render
, &wxMacCoreGraphicsPattern::_Dispose
};
223 class ImagePattern
: public wxMacCoreGraphicsPattern
226 ImagePattern( const wxBitmap
* bmp
, const CGAffineTransform
& transform
)
228 wxASSERT( bmp
&& bmp
->IsOk() );
230 Init( (CGImageRef
) bmp
->CreateCGImage() , transform
);
234 // ImagePattern takes ownership of CGImageRef passed in
235 ImagePattern( CGImageRef image
, const CGAffineTransform
& transform
)
240 Init( image
, transform
);
243 virtual void Render( CGContextRef ctxRef
)
246 wxMacDrawCGImage( ctxRef
, &m_imageBounds
, m_image
);
250 void Init( CGImageRef image
, const CGAffineTransform
& transform
)
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
);
263 virtual ~ImagePattern()
266 CGImageRelease( m_image
);
270 CGRect m_imageBounds
;
273 class HatchPattern
: public wxMacCoreGraphicsPattern
276 HatchPattern( int hatchstyle
, const CGAffineTransform
& transform
)
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
);
286 void StrokeLineSegments( CGContextRef ctxRef
, const CGPoint pts
[] , size_t count
)
288 CGContextStrokeLineSegments( ctxRef
, pts
, count
);
291 virtual void Render( CGContextRef ctxRef
)
295 case wxBDIAGONAL_HATCH
:
299 { (CGFloat
) 8.0 , (CGFloat
) 0.0 } , { (CGFloat
) 0.0 , (CGFloat
) 8.0 }
301 StrokeLineSegments( ctxRef
, pts
, 2 );
305 case wxCROSSDIAG_HATCH
:
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 }
312 StrokeLineSegments( ctxRef
, pts
, 4 );
316 case wxFDIAGONAL_HATCH
:
320 { (CGFloat
) 0.0 , (CGFloat
) 0.0 } , { (CGFloat
) 8.0 , (CGFloat
) 8.0 }
322 StrokeLineSegments( ctxRef
, pts
, 2 );
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 } ,
333 StrokeLineSegments( ctxRef
, pts
, 4 );
337 case wxHORIZONTAL_HATCH
:
341 { (CGFloat
) 0.0 , (CGFloat
) 4.0 } , { (CGFloat
) 8.0 , (CGFloat
) 4.0 } ,
343 StrokeLineSegments( ctxRef
, pts
, 2 );
347 case wxVERTICAL_HATCH
:
351 { (CGFloat
) 4.0 , (CGFloat
) 0.0 } , { (CGFloat
) 4.0 , (CGFloat
) 8.0 } ,
353 StrokeLineSegments( ctxRef
, pts
, 2 );
363 virtual ~HatchPattern() {}
365 CGRect m_imageBounds
;
369 class wxMacCoreGraphicsPenData
: public wxGraphicsObjectRefData
372 wxMacCoreGraphicsPenData( wxGraphicsRenderer
* renderer
, const wxPen
&pen
);
373 ~wxMacCoreGraphicsPenData();
376 virtual void Apply( wxGraphicsContext
* context
);
377 virtual wxDouble
GetWidth() { return m_width
; }
381 wxCFRef
<CGColorRef
> m_color
;
382 wxCFRef
<CGColorSpaceRef
> m_colorSpace
;
388 const CGFloat
*m_lengths
;
389 CGFloat
*m_userLengths
;
393 wxCFRef
<CGPatternRef
> m_pattern
;
394 CGFloat
* m_patternColorComponents
;
397 wxMacCoreGraphicsPenData::wxMacCoreGraphicsPenData( wxGraphicsRenderer
* renderer
, const wxPen
&pen
) :
398 wxGraphicsObjectRefData( renderer
)
402 m_color
.reset( wxMacCreateCGColor( pen
.GetColour() ) ) ;
404 // TODO: * m_dc->m_scaleX
405 m_width
= pen
.GetWidth();
407 m_width
= (CGFloat
) 0.1;
409 switch ( pen
.GetCap() )
412 m_cap
= kCGLineCapRound
;
415 case wxCAP_PROJECTING
:
416 m_cap
= kCGLineCapSquare
;
420 m_cap
= kCGLineCapButt
;
424 m_cap
= kCGLineCapButt
;
428 switch ( pen
.GetJoin() )
431 m_join
= kCGLineJoinBevel
;
435 m_join
= kCGLineJoinMiter
;
439 m_join
= kCGLineJoinRound
;
443 m_join
= kCGLineJoinMiter
;
447 const CGFloat dashUnit
= m_width
< 1.0 ? (CGFloat
) 1.0 : m_width
;
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 };
454 switch ( pen
.GetStyle() )
456 case wxPENSTYLE_SOLID
:
460 m_count
= WXSIZEOF(dotted
);
461 m_userLengths
= new CGFloat
[ m_count
] ;
462 memcpy( m_userLengths
, dotted
, sizeof(dotted
) );
463 m_lengths
= m_userLengths
;
466 case wxPENSTYLE_LONG_DASH
:
467 m_count
= WXSIZEOF(dashed
);
471 case wxPENSTYLE_SHORT_DASH
:
472 m_count
= WXSIZEOF(short_dashed
);
473 m_lengths
= short_dashed
;
476 case wxPENSTYLE_DOT_DASH
:
477 m_count
= WXSIZEOF(dotted_dashed
);
478 m_lengths
= dotted_dashed
;
481 case wxPENSTYLE_USER_DASH
:
483 m_count
= pen
.GetDashes( &dashes
);
484 if ((dashes
!= NULL
) && (m_count
> 0))
486 m_userLengths
= new CGFloat
[m_count
];
487 for ( int i
= 0; i
< m_count
; ++i
)
489 m_userLengths
[i
] = dashes
[i
] * dashUnit
;
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
;
497 m_lengths
= m_userLengths
;
500 case wxPENSTYLE_STIPPLE
:
502 wxBitmap
* bmp
= pen
.GetStipple();
503 if ( bmp
&& bmp
->IsOk() )
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;
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);
527 if ((m_lengths
!= NULL
) && (m_count
> 0))
529 // force the line cap, otherwise we get artifacts (overlaps) and just solid lines
530 m_cap
= kCGLineCapButt
;
534 wxMacCoreGraphicsPenData::~wxMacCoreGraphicsPenData()
536 delete[] m_userLengths
;
537 delete[] m_patternColorComponents
;
540 void wxMacCoreGraphicsPenData::Init()
543 m_userLengths
= NULL
;
546 m_patternColorComponents
= NULL
;
550 void wxMacCoreGraphicsPenData::Apply( wxGraphicsContext
* context
)
552 CGContextRef cg
= (CGContextRef
) context
->GetNativeContext();
553 CGContextSetLineWidth( cg
, m_width
);
554 CGContextSetLineJoin( cg
, m_join
);
556 CGContextSetLineDash( cg
, 0 , m_lengths
, m_count
);
557 CGContextSetLineCap( cg
, m_cap
);
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
);
568 CGContextSetStrokeColorWithColor( cg
, m_color
);
576 // make sure we all use one class for all conversions from wx to native colour
578 class wxMacCoreGraphicsColour
581 wxMacCoreGraphicsColour();
582 wxMacCoreGraphicsColour(const wxBrush
&brush
);
583 ~wxMacCoreGraphicsColour();
585 void Apply( CGContextRef cgContext
);
588 wxCFRef
<CGColorRef
> m_color
;
589 wxCFRef
<CGColorSpaceRef
> m_colorSpace
;
592 wxCFRef
<CGPatternRef
> m_pattern
;
593 CGFloat
* m_patternColorComponents
;
596 wxMacCoreGraphicsColour::~wxMacCoreGraphicsColour()
598 delete[] m_patternColorComponents
;
601 void wxMacCoreGraphicsColour::Init()
604 m_patternColorComponents
= NULL
;
607 void wxMacCoreGraphicsColour::Apply( CGContextRef cgContext
)
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
);
618 CGContextSetFillColorWithColor( cgContext
, m_color
);
622 wxMacCoreGraphicsColour::wxMacCoreGraphicsColour()
627 wxMacCoreGraphicsColour::wxMacCoreGraphicsColour( const wxBrush
&brush
)
630 if ( brush
.GetStyle() == wxSOLID
)
632 m_color
.reset( wxMacCreateCGColor( brush
.GetColour() ));
634 else if ( brush
.IsHatch() )
637 m_colorSpace
.reset( CGColorSpaceCreatePattern( wxMacGetGenericRGBColorSpace() ) );
638 m_pattern
.reset( (CGPatternRef
) *( new HatchPattern( brush
.GetStyle() , CGAffineTransformMakeScale( 1,-1 ) ) ) );
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);
648 // now brush is a bitmap
649 wxBitmap
* bmp
= brush
.GetStipple();
650 if ( bmp
&& bmp
->IsOk() )
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 ) ) ) );
661 class wxMacCoreGraphicsBrushData
: public wxGraphicsObjectRefData
664 wxMacCoreGraphicsBrushData( wxGraphicsRenderer
* renderer
);
665 wxMacCoreGraphicsBrushData( wxGraphicsRenderer
* renderer
, const wxBrush
&brush
);
666 ~wxMacCoreGraphicsBrushData ();
668 virtual void Apply( wxGraphicsContext
* context
);
669 void CreateLinearGradientBrush(wxDouble x1
, wxDouble y1
,
670 wxDouble x2
, wxDouble y2
,
671 const wxGraphicsGradientStops
& stops
);
672 void CreateRadialGradientBrush(wxDouble xo
, wxDouble yo
,
673 wxDouble xc
, wxDouble yc
, wxDouble radius
,
674 const wxGraphicsGradientStops
& stops
);
676 virtual bool IsShading() { return m_isShading
; }
677 CGShadingRef
GetShading() { return m_shading
; }
679 CGFunctionRef
CreateGradientFunction(const wxGraphicsGradientStops
& stops
);
681 static void CalculateShadingValues (void *info
, const CGFloat
*in
, CGFloat
*out
);
684 wxMacCoreGraphicsColour m_cgColor
;
687 CGFunctionRef m_gradientFunction
;
688 CGShadingRef m_shading
;
690 // information about a single gradient component
691 struct GradientComponent
700 // and information about all of them
701 struct GradientComponents
709 void Init(unsigned count_
)
712 comps
= new GradientComponent
[count
];
715 ~GradientComponents()
721 GradientComponent
*comps
;
724 GradientComponents m_gradientComponents
;
727 wxMacCoreGraphicsBrushData::wxMacCoreGraphicsBrushData( wxGraphicsRenderer
* renderer
) : wxGraphicsObjectRefData( renderer
)
733 wxMacCoreGraphicsBrushData::CreateLinearGradientBrush(wxDouble x1
, wxDouble y1
,
734 wxDouble x2
, wxDouble y2
,
735 const wxGraphicsGradientStops
& stops
)
737 m_gradientFunction
= CreateGradientFunction(stops
);
738 m_shading
= CGShadingCreateAxial( wxMacGetGenericRGBColorSpace(), CGPointMake((CGFloat
) x1
, (CGFloat
) y1
),
739 CGPointMake((CGFloat
) x2
,(CGFloat
) y2
), m_gradientFunction
, true, true ) ;
744 wxMacCoreGraphicsBrushData::CreateRadialGradientBrush(wxDouble xo
, wxDouble yo
,
745 wxDouble xc
, wxDouble yc
,
747 const wxGraphicsGradientStops
& stops
)
749 m_gradientFunction
= CreateGradientFunction(stops
);
750 m_shading
= CGShadingCreateRadial( wxMacGetGenericRGBColorSpace(), CGPointMake((CGFloat
) xo
,(CGFloat
) yo
), 0,
751 CGPointMake((CGFloat
) xc
,(CGFloat
) yc
), (CGFloat
) radius
, m_gradientFunction
, true, true ) ;
755 wxMacCoreGraphicsBrushData::wxMacCoreGraphicsBrushData(wxGraphicsRenderer
* renderer
, const wxBrush
&brush
) : wxGraphicsObjectRefData( renderer
),
762 wxMacCoreGraphicsBrushData::~wxMacCoreGraphicsBrushData()
765 CGShadingRelease(m_shading
);
767 if( m_gradientFunction
)
768 CGFunctionRelease(m_gradientFunction
);
771 void wxMacCoreGraphicsBrushData::Init()
773 m_gradientFunction
= NULL
;
778 void wxMacCoreGraphicsBrushData::Apply( wxGraphicsContext
* context
)
780 CGContextRef cg
= (CGContextRef
) context
->GetNativeContext();
784 // nothing to set as shades are processed by clipping using the path and filling
788 m_cgColor
.Apply( cg
);
792 void wxMacCoreGraphicsBrushData::CalculateShadingValues (void *info
, const CGFloat
*in
, CGFloat
*out
)
794 const GradientComponents
& stops
= *(GradientComponents
*) info
;
800 out
[0] = stops
.comps
[0].red
;
801 out
[1] = stops
.comps
[0].green
;
802 out
[2] = stops
.comps
[0].blue
;
803 out
[3] = stops
.comps
[0].alpha
;
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
;
815 // Find first component with position greater than f
817 for ( i
= 0; i
< stops
.count
; i
++ )
819 if (stops
.comps
[i
].pos
> f
)
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
;
828 out
[0] = stops
.comps
[i
- 1].red
+ (stops
.comps
[i
].red
- stops
.comps
[i
- 1].red
) * fact
;
829 out
[1] = stops
.comps
[i
- 1].green
+ (stops
.comps
[i
].green
- stops
.comps
[i
- 1].green
) * fact
;
830 out
[2] = stops
.comps
[i
- 1].blue
+ (stops
.comps
[i
].blue
- stops
.comps
[i
- 1].blue
) * fact
;
831 out
[3] = stops
.comps
[i
- 1].alpha
+ (stops
.comps
[i
].alpha
- stops
.comps
[i
- 1].alpha
) * fact
;
836 wxMacCoreGraphicsBrushData::CreateGradientFunction(const wxGraphicsGradientStops
& stops
)
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 };
843 m_gradientComponents
.Init(stops
.GetCount());
844 for ( unsigned i
= 0; i
< m_gradientComponents
.count
; i
++ )
846 const wxGraphicsGradientStop stop
= stops
.Item(i
);
848 m_gradientComponents
.comps
[i
].pos
= stop
.GetPosition();
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);
857 return CGFunctionCreate ( &m_gradientComponents
, 1,
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
);
876 class wxMacCoreGraphicsFontData
: public wxGraphicsObjectRefData
879 wxMacCoreGraphicsFontData( wxGraphicsRenderer
* renderer
, const wxFont
&font
, const wxColour
& col
);
880 ~wxMacCoreGraphicsFontData();
882 #if wxOSX_USE_ATSU_TEXT
883 virtual ATSUStyle
GetATSUStyle() { return m_macATSUIStyle
; }
885 #if wxOSX_USE_CORE_TEXT
886 CTFontRef
OSXGetCTFont() const { return m_ctFont
; }
888 wxColour
GetColour() const { return m_colour
; }
890 bool GetUnderlined() const { return m_underlined
; }
892 UIFont
* GetUIFont() const { return m_uiFont
; }
897 #if wxOSX_USE_ATSU_TEXT
898 ATSUStyle m_macATSUIStyle
;
900 #if wxOSX_USE_CORE_TEXT
901 wxCFRef
< CTFontRef
> m_ctFont
;
908 wxMacCoreGraphicsFontData::wxMacCoreGraphicsFontData(wxGraphicsRenderer
* renderer
, const wxFont
&font
, const wxColour
& col
) : wxGraphicsObjectRefData( renderer
)
911 m_underlined
= font
.GetUnderlined();
913 #if wxOSX_USE_CORE_TEXT
914 m_ctFont
.reset( wxMacCreateCTFont( font
) );
917 m_uiFont
= CreateUIFont(font
);
918 wxMacCocoaRetain( m_uiFont
);
920 #if wxOSX_USE_ATSU_TEXT
921 OSStatus status
= noErr
;
922 m_macATSUIStyle
= NULL
;
924 status
= ATSUCreateAndCopyStyle( (ATSUStyle
) font
.MacGetATSUStyle() , &m_macATSUIStyle
);
926 wxASSERT_MSG( status
== noErr
, wxT("couldn't create ATSU style") );
928 // we need the scale here ...
930 Fixed atsuSize
= IntToFixed( int( 1 * font
.GetPointSize()) );
932 col
.GetRGBColor( &atsuColor
);
933 ATSUAttributeTag atsuTags
[] =
938 ByteCount atsuSizes
[WXSIZEOF(atsuTags
)] =
943 ATSUAttributeValuePtr atsuValues
[WXSIZEOF(atsuTags
)] =
949 status
= ::ATSUSetAttributes(
950 m_macATSUIStyle
, WXSIZEOF(atsuTags
),
951 atsuTags
, atsuSizes
, atsuValues
);
953 wxASSERT_MSG( status
== noErr
, wxT("couldn't modify ATSU style") );
957 wxMacCoreGraphicsFontData::~wxMacCoreGraphicsFontData()
959 #if wxOSX_USE_CORE_TEXT
961 #if wxOSX_USE_ATSU_TEXT
962 if ( m_macATSUIStyle
)
964 ::ATSUDisposeStyle((ATSUStyle
)m_macATSUIStyle
);
965 m_macATSUIStyle
= NULL
;
969 wxMacCocoaRelease( m_uiFont
);
973 class wxMacCoreGraphicsBitmapData
: public wxGraphicsObjectRefData
976 wxMacCoreGraphicsBitmapData( wxGraphicsRenderer
* renderer
, CGImageRef bitmap
, bool monochrome
);
977 ~wxMacCoreGraphicsBitmapData();
979 virtual CGImageRef
GetBitmap() { return m_bitmap
; }
980 bool IsMonochrome() { return m_monochrome
; }
983 wxImage
ConvertToImage() const
985 return wxBitmap(m_bitmap
).ConvertToImage();
987 #endif // wxUSE_IMAGE
994 wxMacCoreGraphicsBitmapData::wxMacCoreGraphicsBitmapData( wxGraphicsRenderer
* renderer
, CGImageRef bitmap
, bool monochrome
) : wxGraphicsObjectRefData( renderer
),
995 m_bitmap(bitmap
), m_monochrome(monochrome
)
999 wxMacCoreGraphicsBitmapData::~wxMacCoreGraphicsBitmapData()
1001 CGImageRelease( m_bitmap
);
1006 wxImage
wxGraphicsBitmap::ConvertToImage() const
1008 wxMacCoreGraphicsBitmapData
* const
1009 data
= static_cast<wxMacCoreGraphicsBitmapData
*>(GetRefData());
1011 return data
? data
->ConvertToImage() : wxNullImage
;
1014 #endif // wxUSE_IMAGE
1020 //-----------------------------------------------------------------------------
1021 // wxMacCoreGraphicsMatrix declaration
1022 //-----------------------------------------------------------------------------
1024 class WXDLLIMPEXP_CORE wxMacCoreGraphicsMatrixData
: public wxGraphicsMatrixData
1027 wxMacCoreGraphicsMatrixData(wxGraphicsRenderer
* renderer
) ;
1029 virtual ~wxMacCoreGraphicsMatrixData() ;
1031 virtual wxGraphicsObjectRefData
*Clone() const ;
1033 // concatenates the matrix
1034 virtual void Concat( const wxGraphicsMatrixData
*t
);
1036 // sets the matrix to the respective values
1037 virtual void Set(wxDouble a
=1.0, wxDouble b
=0.0, wxDouble c
=0.0, wxDouble d
=1.0,
1038 wxDouble tx
=0.0, wxDouble ty
=0.0);
1040 // gets the component valuess of the matrix
1041 virtual void Get(wxDouble
* a
=NULL
, wxDouble
* b
=NULL
, wxDouble
* c
=NULL
,
1042 wxDouble
* d
=NULL
, wxDouble
* tx
=NULL
, wxDouble
* ty
=NULL
) const;
1044 // makes this the inverse matrix
1045 virtual void Invert();
1047 // returns true if the elements of the transformation matrix are equal ?
1048 virtual bool IsEqual( const wxGraphicsMatrixData
* t
) const ;
1050 // return true if this is the identity matrix
1051 virtual bool IsIdentity() const;
1057 // add the translation to this matrix
1058 virtual void Translate( wxDouble dx
, wxDouble dy
);
1060 // add the scale to this matrix
1061 virtual void Scale( wxDouble xScale
, wxDouble yScale
);
1063 // add the rotation to this matrix (radians)
1064 virtual void Rotate( wxDouble angle
);
1067 // apply the transforms
1070 // applies that matrix to the point
1071 virtual void TransformPoint( wxDouble
*x
, wxDouble
*y
) const;
1073 // applies the matrix except for translations
1074 virtual void TransformDistance( wxDouble
*dx
, wxDouble
*dy
) const;
1076 // returns the native representation
1077 virtual void * GetNativeMatrix() const;
1080 CGAffineTransform m_matrix
;
1083 //-----------------------------------------------------------------------------
1084 // wxMacCoreGraphicsMatrix implementation
1085 //-----------------------------------------------------------------------------
1087 wxMacCoreGraphicsMatrixData::wxMacCoreGraphicsMatrixData(wxGraphicsRenderer
* renderer
) : wxGraphicsMatrixData(renderer
)
1091 wxMacCoreGraphicsMatrixData::~wxMacCoreGraphicsMatrixData()
1095 wxGraphicsObjectRefData
*wxMacCoreGraphicsMatrixData::Clone() const
1097 wxMacCoreGraphicsMatrixData
* m
= new wxMacCoreGraphicsMatrixData(GetRenderer()) ;
1098 m
->m_matrix
= m_matrix
;
1102 // concatenates the matrix
1103 void wxMacCoreGraphicsMatrixData::Concat( const wxGraphicsMatrixData
*t
)
1105 m_matrix
= CGAffineTransformConcat(*((CGAffineTransform
*) t
->GetNativeMatrix()), m_matrix
);
1108 // sets the matrix to the respective values
1109 void wxMacCoreGraphicsMatrixData::Set(wxDouble a
, wxDouble b
, wxDouble c
, wxDouble d
,
1110 wxDouble tx
, wxDouble ty
)
1112 m_matrix
= CGAffineTransformMake((CGFloat
) a
,(CGFloat
) b
,(CGFloat
) c
,(CGFloat
) d
,(CGFloat
) tx
,(CGFloat
) ty
);
1115 // gets the component valuess of the matrix
1116 void wxMacCoreGraphicsMatrixData::Get(wxDouble
* a
, wxDouble
* b
, wxDouble
* c
,
1117 wxDouble
* d
, wxDouble
* tx
, wxDouble
* ty
) const
1119 if (a
) *a
= m_matrix
.a
;
1120 if (b
) *b
= m_matrix
.b
;
1121 if (c
) *c
= m_matrix
.c
;
1122 if (d
) *d
= m_matrix
.d
;
1123 if (tx
) *tx
= m_matrix
.tx
;
1124 if (ty
) *ty
= m_matrix
.ty
;
1127 // makes this the inverse matrix
1128 void wxMacCoreGraphicsMatrixData::Invert()
1130 m_matrix
= CGAffineTransformInvert( m_matrix
);
1133 // returns true if the elements of the transformation matrix are equal ?
1134 bool wxMacCoreGraphicsMatrixData::IsEqual( const wxGraphicsMatrixData
* t
) const
1136 return CGAffineTransformEqualToTransform(m_matrix
, *((CGAffineTransform
*) t
->GetNativeMatrix()));
1139 // return true if this is the identity matrix
1140 bool wxMacCoreGraphicsMatrixData::IsIdentity() const
1142 return ( m_matrix
.a
== 1 && m_matrix
.d
== 1 &&
1143 m_matrix
.b
== 0 && m_matrix
.d
== 0 && m_matrix
.tx
== 0 && m_matrix
.ty
== 0);
1150 // add the translation to this matrix
1151 void wxMacCoreGraphicsMatrixData::Translate( wxDouble dx
, wxDouble dy
)
1153 m_matrix
= CGAffineTransformTranslate( m_matrix
, (CGFloat
) dx
, (CGFloat
) dy
);
1156 // add the scale to this matrix
1157 void wxMacCoreGraphicsMatrixData::Scale( wxDouble xScale
, wxDouble yScale
)
1159 m_matrix
= CGAffineTransformScale( m_matrix
, (CGFloat
) xScale
, (CGFloat
) yScale
);
1162 // add the rotation to this matrix (radians)
1163 void wxMacCoreGraphicsMatrixData::Rotate( wxDouble angle
)
1165 m_matrix
= CGAffineTransformRotate( m_matrix
, (CGFloat
) angle
);
1169 // apply the transforms
1172 // applies that matrix to the point
1173 void wxMacCoreGraphicsMatrixData::TransformPoint( wxDouble
*x
, wxDouble
*y
) const
1175 CGPoint pt
= CGPointApplyAffineTransform( CGPointMake((CGFloat
) *x
,(CGFloat
) *y
), m_matrix
);
1181 // applies the matrix except for translations
1182 void wxMacCoreGraphicsMatrixData::TransformDistance( wxDouble
*dx
, wxDouble
*dy
) const
1184 CGSize sz
= CGSizeApplyAffineTransform( CGSizeMake((CGFloat
) *dx
,(CGFloat
) *dy
) , m_matrix
);
1189 // returns the native representation
1190 void * wxMacCoreGraphicsMatrixData::GetNativeMatrix() const
1192 return (void*) &m_matrix
;
1199 //-----------------------------------------------------------------------------
1200 // wxMacCoreGraphicsPath declaration
1201 //-----------------------------------------------------------------------------
1203 class WXDLLEXPORT wxMacCoreGraphicsPathData
: public wxGraphicsPathData
1206 wxMacCoreGraphicsPathData( wxGraphicsRenderer
* renderer
, CGMutablePathRef path
= NULL
);
1208 ~wxMacCoreGraphicsPathData();
1210 virtual wxGraphicsObjectRefData
*Clone() const;
1212 // begins a new subpath at (x,y)
1213 virtual void MoveToPoint( wxDouble x
, wxDouble y
);
1215 // adds a straight line from the current point to (x,y)
1216 virtual void AddLineToPoint( wxDouble x
, wxDouble y
);
1218 // adds a cubic Bezier curve from the current point, using two control points and an end point
1219 virtual void AddCurveToPoint( wxDouble cx1
, wxDouble cy1
, wxDouble cx2
, wxDouble cy2
, wxDouble x
, wxDouble y
);
1221 // closes the current sub-path
1222 virtual void CloseSubpath();
1224 // gets the last point of the current path, (0,0) if not yet set
1225 virtual void GetCurrentPoint( wxDouble
* x
, wxDouble
* y
) const;
1227 // adds an arc of a circle centering at (x,y) with radius (r) from startAngle to endAngle
1228 virtual void AddArc( wxDouble x
, wxDouble y
, wxDouble r
, wxDouble startAngle
, wxDouble endAngle
, bool clockwise
);
1231 // These are convenience functions which - if not available natively will be assembled
1232 // using the primitives from above
1235 // adds a quadratic Bezier curve from the current point, using a control point and an end point
1236 virtual void AddQuadCurveToPoint( wxDouble cx
, wxDouble cy
, wxDouble x
, wxDouble y
);
1238 // appends a rectangle as a new closed subpath
1239 virtual void AddRectangle( wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
);
1241 // appends a circle as a new closed subpath
1242 virtual void AddCircle( wxDouble x
, wxDouble y
, wxDouble r
);
1244 // appends an ellipsis as a new closed subpath fitting the passed rectangle
1245 virtual void AddEllipse( wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
);
1247 // 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)
1248 virtual void AddArcToPoint( wxDouble x1
, wxDouble y1
, wxDouble x2
, wxDouble y2
, wxDouble r
);
1250 // adds another path
1251 virtual void AddPath( const wxGraphicsPathData
* path
);
1253 // returns the native path
1254 virtual void * GetNativePath() const { return m_path
; }
1256 // give the native path returned by GetNativePath() back (there might be some deallocations necessary)
1257 virtual void UnGetNativePath(void *WXUNUSED(p
)) const {}
1259 // transforms each point of this path by the matrix
1260 virtual void Transform( const wxGraphicsMatrixData
* matrix
);
1262 // gets the bounding box enclosing all points (possibly including control points)
1263 virtual void GetBox(wxDouble
*x
, wxDouble
*y
, wxDouble
*w
, wxDouble
*h
) const;
1265 virtual bool Contains( wxDouble x
, wxDouble y
, wxPolygonFillMode fillStyle
= wxODDEVEN_RULE
) const;
1267 CGMutablePathRef m_path
;
1270 //-----------------------------------------------------------------------------
1271 // wxMacCoreGraphicsPath implementation
1272 //-----------------------------------------------------------------------------
1274 wxMacCoreGraphicsPathData::wxMacCoreGraphicsPathData( wxGraphicsRenderer
* renderer
, CGMutablePathRef path
) : wxGraphicsPathData(renderer
)
1279 m_path
= CGPathCreateMutable();
1282 wxMacCoreGraphicsPathData::~wxMacCoreGraphicsPathData()
1284 CGPathRelease( m_path
);
1287 wxGraphicsObjectRefData
* wxMacCoreGraphicsPathData::Clone() const
1289 wxMacCoreGraphicsPathData
* clone
= new wxMacCoreGraphicsPathData(GetRenderer(),CGPathCreateMutableCopy(m_path
));
1294 // opens (starts) a new subpath
1295 void wxMacCoreGraphicsPathData::MoveToPoint( wxDouble x1
, wxDouble y1
)
1297 CGPathMoveToPoint( m_path
, NULL
, (CGFloat
) x1
, (CGFloat
) y1
);
1300 void wxMacCoreGraphicsPathData::AddLineToPoint( wxDouble x1
, wxDouble y1
)
1302 CGPathAddLineToPoint( m_path
, NULL
, (CGFloat
) x1
, (CGFloat
) y1
);
1305 void wxMacCoreGraphicsPathData::AddCurveToPoint( wxDouble cx1
, wxDouble cy1
, wxDouble cx2
, wxDouble cy2
, wxDouble x
, wxDouble y
)
1307 CGPathAddCurveToPoint( m_path
, NULL
, (CGFloat
) cx1
, (CGFloat
) cy1
, (CGFloat
) cx2
, (CGFloat
) cy2
, (CGFloat
) x
, (CGFloat
) y
);
1310 void wxMacCoreGraphicsPathData::AddQuadCurveToPoint( wxDouble cx1
, wxDouble cy1
, wxDouble x
, wxDouble y
)
1312 CGPathAddQuadCurveToPoint( m_path
, NULL
, (CGFloat
) cx1
, (CGFloat
) cy1
, (CGFloat
) x
, (CGFloat
) y
);
1315 void wxMacCoreGraphicsPathData::AddRectangle( wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
)
1317 CGRect cgRect
= { { (CGFloat
) x
, (CGFloat
) y
} , { (CGFloat
) w
, (CGFloat
) h
} };
1318 CGPathAddRect( m_path
, NULL
, cgRect
);
1321 void wxMacCoreGraphicsPathData::AddCircle( wxDouble x
, wxDouble y
, wxDouble r
)
1323 CGPathAddEllipseInRect( m_path
, NULL
, CGRectMake(x
-r
,y
-r
,2*r
,2*r
));
1326 void wxMacCoreGraphicsPathData::AddEllipse( wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
)
1328 CGPathAddEllipseInRect( m_path
, NULL
, CGRectMake(x
,y
,w
,h
));
1331 // adds an arc of a circle centering at (x,y) with radius (r) from startAngle to endAngle
1332 void wxMacCoreGraphicsPathData::AddArc( wxDouble x
, wxDouble y
, wxDouble r
, wxDouble startAngle
, wxDouble endAngle
, bool clockwise
)
1334 // inverse direction as we the 'normal' state is a y axis pointing down, ie mirrored to the standard core graphics setup
1335 CGPathAddArc( m_path
, NULL
, (CGFloat
) x
, (CGFloat
) y
, (CGFloat
) r
, (CGFloat
) startAngle
, (CGFloat
) endAngle
, !clockwise
);
1338 void wxMacCoreGraphicsPathData::AddArcToPoint( wxDouble x1
, wxDouble y1
, wxDouble x2
, wxDouble y2
, wxDouble r
)
1340 CGPathAddArcToPoint( m_path
, NULL
, (CGFloat
) x1
, (CGFloat
) y1
, (CGFloat
) x2
, (CGFloat
) y2
, (CGFloat
) r
);
1343 void wxMacCoreGraphicsPathData::AddPath( const wxGraphicsPathData
* path
)
1345 CGPathAddPath( m_path
, NULL
, (CGPathRef
) path
->GetNativePath() );
1348 // closes the current subpath
1349 void wxMacCoreGraphicsPathData::CloseSubpath()
1351 CGPathCloseSubpath( m_path
);
1354 // gets the last point of the current path, (0,0) if not yet set
1355 void wxMacCoreGraphicsPathData::GetCurrentPoint( wxDouble
* x
, wxDouble
* y
) const
1357 CGPoint p
= CGPathGetCurrentPoint( m_path
);
1362 // transforms each point of this path by the matrix
1363 void wxMacCoreGraphicsPathData::Transform( const wxGraphicsMatrixData
* matrix
)
1365 CGMutablePathRef p
= CGPathCreateMutable() ;
1366 CGPathAddPath( p
, (CGAffineTransform
*) matrix
->GetNativeMatrix() , m_path
);
1367 CGPathRelease( m_path
);
1371 // gets the bounding box enclosing all points (possibly including control points)
1372 void wxMacCoreGraphicsPathData::GetBox(wxDouble
*x
, wxDouble
*y
, wxDouble
*w
, wxDouble
*h
) const
1374 CGRect bounds
= CGPathGetBoundingBox( m_path
) ;
1375 *x
= bounds
.origin
.x
;
1376 *y
= bounds
.origin
.y
;
1377 *w
= bounds
.size
.width
;
1378 *h
= bounds
.size
.height
;
1381 bool wxMacCoreGraphicsPathData::Contains( wxDouble x
, wxDouble y
, wxPolygonFillMode fillStyle
) const
1383 return CGPathContainsPoint( m_path
, NULL
, CGPointMake((CGFloat
) x
,(CGFloat
) y
), fillStyle
== wxODDEVEN_RULE
);
1390 //-----------------------------------------------------------------------------
1391 // wxMacCoreGraphicsContext declaration
1392 //-----------------------------------------------------------------------------
1394 class WXDLLEXPORT wxMacCoreGraphicsContext
: public wxGraphicsContext
1397 wxMacCoreGraphicsContext( wxGraphicsRenderer
* renderer
, CGContextRef cgcontext
, wxDouble width
= 0, wxDouble height
= 0 );
1399 #if wxOSX_USE_CARBON
1400 wxMacCoreGraphicsContext( wxGraphicsRenderer
* renderer
, WindowRef window
);
1403 wxMacCoreGraphicsContext( wxGraphicsRenderer
* renderer
, wxWindow
* window
);
1405 wxMacCoreGraphicsContext( wxGraphicsRenderer
* renderer
);
1407 ~wxMacCoreGraphicsContext();
1411 virtual void StartPage( wxDouble width
, wxDouble height
);
1413 virtual void EndPage();
1415 virtual void Flush();
1417 // push the current state of the context, ie the transformation matrix on a stack
1418 virtual void PushState();
1420 // pops a stored state from the stack
1421 virtual void PopState();
1423 // clips drawings to the region
1424 virtual void Clip( const wxRegion
®ion
);
1426 // clips drawings to the rect
1427 virtual void Clip( wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
);
1429 // resets the clipping to original extent
1430 virtual void ResetClip();
1432 virtual void * GetNativeContext();
1434 virtual bool SetAntialiasMode(wxAntialiasMode antialias
);
1436 virtual bool SetInterpolationQuality(wxInterpolationQuality interpolation
);
1438 virtual bool SetCompositionMode(wxCompositionMode op
);
1440 virtual void BeginLayer(wxDouble opacity
);
1442 virtual void EndLayer();
1449 virtual void Translate( wxDouble dx
, wxDouble dy
);
1452 virtual void Scale( wxDouble xScale
, wxDouble yScale
);
1455 virtual void Rotate( wxDouble angle
);
1457 // concatenates this transform with the current transform of this context
1458 virtual void ConcatTransform( const wxGraphicsMatrix
& matrix
);
1460 // sets the transform of this context
1461 virtual void SetTransform( const wxGraphicsMatrix
& matrix
);
1463 // gets the matrix of this context
1464 virtual wxGraphicsMatrix
GetTransform() const;
1466 // setting the paint
1469 // strokes along a path with the current pen
1470 virtual void StrokePath( const wxGraphicsPath
&path
);
1472 // fills a path with the current brush
1473 virtual void FillPath( const wxGraphicsPath
&path
, wxPolygonFillMode fillStyle
= wxODDEVEN_RULE
);
1475 // draws a path by first filling and then stroking
1476 virtual void DrawPath( const wxGraphicsPath
&path
, wxPolygonFillMode fillStyle
= wxODDEVEN_RULE
);
1478 virtual bool ShouldOffset() const
1480 if ( !m_enableOffset
)
1484 if ( !m_pen
.IsNull() )
1486 penwidth
= (int)((wxMacCoreGraphicsPenData
*)m_pen
.GetRefData())->GetWidth();
1487 if ( penwidth
== 0 )
1490 return ( penwidth
% 2 ) == 1;
1496 virtual void GetTextExtent( const wxString
&text
, wxDouble
*width
, wxDouble
*height
,
1497 wxDouble
*descent
, wxDouble
*externalLeading
) const;
1499 virtual void GetPartialTextExtents(const wxString
& text
, wxArrayDouble
& widths
) const;
1505 virtual void DrawBitmap( const wxBitmap
&bmp
, wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
);
1507 virtual void DrawBitmap( const wxGraphicsBitmap
&bmp
, wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
);
1509 virtual void DrawIcon( const wxIcon
&icon
, wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
);
1511 // fast convenience methods
1514 virtual void DrawRectangleX( wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
);
1516 void SetNativeContext( CGContextRef cg
);
1518 wxDECLARE_NO_COPY_CLASS(wxMacCoreGraphicsContext
);
1521 bool EnsureIsValid();
1523 virtual void DoDrawText( const wxString
&str
, wxDouble x
, wxDouble y
);
1524 virtual void DoDrawRotatedText( const wxString
&str
, wxDouble x
, wxDouble y
, wxDouble angle
);
1526 CGContextRef m_cgContext
;
1527 #if wxOSX_USE_CARBON
1528 WindowRef m_windowRef
;
1532 bool m_contextSynthesized
;
1533 CGAffineTransform m_windowTransform
;
1536 #if wxOSX_USE_COCOA_OR_CARBON
1537 wxCFRef
<HIShapeRef
> m_clipRgn
;
1541 //-----------------------------------------------------------------------------
1542 // device context implementation
1544 // more and more of the dc functionality should be implemented by calling
1545 // the appropricate wxMacCoreGraphicsContext, but we will have to do that step by step
1546 // also coordinate conversions should be moved to native matrix ops
1547 //-----------------------------------------------------------------------------
1549 // we always stock two context states, one at entry, to be able to preserve the
1550 // state we were called with, the other one after changing to HI Graphics orientation
1551 // (this one is used for getting back clippings etc)
1553 //-----------------------------------------------------------------------------
1554 // wxMacCoreGraphicsContext implementation
1555 //-----------------------------------------------------------------------------
1557 class wxQuartzOffsetHelper
1560 wxQuartzOffsetHelper( CGContextRef cg
, bool offset
)
1566 m_userOffset
= CGContextConvertSizeToUserSpace( m_cg
, CGSizeMake( 0.5 , 0.5 ) );
1567 CGContextTranslateCTM( m_cg
, m_userOffset
.width
, m_userOffset
.height
);
1571 m_userOffset
= CGSizeMake(0.0, 0.0);
1575 ~wxQuartzOffsetHelper( )
1578 CGContextTranslateCTM( m_cg
, -m_userOffset
.width
, -m_userOffset
.height
);
1581 CGSize m_userOffset
;
1586 void wxMacCoreGraphicsContext::Init()
1589 m_contextSynthesized
= false;
1592 #if wxOSX_USE_CARBON
1595 #if wxOSX_USE_COCOA_OR_IPHONE
1598 m_invisible
= false;
1599 m_antialias
= wxANTIALIAS_DEFAULT
;
1600 m_interpolation
= wxINTERPOLATION_DEFAULT
;
1603 wxMacCoreGraphicsContext::wxMacCoreGraphicsContext( wxGraphicsRenderer
* renderer
, CGContextRef cgcontext
, wxDouble width
, wxDouble height
) : wxGraphicsContext(renderer
)
1606 SetNativeContext(cgcontext
);
1611 #if wxOSX_USE_CARBON
1612 wxMacCoreGraphicsContext::wxMacCoreGraphicsContext( wxGraphicsRenderer
* renderer
, WindowRef window
): wxGraphicsContext(renderer
)
1615 m_windowRef
= window
;
1616 m_enableOffset
= true;
1620 wxMacCoreGraphicsContext::wxMacCoreGraphicsContext( wxGraphicsRenderer
* renderer
, wxWindow
* window
): wxGraphicsContext(renderer
)
1624 m_enableOffset
= true;
1625 wxSize sz
= window
->GetSize();
1629 #if wxOSX_USE_COCOA_OR_IPHONE
1630 m_view
= window
->GetHandle();
1633 if ( ! window
->GetPeer()->IsFlipped() )
1635 m_windowTransform
= CGAffineTransformMakeTranslation( 0 , m_height
);
1636 m_windowTransform
= CGAffineTransformScale( m_windowTransform
, 1 , -1 );
1641 m_windowTransform
= CGAffineTransformIdentity
;
1644 int originX
, originY
;
1645 originX
= originY
= 0;
1646 Rect bounds
= { 0,0,0,0 };
1647 m_windowRef
= (WindowRef
) window
->MacGetTopLevelWindowRef();
1648 window
->MacWindowToRootWindow( &originX
, &originY
);
1649 GetWindowBounds( m_windowRef
, kWindowContentRgn
, &bounds
);
1650 m_windowTransform
= CGAffineTransformMakeTranslation( 0 , bounds
.bottom
- bounds
.top
);
1651 m_windowTransform
= CGAffineTransformScale( m_windowTransform
, 1 , -1 );
1652 m_windowTransform
= CGAffineTransformTranslate( m_windowTransform
, originX
, originY
) ;
1656 wxMacCoreGraphicsContext::wxMacCoreGraphicsContext(wxGraphicsRenderer
* renderer
) : wxGraphicsContext(renderer
)
1661 wxMacCoreGraphicsContext::~wxMacCoreGraphicsContext()
1663 SetNativeContext(NULL
);
1667 void wxMacCoreGraphicsContext::StartPage( wxDouble width
, wxDouble height
)
1670 if ( width
!= 0 && height
!= 0)
1671 r
= CGRectMake( (CGFloat
) 0.0 , (CGFloat
) 0.0 , (CGFloat
) width
, (CGFloat
) height
);
1673 r
= CGRectMake( (CGFloat
) 0.0 , (CGFloat
) 0.0 , (CGFloat
) m_width
, (CGFloat
) m_height
);
1675 CGContextBeginPage(m_cgContext
, &r
);
1676 // CGContextTranslateCTM( m_cgContext , 0 , height == 0 ? m_height : height );
1677 // CGContextScaleCTM( m_cgContext , 1 , -1 );
1680 void wxMacCoreGraphicsContext::EndPage()
1682 CGContextEndPage(m_cgContext
);
1685 void wxMacCoreGraphicsContext::Flush()
1687 CGContextFlush(m_cgContext
);
1690 bool wxMacCoreGraphicsContext::EnsureIsValid()
1698 if ( wxOSXLockFocus(m_view
) )
1700 m_cgContext
= wxOSXGetContextFromCurrentContext();
1701 wxASSERT_MSG( m_cgContext
!= NULL
, wxT("Unable to retrieve drawing context from View"));
1708 #if wxOSX_USE_IPHONE
1709 m_cgContext
= wxOSXGetContextFromCurrentContext();
1710 if ( m_cgContext
== NULL
)
1715 #if wxOSX_USE_CARBON
1716 OSStatus status
= QDBeginCGContext( GetWindowPort( m_windowRef
) , &m_cgContext
);
1717 if ( status
!= noErr
)
1719 wxFAIL_MSG("Cannot nest wxDCs on the same window");
1724 CGContextSaveGState( m_cgContext
);
1725 #if wxOSX_USE_COCOA_OR_CARBON
1726 if ( m_clipRgn
.get() )
1728 wxCFRef
<HIMutableShapeRef
> hishape( HIShapeCreateMutableCopy( m_clipRgn
) );
1729 // if the shape is empty, HIShapeReplacePathInCGContext doesn't work
1730 if ( HIShapeIsEmpty(hishape
))
1732 CGRect empty
= CGRectMake( 0,0,0,0 );
1733 CGContextClipToRect( m_cgContext
, empty
);
1737 HIShapeReplacePathInCGContext( hishape
, m_cgContext
);
1738 CGContextClip( m_cgContext
);
1742 CGContextConcatCTM( m_cgContext
, m_windowTransform
);
1743 CGContextSetTextMatrix( m_cgContext
, CGAffineTransformIdentity
);
1744 m_contextSynthesized
= true;
1745 CGContextSaveGState( m_cgContext
);
1747 #if 0 // turn on for debugging of clientdc
1748 static float color
= 0.5 ;
1749 static int channel
= 0 ;
1750 CGRect bounds
= CGRectMake(-1000,-1000,2000,2000);
1751 CGContextSetRGBFillColor( m_cgContext
, channel
== 0 ? color
: 0.5 ,
1752 channel
== 1 ? color
: 0.5 , channel
== 2 ? color
: 0.5 , 1 );
1753 CGContextFillRect( m_cgContext
, bounds
);
1765 return m_cgContext
!= NULL
;
1768 bool wxMacCoreGraphicsContext::SetAntialiasMode(wxAntialiasMode antialias
)
1770 if (!EnsureIsValid())
1773 if (m_antialias
== antialias
)
1776 m_antialias
= antialias
;
1781 case wxANTIALIAS_DEFAULT
:
1782 antialiasMode
= true;
1784 case wxANTIALIAS_NONE
:
1785 antialiasMode
= false;
1790 CGContextSetShouldAntialias(m_cgContext
, antialiasMode
);
1794 bool wxMacCoreGraphicsContext::SetInterpolationQuality(wxInterpolationQuality interpolation
)
1796 if (!EnsureIsValid())
1799 if (m_interpolation
== interpolation
)
1802 m_interpolation
= interpolation
;
1803 CGInterpolationQuality quality
;
1805 switch (interpolation
)
1807 case wxINTERPOLATION_DEFAULT
:
1808 quality
= kCGInterpolationDefault
;
1810 case wxINTERPOLATION_NONE
:
1811 quality
= kCGInterpolationNone
;
1813 case wxINTERPOLATION_FAST
:
1814 quality
= kCGInterpolationLow
;
1816 case wxINTERPOLATION_GOOD
:
1817 #if wxOSX_USE_COCOA_OR_CARBON
1818 quality
= UMAGetSystemVersion() < 0x1060 ? kCGInterpolationHigh
: (CGInterpolationQuality
) 4 /*kCGInterpolationMedium only on 10.6*/;
1820 quality
= kCGInterpolationMedium
;
1823 case wxINTERPOLATION_BEST
:
1824 quality
= kCGInterpolationHigh
;
1829 CGContextSetInterpolationQuality(m_cgContext
, quality
);
1833 bool wxMacCoreGraphicsContext::SetCompositionMode(wxCompositionMode op
)
1835 if (!EnsureIsValid())
1838 if ( m_composition
== op
)
1843 if (m_composition
== wxCOMPOSITION_DEST
)
1846 #if wxOSX_USE_COCOA_OR_CARBON
1847 if ( UMAGetSystemVersion() < 0x1060 )
1849 CGCompositeOperation cop
= kCGCompositeOperationSourceOver
;
1850 CGBlendMode mode
= kCGBlendModeNormal
;
1853 case wxCOMPOSITION_CLEAR
:
1854 cop
= kCGCompositeOperationClear
;
1856 case wxCOMPOSITION_SOURCE
:
1857 cop
= kCGCompositeOperationCopy
;
1859 case wxCOMPOSITION_OVER
:
1860 mode
= kCGBlendModeNormal
;
1862 case wxCOMPOSITION_IN
:
1863 cop
= kCGCompositeOperationSourceIn
;
1865 case wxCOMPOSITION_OUT
:
1866 cop
= kCGCompositeOperationSourceOut
;
1868 case wxCOMPOSITION_ATOP
:
1869 cop
= kCGCompositeOperationSourceAtop
;
1871 case wxCOMPOSITION_DEST_OVER
:
1872 cop
= kCGCompositeOperationDestinationOver
;
1874 case wxCOMPOSITION_DEST_IN
:
1875 cop
= kCGCompositeOperationDestinationIn
;
1877 case wxCOMPOSITION_DEST_OUT
:
1878 cop
= kCGCompositeOperationDestinationOut
;
1880 case wxCOMPOSITION_DEST_ATOP
:
1881 cop
= kCGCompositeOperationDestinationAtop
;
1883 case wxCOMPOSITION_XOR
:
1884 cop
= kCGCompositeOperationXOR
;
1886 #if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5
1887 case wxCOMPOSITION_ADD
:
1888 mode
= kCGBlendModePlusLighter
;
1894 if ( cop
!= kCGCompositeOperationSourceOver
)
1895 CGContextSetCompositeOperation(m_cgContext
, cop
);
1897 CGContextSetBlendMode(m_cgContext
, mode
);
1900 #if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5
1903 CGBlendMode mode
= kCGBlendModeNormal
;
1906 case wxCOMPOSITION_CLEAR
:
1907 mode
= kCGBlendModeClear
;
1909 case wxCOMPOSITION_SOURCE
:
1910 mode
= kCGBlendModeCopy
;
1912 case wxCOMPOSITION_OVER
:
1913 mode
= kCGBlendModeNormal
;
1915 case wxCOMPOSITION_IN
:
1916 mode
= kCGBlendModeSourceIn
;
1918 case wxCOMPOSITION_OUT
:
1919 mode
= kCGBlendModeSourceOut
;
1921 case wxCOMPOSITION_ATOP
:
1922 mode
= kCGBlendModeSourceAtop
;
1924 case wxCOMPOSITION_DEST_OVER
:
1925 mode
= kCGBlendModeDestinationOver
;
1927 case wxCOMPOSITION_DEST_IN
:
1928 mode
= kCGBlendModeDestinationIn
;
1930 case wxCOMPOSITION_DEST_OUT
:
1931 mode
= kCGBlendModeDestinationOut
;
1933 case wxCOMPOSITION_DEST_ATOP
:
1934 mode
= kCGBlendModeDestinationAtop
;
1936 case wxCOMPOSITION_XOR
:
1937 mode
= kCGBlendModeXOR
;
1940 case wxCOMPOSITION_ADD
:
1941 mode
= kCGBlendModePlusLighter
;
1946 CGContextSetBlendMode(m_cgContext
, mode
);
1952 void wxMacCoreGraphicsContext::BeginLayer(wxDouble opacity
)
1954 CGContextSaveGState(m_cgContext
);
1955 CGContextSetAlpha(m_cgContext
, (CGFloat
) opacity
);
1956 CGContextBeginTransparencyLayer(m_cgContext
, 0);
1959 void wxMacCoreGraphicsContext::EndLayer()
1961 CGContextEndTransparencyLayer(m_cgContext
);
1962 CGContextRestoreGState(m_cgContext
);
1965 void wxMacCoreGraphicsContext::Clip( const wxRegion
®ion
)
1967 #if wxOSX_USE_COCOA_OR_CARBON
1970 wxCFRef
<HIShapeRef
> shape
= wxCFRefFromGet(region
.GetWXHRGN());
1971 // if the shape is empty, HIShapeReplacePathInCGContext doesn't work
1972 if ( HIShapeIsEmpty(shape
))
1974 CGRect empty
= CGRectMake( 0,0,0,0 );
1975 CGContextClipToRect( m_cgContext
, empty
);
1979 HIShapeReplacePathInCGContext( shape
, m_cgContext
);
1980 CGContextClip( m_cgContext
);
1985 // this offsetting to device coords is not really correct, but since we cannot apply affine transforms
1986 // to regions we try at least to have correct translations
1987 HIMutableShapeRef mutableShape
= HIShapeCreateMutableCopy( region
.GetWXHRGN() );
1989 CGPoint transformedOrigin
= CGPointApplyAffineTransform( CGPointZero
, m_windowTransform
);
1990 HIShapeOffset( mutableShape
, transformedOrigin
.x
, transformedOrigin
.y
);
1991 m_clipRgn
.reset(mutableShape
);
1994 // allow usage as measuring context
1995 // wxASSERT_MSG( m_cgContext != NULL, "Needs a valid context for clipping" );
1999 // clips drawings to the rect
2000 void wxMacCoreGraphicsContext::Clip( wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
)
2002 CGRect r
= CGRectMake( (CGFloat
) x
, (CGFloat
) y
, (CGFloat
) w
, (CGFloat
) h
);
2005 CGContextClipToRect( m_cgContext
, r
);
2009 #if wxOSX_USE_COCOA_OR_CARBON
2010 // the clipping itself must be stored as device coordinates, otherwise
2011 // we cannot apply it back correctly
2012 r
.origin
= CGPointApplyAffineTransform( r
.origin
, m_windowTransform
);
2013 r
.size
= CGSizeApplyAffineTransform(r
.size
, m_windowTransform
);
2014 m_clipRgn
.reset(HIShapeCreateWithRect(&r
));
2016 // allow usage as measuring context
2017 // wxFAIL_MSG( "Needs a valid context for clipping" );
2022 // resets the clipping to original extent
2023 void wxMacCoreGraphicsContext::ResetClip()
2027 // there is no way for clearing the clip, we can only revert to the stored
2028 // state, but then we have to make sure everything else is NOT restored
2029 CGAffineTransform transform
= CGContextGetCTM( m_cgContext
);
2030 CGContextRestoreGState( m_cgContext
);
2031 CGContextSaveGState( m_cgContext
);
2032 CGAffineTransform transformNew
= CGContextGetCTM( m_cgContext
);
2033 transformNew
= CGAffineTransformInvert( transformNew
) ;
2034 CGContextConcatCTM( m_cgContext
, transformNew
);
2035 CGContextConcatCTM( m_cgContext
, transform
);
2039 #if wxOSX_USE_COCOA_OR_CARBON
2042 // allow usage as measuring context
2043 // wxFAIL_MSG( "Needs a valid context for clipping" );
2048 void wxMacCoreGraphicsContext::StrokePath( const wxGraphicsPath
&path
)
2050 if ( m_pen
.IsNull() )
2053 if (!EnsureIsValid())
2056 if (m_composition
== wxCOMPOSITION_DEST
)
2059 wxQuartzOffsetHelper
helper( m_cgContext
, ShouldOffset() );
2061 ((wxMacCoreGraphicsPenData
*)m_pen
.GetRefData())->Apply(this);
2062 CGContextAddPath( m_cgContext
, (CGPathRef
) path
.GetNativePath() );
2063 CGContextStrokePath( m_cgContext
);
2066 void wxMacCoreGraphicsContext::DrawPath( const wxGraphicsPath
&path
, wxPolygonFillMode fillStyle
)
2068 if (!EnsureIsValid())
2071 if (m_composition
== wxCOMPOSITION_DEST
)
2074 if ( !m_brush
.IsNull() && ((wxMacCoreGraphicsBrushData
*)m_brush
.GetRefData())->IsShading() )
2076 // when using shading, we cannot draw pen and brush at the same time
2077 // revert to the base implementation of first filling and then stroking
2078 wxGraphicsContext::DrawPath( path
, fillStyle
);
2082 CGPathDrawingMode mode
= kCGPathFill
;
2083 if ( m_brush
.IsNull() )
2085 if ( m_pen
.IsNull() )
2088 mode
= kCGPathStroke
;
2092 if ( m_pen
.IsNull() )
2094 if ( fillStyle
== wxODDEVEN_RULE
)
2095 mode
= kCGPathEOFill
;
2101 if ( fillStyle
== wxODDEVEN_RULE
)
2102 mode
= kCGPathEOFillStroke
;
2104 mode
= kCGPathFillStroke
;
2108 if ( !m_brush
.IsNull() )
2109 ((wxMacCoreGraphicsBrushData
*)m_brush
.GetRefData())->Apply(this);
2110 if ( !m_pen
.IsNull() )
2111 ((wxMacCoreGraphicsPenData
*)m_pen
.GetRefData())->Apply(this);
2113 wxQuartzOffsetHelper
helper( m_cgContext
, ShouldOffset() );
2115 CGContextAddPath( m_cgContext
, (CGPathRef
) path
.GetNativePath() );
2116 CGContextDrawPath( m_cgContext
, mode
);
2119 void wxMacCoreGraphicsContext::FillPath( const wxGraphicsPath
&path
, wxPolygonFillMode fillStyle
)
2121 if ( m_brush
.IsNull() )
2124 if (!EnsureIsValid())
2127 if (m_composition
== wxCOMPOSITION_DEST
)
2130 if ( ((wxMacCoreGraphicsBrushData
*)m_brush
.GetRefData())->IsShading() )
2132 CGContextSaveGState( m_cgContext
);
2133 CGContextAddPath( m_cgContext
, (CGPathRef
) path
.GetNativePath() );
2134 CGContextClip( m_cgContext
);
2135 CGContextDrawShading( m_cgContext
, ((wxMacCoreGraphicsBrushData
*)m_brush
.GetRefData())->GetShading() );
2136 CGContextRestoreGState( m_cgContext
);
2140 ((wxMacCoreGraphicsBrushData
*)m_brush
.GetRefData())->Apply(this);
2141 CGContextAddPath( m_cgContext
, (CGPathRef
) path
.GetNativePath() );
2142 if ( fillStyle
== wxODDEVEN_RULE
)
2143 CGContextEOFillPath( m_cgContext
);
2145 CGContextFillPath( m_cgContext
);
2149 void wxMacCoreGraphicsContext::SetNativeContext( CGContextRef cg
)
2151 // we allow either setting or clearing but not replacing
2152 wxASSERT( m_cgContext
== NULL
|| cg
== NULL
);
2156 CGContextRestoreGState( m_cgContext
);
2157 CGContextRestoreGState( m_cgContext
);
2158 if ( m_contextSynthesized
)
2160 #if wxOSX_USE_CARBON
2161 QDEndCGContext( GetWindowPort( m_windowRef
) , &m_cgContext
);
2164 wxOSXUnlockFocus(m_view
);
2168 CGContextRelease(m_cgContext
);
2173 // FIXME: This check is needed because currently we need to use a DC/GraphicsContext
2174 // in order to get font properties, like wxFont::GetPixelSize, but since we don't have
2175 // a native window attached to use, I create a wxGraphicsContext with a NULL CGContextRef
2176 // for this one operation.
2178 // When wxFont::GetPixelSize on Mac no longer needs a graphics context, this check
2182 CGContextRetain(m_cgContext
);
2183 CGContextSaveGState( m_cgContext
);
2184 CGContextSetTextMatrix( m_cgContext
, CGAffineTransformIdentity
);
2185 CGContextSaveGState( m_cgContext
);
2186 m_contextSynthesized
= false;
2190 void wxMacCoreGraphicsContext::Translate( wxDouble dx
, wxDouble dy
)
2193 CGContextTranslateCTM( m_cgContext
, (CGFloat
) dx
, (CGFloat
) dy
);
2195 m_windowTransform
= CGAffineTransformTranslate(m_windowTransform
, (CGFloat
) dx
, (CGFloat
) dy
);
2198 void wxMacCoreGraphicsContext::Scale( wxDouble xScale
, wxDouble yScale
)
2201 CGContextScaleCTM( m_cgContext
, (CGFloat
) xScale
, (CGFloat
) yScale
);
2203 m_windowTransform
= CGAffineTransformScale(m_windowTransform
, (CGFloat
) xScale
, (CGFloat
) yScale
);
2206 void wxMacCoreGraphicsContext::Rotate( wxDouble angle
)
2209 CGContextRotateCTM( m_cgContext
, (CGFloat
) angle
);
2211 m_windowTransform
= CGAffineTransformRotate(m_windowTransform
, (CGFloat
) angle
);
2214 void wxMacCoreGraphicsContext::DrawBitmap( const wxBitmap
&bmp
, wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
)
2216 wxGraphicsBitmap bitmap
= GetRenderer()->CreateBitmap(bmp
);
2217 DrawBitmap(bitmap
, x
, y
, w
, h
);
2220 void wxMacCoreGraphicsContext::DrawBitmap( const wxGraphicsBitmap
&bmp
, wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
)
2222 if (!EnsureIsValid())
2225 if (m_composition
== wxCOMPOSITION_DEST
)
2229 wxMacCoreGraphicsBitmapData
* refdata
=static_cast<wxMacCoreGraphicsBitmapData
*>(bmp
.GetRefData());
2230 CGImageRef image
= refdata
->GetBitmap();
2231 CGRect r
= CGRectMake( (CGFloat
) x
, (CGFloat
) y
, (CGFloat
) w
, (CGFloat
) h
);
2232 if ( refdata
->IsMonochrome() == 1 )
2234 // is a mask, the '1' in the mask tell where to draw the current brush
2235 if ( !m_brush
.IsNull() )
2237 if ( ((wxMacCoreGraphicsBrushData
*)m_brush
.GetRefData())->IsShading() )
2239 // TODO clip to mask
2241 CGContextSaveGState( m_cgContext );
2242 CGContextAddPath( m_cgContext , (CGPathRef) path.GetNativePath() );
2243 CGContextClip( m_cgContext );
2244 CGContextDrawShading( m_cgContext, ((wxMacCoreGraphicsBrushData*)m_brush.GetRefData())->GetShading() );
2245 CGContextRestoreGState( m_cgContext);
2250 ((wxMacCoreGraphicsBrushData
*)m_brush
.GetRefData())->Apply(this);
2251 wxMacDrawCGImage( m_cgContext
, &r
, image
);
2257 wxMacDrawCGImage( m_cgContext
, &r
, image
);
2262 void wxMacCoreGraphicsContext::DrawIcon( const wxIcon
&icon
, wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
)
2264 if (!EnsureIsValid())
2267 if (m_composition
== wxCOMPOSITION_DEST
)
2270 CGRect r
= CGRectMake( (CGFloat
) 0.0 , (CGFloat
) 0.0 , (CGFloat
) w
, (CGFloat
) h
);
2271 CGContextSaveGState( m_cgContext
);
2272 CGContextTranslateCTM( m_cgContext
,(CGFloat
) x
,(CGFloat
) (y
+ h
) );
2273 CGContextScaleCTM( m_cgContext
, 1, -1 );
2274 #if wxOSX_USE_COCOA_OR_CARBON
2275 PlotIconRefInContext( m_cgContext
, &r
, kAlignNone
, kTransformNone
,
2276 NULL
, kPlotIconRefNormalFlags
, icon
.GetHICON() );
2278 CGContextRestoreGState( m_cgContext
);
2281 void wxMacCoreGraphicsContext::PushState()
2283 if (!EnsureIsValid())
2286 CGContextSaveGState( m_cgContext
);
2289 void wxMacCoreGraphicsContext::PopState()
2291 if (!EnsureIsValid())
2294 CGContextRestoreGState( m_cgContext
);
2297 void wxMacCoreGraphicsContext::DoDrawText( const wxString
&str
, wxDouble x
, wxDouble y
)
2299 wxCHECK_RET( !m_font
.IsNull(), wxT("wxMacCoreGraphicsContext::DrawText - no valid font set") );
2301 if (!EnsureIsValid())
2304 if (m_composition
== wxCOMPOSITION_DEST
)
2307 #if wxOSX_USE_CORE_TEXT
2308 if ( UMAGetSystemVersion() >= 0x1050 )
2310 wxMacCoreGraphicsFontData
* fref
= (wxMacCoreGraphicsFontData
*)m_font
.GetRefData();
2311 wxCFStringRef
text(str
, wxLocale::GetSystemEncoding() );
2312 CTFontRef font
= fref
->OSXGetCTFont();
2313 CGColorRef col
= wxMacCreateCGColor( fref
->GetColour() );
2315 // right now there's no way to get continuous underlines, only words, so we emulate it
2316 CTUnderlineStyle ustyle
= fref
->GetUnderlined() ? kCTUnderlineStyleSingle
: kCTUnderlineStyleNone
;
2317 wxCFRef
<CFNumberRef
> underlined( CFNumberCreate(NULL
, kCFNumberSInt32Type
, &ustyle
) );
2318 CFStringRef keys
[] = { kCTFontAttributeName
, kCTForegroundColorAttributeName
, kCTUnderlineStyleAttributeName
};
2319 CFTypeRef values
[] = { font
, col
, underlined
};
2321 CFStringRef keys
[] = { kCTFontAttributeName
, kCTForegroundColorAttributeName
};
2322 CFTypeRef values
[] = { font
, col
};
2324 wxCFRef
<CFDictionaryRef
> attributes( CFDictionaryCreate(kCFAllocatorDefault
, (const void**) &keys
, (const void**) &values
,
2325 WXSIZEOF( keys
), &kCFTypeDictionaryKeyCallBacks
, &kCFTypeDictionaryValueCallBacks
) );
2326 wxCFRef
<CFAttributedStringRef
> attrtext( CFAttributedStringCreate(kCFAllocatorDefault
, text
, attributes
) );
2327 wxCFRef
<CTLineRef
> line( CTLineCreateWithAttributedString(attrtext
) );
2329 y
+= CTFontGetAscent(font
);
2331 CGContextSaveGState(m_cgContext
);
2332 CGContextTranslateCTM(m_cgContext
, (CGFloat
) x
, (CGFloat
) y
);
2333 CGContextScaleCTM(m_cgContext
, 1, -1);
2334 CGContextSetTextPosition(m_cgContext
, 0, 0);
2335 CTLineDraw( line
, m_cgContext
);
2337 if ( fref
->GetUnderlined() ) {
2338 //AKT: draw horizontal line 1 pixel thick and with 1 pixel gap under baseline
2339 CGFloat width
= CTLineGetTypographicBounds(line
, NULL
, NULL
, NULL
);
2341 CGPoint points
[] = { {0.0, -2.0}, {width
, -2.0} };
2343 CGContextSetStrokeColorWithColor(m_cgContext
, col
);
2344 CGContextSetShouldAntialias(m_cgContext
, false);
2345 CGContextSetLineWidth(m_cgContext
, 1.0);
2346 CGContextStrokeLineSegments(m_cgContext
, points
, 2);
2349 CGContextRestoreGState(m_cgContext
);
2354 #if wxOSX_USE_ATSU_TEXT
2356 DrawText(str
, x
, y
, 0.0);
2360 #if wxOSX_USE_IPHONE
2361 wxMacCoreGraphicsFontData
* fref
= (wxMacCoreGraphicsFontData
*)m_font
.GetRefData();
2363 CGContextSaveGState(m_cgContext
);
2365 CGColorRef col
= wxMacCreateCGColor( fref
->GetColour() );
2366 CGContextSetTextDrawingMode (m_cgContext
, kCGTextFill
);
2367 CGContextSetFillColorWithColor( m_cgContext
, col
);
2369 wxCFStringRef
text(str
, wxLocale::GetSystemEncoding() );
2370 DrawTextInContext( m_cgContext
, CGPointMake( x
, y
), fref
->GetUIFont() , text
.AsNSString() );
2372 CGContextRestoreGState(m_cgContext
);
2377 void wxMacCoreGraphicsContext::DoDrawRotatedText(const wxString
&str
,
2378 wxDouble x
, wxDouble y
,
2381 wxCHECK_RET( !m_font
.IsNull(), wxT("wxMacCoreGraphicsContext::DrawText - no valid font set") );
2383 if (!EnsureIsValid())
2386 if (m_composition
== wxCOMPOSITION_DEST
)
2389 #if wxOSX_USE_CORE_TEXT
2390 if ( UMAGetSystemVersion() >= 0x1050 )
2392 // default implementation takes care of rotation and calls non rotated DrawText afterwards
2393 wxGraphicsContext::DoDrawRotatedText( str
, x
, y
, angle
);
2397 #if wxOSX_USE_ATSU_TEXT
2399 OSStatus status
= noErr
;
2400 ATSUTextLayout atsuLayout
;
2401 wxMacUniCharBuffer
unibuf( str
);
2402 UniCharCount chars
= unibuf
.GetChars();
2404 ATSUStyle style
= (((wxMacCoreGraphicsFontData
*)m_font
.GetRefData())->GetATSUStyle());
2405 status
= ::ATSUCreateTextLayoutWithTextPtr( unibuf
.GetBuffer() , 0 , chars
, chars
, 1 ,
2406 &chars
, &style
, &atsuLayout
);
2408 wxASSERT_MSG( status
== noErr
, wxT("couldn't create the layout of the rotated text") );
2410 status
= ::ATSUSetTransientFontMatching( atsuLayout
, true );
2411 wxASSERT_MSG( status
== noErr
, wxT("couldn't setup transient font matching") );
2413 int iAngle
= int( angle
* RAD2DEG
);
2414 if ( abs(iAngle
) > 0 )
2416 Fixed atsuAngle
= IntToFixed( iAngle
);
2417 ATSUAttributeTag atsuTags
[] =
2419 kATSULineRotationTag
,
2421 ByteCount atsuSizes
[WXSIZEOF(atsuTags
)] =
2425 ATSUAttributeValuePtr atsuValues
[WXSIZEOF(atsuTags
)] =
2429 status
= ::ATSUSetLayoutControls(atsuLayout
, WXSIZEOF(atsuTags
),
2430 atsuTags
, atsuSizes
, atsuValues
);
2434 ATSUAttributeTag atsuTags
[] =
2438 ByteCount atsuSizes
[WXSIZEOF(atsuTags
)] =
2440 sizeof( CGContextRef
) ,
2442 ATSUAttributeValuePtr atsuValues
[WXSIZEOF(atsuTags
)] =
2446 status
= ::ATSUSetLayoutControls(atsuLayout
, WXSIZEOF(atsuTags
),
2447 atsuTags
, atsuSizes
, atsuValues
);
2450 ATSUTextMeasurement textBefore
, textAfter
;
2451 ATSUTextMeasurement ascent
, descent
;
2453 status
= ::ATSUGetUnjustifiedBounds( atsuLayout
, kATSUFromTextBeginning
, kATSUToTextEnd
,
2454 &textBefore
, &textAfter
, &ascent
, &descent
);
2456 wxASSERT_MSG( status
== noErr
, wxT("couldn't measure the rotated text") );
2459 x
+= (int)(sin(angle
) * FixedToFloat(ascent
));
2460 y
+= (int)(cos(angle
) * FixedToFloat(ascent
));
2462 status
= ::ATSUMeasureTextImage( atsuLayout
, kATSUFromTextBeginning
, kATSUToTextEnd
,
2463 IntToFixed(x
) , IntToFixed(y
) , &rect
);
2464 wxASSERT_MSG( status
== noErr
, wxT("couldn't measure the rotated text") );
2466 CGContextSaveGState(m_cgContext
);
2467 CGContextTranslateCTM(m_cgContext
, (CGFloat
) x
, (CGFloat
) y
);
2468 CGContextScaleCTM(m_cgContext
, 1, -1);
2469 status
= ::ATSUDrawText( atsuLayout
, kATSUFromTextBeginning
, kATSUToTextEnd
,
2470 IntToFixed(0) , IntToFixed(0) );
2472 wxASSERT_MSG( status
== noErr
, wxT("couldn't draw the rotated text") );
2474 CGContextRestoreGState(m_cgContext
);
2476 ::ATSUDisposeTextLayout(atsuLayout
);
2481 #if wxOSX_USE_IPHONE
2482 // default implementation takes care of rotation and calls non rotated DrawText afterwards
2483 wxGraphicsContext::DoDrawRotatedText( str
, x
, y
, angle
);
2487 void wxMacCoreGraphicsContext::GetTextExtent( const wxString
&str
, wxDouble
*width
, wxDouble
*height
,
2488 wxDouble
*descent
, wxDouble
*externalLeading
) const
2490 wxCHECK_RET( !m_font
.IsNull(), wxT("wxMacCoreGraphicsContext::GetTextExtent - no valid font set") );
2498 if ( externalLeading
)
2499 *externalLeading
= 0;
2504 #if wxOSX_USE_CORE_TEXT
2505 if ( UMAGetSystemVersion() >= 0x1050 )
2507 wxMacCoreGraphicsFontData
* fref
= (wxMacCoreGraphicsFontData
*)m_font
.GetRefData();
2508 CTFontRef font
= fref
->OSXGetCTFont();
2510 wxCFStringRef
text(str
, wxLocale::GetSystemEncoding() );
2511 CFStringRef keys
[] = { kCTFontAttributeName
};
2512 CFTypeRef values
[] = { font
};
2513 wxCFRef
<CFDictionaryRef
> attributes( CFDictionaryCreate(kCFAllocatorDefault
, (const void**) &keys
, (const void**) &values
,
2514 WXSIZEOF( keys
), &kCFTypeDictionaryKeyCallBacks
, &kCFTypeDictionaryValueCallBacks
) );
2515 wxCFRef
<CFAttributedStringRef
> attrtext( CFAttributedStringCreate(kCFAllocatorDefault
, text
, attributes
) );
2516 wxCFRef
<CTLineRef
> line( CTLineCreateWithAttributedString(attrtext
) );
2519 w
= CTLineGetTypographicBounds(line
, &a
, &d
, &l
);
2525 if ( externalLeading
)
2526 *externalLeading
= l
;
2532 #if wxOSX_USE_ATSU_TEXT
2534 OSStatus status
= noErr
;
2536 ATSUTextLayout atsuLayout
;
2537 wxMacUniCharBuffer
unibuf( str
);
2538 UniCharCount chars
= unibuf
.GetChars();
2540 ATSUStyle style
= (((wxMacCoreGraphicsFontData
*)m_font
.GetRefData())->GetATSUStyle());
2541 status
= ::ATSUCreateTextLayoutWithTextPtr( unibuf
.GetBuffer() , 0 , chars
, chars
, 1 ,
2542 &chars
, &style
, &atsuLayout
);
2544 wxASSERT_MSG( status
== noErr
, wxT("couldn't create the layout of the text") );
2546 status
= ::ATSUSetTransientFontMatching( atsuLayout
, true );
2547 wxASSERT_MSG( status
== noErr
, wxT("couldn't setup transient font matching") );
2549 ATSUTextMeasurement textBefore
, textAfter
;
2550 ATSUTextMeasurement textAscent
, textDescent
;
2552 status
= ::ATSUGetUnjustifiedBounds( atsuLayout
, kATSUFromTextBeginning
, kATSUToTextEnd
,
2553 &textBefore
, &textAfter
, &textAscent
, &textDescent
);
2556 *height
= FixedToFloat(textAscent
+ textDescent
);
2558 *descent
= FixedToFloat(textDescent
);
2559 if ( externalLeading
)
2560 *externalLeading
= 0;
2562 *width
= FixedToFloat(textAfter
- textBefore
);
2564 ::ATSUDisposeTextLayout(atsuLayout
);
2569 #if wxOSX_USE_IPHONE
2570 wxMacCoreGraphicsFontData
* fref
= (wxMacCoreGraphicsFontData
*)m_font
.GetRefData();
2572 wxCFStringRef
text(str
, wxLocale::GetSystemEncoding() );
2573 CGSize sz
= MeasureTextInContext( fref
->GetUIFont() , text
.AsNSString() );
2576 *height
= sz
.height
;
2579 *descent = FixedToFloat(textDescent);
2580 if ( externalLeading )
2581 *externalLeading = 0;
2588 void wxMacCoreGraphicsContext::GetPartialTextExtents(const wxString
& text
, wxArrayDouble
& widths
) const
2591 widths
.Add(0, text
.length());
2593 wxCHECK_RET( !m_font
.IsNull(), wxT("wxMacCoreGraphicsContext::DrawText - no valid font set") );
2598 #if wxOSX_USE_CORE_TEXT
2600 wxMacCoreGraphicsFontData
* fref
= (wxMacCoreGraphicsFontData
*)m_font
.GetRefData();
2601 CTFontRef font
= fref
->OSXGetCTFont();
2603 wxCFStringRef
t(text
, wxLocale::GetSystemEncoding() );
2604 CFStringRef keys
[] = { kCTFontAttributeName
};
2605 CFTypeRef values
[] = { font
};
2606 wxCFRef
<CFDictionaryRef
> attributes( CFDictionaryCreate(kCFAllocatorDefault
, (const void**) &keys
, (const void**) &values
,
2607 WXSIZEOF( keys
), &kCFTypeDictionaryKeyCallBacks
, &kCFTypeDictionaryValueCallBacks
) );
2608 wxCFRef
<CFAttributedStringRef
> attrtext( CFAttributedStringCreate(kCFAllocatorDefault
, t
, attributes
) );
2609 wxCFRef
<CTLineRef
> line( CTLineCreateWithAttributedString(attrtext
) );
2611 int chars
= text
.length();
2612 for ( int pos
= 0; pos
< (int)chars
; pos
++ )
2614 widths
[pos
] = CTLineGetOffsetForStringIndex( line
, pos
+1 , NULL
);
2620 #if wxOSX_USE_ATSU_TEXT
2622 OSStatus status
= noErr
;
2623 ATSUTextLayout atsuLayout
;
2624 wxMacUniCharBuffer
unibuf( text
);
2625 UniCharCount chars
= unibuf
.GetChars();
2627 ATSUStyle style
= (((wxMacCoreGraphicsFontData
*)m_font
.GetRefData())->GetATSUStyle());
2628 status
= ::ATSUCreateTextLayoutWithTextPtr( unibuf
.GetBuffer() , 0 , chars
, chars
, 1 ,
2629 &chars
, &style
, &atsuLayout
);
2631 wxASSERT_MSG( status
== noErr
, wxT("couldn't create the layout of the text") );
2633 status
= ::ATSUSetTransientFontMatching( atsuLayout
, true );
2634 wxASSERT_MSG( status
== noErr
, wxT("couldn't setup transient font matching") );
2636 // new implementation from JS, keep old one just in case
2638 for ( int pos
= 0; pos
< (int)chars
; pos
++ )
2640 unsigned long actualNumberOfBounds
= 0;
2641 ATSTrapezoid glyphBounds
;
2643 // We get a single bound, since the text should only require one. If it requires more, there is an issue
2645 result
= ATSUGetGlyphBounds( atsuLayout
, 0, 0, kATSUFromTextBeginning
, pos
+ 1,
2646 kATSUseDeviceOrigins
, 1, &glyphBounds
, &actualNumberOfBounds
);
2647 if (result
!= noErr
|| actualNumberOfBounds
!= 1 )
2650 widths
[pos
] = FixedToFloat( glyphBounds
.upperRight
.x
- glyphBounds
.upperLeft
.x
);
2651 //unsigned char uch = s[i];
2654 ATSLayoutRecord
*layoutRecords
= NULL
;
2655 ItemCount glyphCount
= 0;
2657 // Get the glyph extents
2658 OSStatus err
= ::ATSUDirectGetLayoutDataArrayPtrFromTextLayout(atsuLayout
,
2660 kATSUDirectDataLayoutRecordATSLayoutRecordCurrent
,
2664 wxASSERT(glyphCount
== (text
.length()+1));
2666 if ( err
== noErr
&& glyphCount
== (text
.length()+1))
2668 for ( int pos
= 1; pos
< (int)glyphCount
; pos
++ )
2670 widths
[pos
-1] = FixedToFloat( layoutRecords
[pos
].realPos
);
2674 ::ATSUDirectReleaseLayoutDataArrayPtr(NULL
,
2675 kATSUDirectDataLayoutRecordATSLayoutRecordCurrent
,
2676 (void **) &layoutRecords
);
2678 ::ATSUDisposeTextLayout(atsuLayout
);
2681 #if wxOSX_USE_IPHONE
2682 // TODO core graphics text implementation here
2686 void * wxMacCoreGraphicsContext::GetNativeContext()
2692 void wxMacCoreGraphicsContext::DrawRectangleX( wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
)
2694 if (m_composition
== wxCOMPOSITION_DEST
)
2697 CGRect rect
= CGRectMake( (CGFloat
) x
, (CGFloat
) y
, (CGFloat
) w
, (CGFloat
) h
);
2698 if ( !m_brush
.IsNull() )
2700 ((wxMacCoreGraphicsBrushData
*)m_brush
.GetRefData())->Apply(this);
2701 CGContextFillRect(m_cgContext
, rect
);
2704 wxQuartzOffsetHelper
helper( m_cgContext
, ShouldOffset() );
2705 if ( !m_pen
.IsNull() )
2707 ((wxMacCoreGraphicsPenData
*)m_pen
.GetRefData())->Apply(this);
2708 CGContextStrokeRect(m_cgContext
, rect
);
2712 // concatenates this transform with the current transform of this context
2713 void wxMacCoreGraphicsContext::ConcatTransform( const wxGraphicsMatrix
& matrix
)
2716 CGContextConcatCTM( m_cgContext
, *(CGAffineTransform
*) matrix
.GetNativeMatrix());
2718 m_windowTransform
= CGAffineTransformConcat(*(CGAffineTransform
*) matrix
.GetNativeMatrix(), m_windowTransform
);
2721 // sets the transform of this context
2722 void wxMacCoreGraphicsContext::SetTransform( const wxGraphicsMatrix
& matrix
)
2726 CGAffineTransform transform
= CGContextGetCTM( m_cgContext
);
2727 transform
= CGAffineTransformInvert( transform
) ;
2728 CGContextConcatCTM( m_cgContext
, transform
);
2729 CGContextConcatCTM( m_cgContext
, *(CGAffineTransform
*) matrix
.GetNativeMatrix());
2733 m_windowTransform
= *(CGAffineTransform
*) matrix
.GetNativeMatrix();
2737 // gets the matrix of this context
2738 wxGraphicsMatrix
wxMacCoreGraphicsContext::GetTransform() const
2740 wxGraphicsMatrix m
= CreateMatrix();
2741 *((CGAffineTransform
*) m
.GetNativeMatrix()) = ( m_cgContext
== NULL
? m_windowTransform
:
2742 CGContextGetCTM( m_cgContext
));
2749 // ----------------------------------------------------------------------------
2750 // wxMacCoreGraphicsImageContext
2751 // ----------------------------------------------------------------------------
2753 // This is a GC that can be used to draw on wxImage. In this implementation we
2754 // simply draw on a wxBitmap using wxMemoryDC and then convert it to wxImage in
2755 // the end so it's not especially interesting and exists mainly for
2756 // compatibility with the other platforms.
2757 class wxMacCoreGraphicsImageContext
: public wxMacCoreGraphicsContext
2760 wxMacCoreGraphicsImageContext(wxGraphicsRenderer
* renderer
,
2762 wxMacCoreGraphicsContext(renderer
),
2769 (CGContextRef
)(m_memDC
.GetGraphicsContext()->GetNativeContext())
2771 m_width
= image
.GetWidth();
2772 m_height
= image
.GetHeight();
2775 virtual ~wxMacCoreGraphicsImageContext()
2777 m_memDC
.SelectObject(wxNullBitmap
);
2778 m_image
= m_bitmap
.ConvertToImage();
2787 #endif // wxUSE_IMAGE
2793 //-----------------------------------------------------------------------------
2794 // wxMacCoreGraphicsRenderer declaration
2795 //-----------------------------------------------------------------------------
2797 class WXDLLIMPEXP_CORE wxMacCoreGraphicsRenderer
: public wxGraphicsRenderer
2800 wxMacCoreGraphicsRenderer() {}
2802 virtual ~wxMacCoreGraphicsRenderer() {}
2806 virtual wxGraphicsContext
* CreateContext( const wxWindowDC
& dc
);
2807 virtual wxGraphicsContext
* CreateContext( const wxMemoryDC
& dc
);
2808 #if wxUSE_PRINTING_ARCHITECTURE
2809 virtual wxGraphicsContext
* CreateContext( const wxPrinterDC
& dc
);
2812 virtual wxGraphicsContext
* CreateContextFromNativeContext( void * context
);
2814 virtual wxGraphicsContext
* CreateContextFromNativeWindow( void * window
);
2816 virtual wxGraphicsContext
* CreateContext( wxWindow
* window
);
2819 virtual wxGraphicsContext
* CreateContextFromImage(wxImage
& image
);
2820 #endif // wxUSE_IMAGE
2822 virtual wxGraphicsContext
* CreateMeasuringContext();
2826 virtual wxGraphicsPath
CreatePath();
2830 virtual wxGraphicsMatrix
CreateMatrix( wxDouble a
=1.0, wxDouble b
=0.0, wxDouble c
=0.0, wxDouble d
=1.0,
2831 wxDouble tx
=0.0, wxDouble ty
=0.0);
2834 virtual wxGraphicsPen
CreatePen(const wxPen
& pen
) ;
2836 virtual wxGraphicsBrush
CreateBrush(const wxBrush
& brush
) ;
2838 virtual wxGraphicsBrush
2839 CreateLinearGradientBrush(wxDouble x1
, wxDouble y1
,
2840 wxDouble x2
, wxDouble y2
,
2841 const wxGraphicsGradientStops
& stops
);
2843 virtual wxGraphicsBrush
2844 CreateRadialGradientBrush(wxDouble xo
, wxDouble yo
,
2845 wxDouble xc
, wxDouble yc
,
2847 const wxGraphicsGradientStops
& stops
);
2850 virtual wxGraphicsFont
CreateFont( const wxFont
&font
, const wxColour
&col
= *wxBLACK
) ;
2851 virtual wxGraphicsFont
CreateFont(double sizeInPixels
,
2852 const wxString
& facename
,
2853 int flags
= wxFONTFLAG_DEFAULT
,
2854 const wxColour
& col
= *wxBLACK
);
2856 // create a native bitmap representation
2857 virtual wxGraphicsBitmap
CreateBitmap( const wxBitmap
&bitmap
) ;
2860 virtual wxGraphicsBitmap
CreateBitmapFromImage(const wxImage
& image
);
2861 #endif // wxUSE_IMAGE
2863 // create a graphics bitmap from a native bitmap
2864 virtual wxGraphicsBitmap
CreateBitmapFromNativeBitmap( void* bitmap
);
2866 // create a native bitmap representation
2867 virtual wxGraphicsBitmap
CreateSubBitmap( const wxGraphicsBitmap
&bitmap
, wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
) ;
2869 DECLARE_DYNAMIC_CLASS_NO_COPY(wxMacCoreGraphicsRenderer
)
2872 //-----------------------------------------------------------------------------
2873 // wxMacCoreGraphicsRenderer implementation
2874 //-----------------------------------------------------------------------------
2876 IMPLEMENT_DYNAMIC_CLASS(wxMacCoreGraphicsRenderer
,wxGraphicsRenderer
)
2878 static wxMacCoreGraphicsRenderer gs_MacCoreGraphicsRenderer
;
2880 wxGraphicsRenderer
* wxGraphicsRenderer::GetDefaultRenderer()
2882 return &gs_MacCoreGraphicsRenderer
;
2885 wxGraphicsContext
* wxMacCoreGraphicsRenderer::CreateContext( const wxWindowDC
& dc
)
2887 const wxDCImpl
* impl
= dc
.GetImpl();
2888 wxWindowDCImpl
*win_impl
= wxDynamicCast( impl
, wxWindowDCImpl
);
2892 win_impl
->GetSize( &w
, &h
);
2893 CGContextRef cgctx
= 0;
2895 wxASSERT_MSG(win_impl
->GetWindow(), "Invalid wxWindow in wxMacCoreGraphicsRenderer::CreateContext");
2896 if (win_impl
->GetWindow())
2897 cgctx
= (CGContextRef
)(win_impl
->GetWindow()->MacGetCGContextRef());
2899 // having a cgctx being NULL is fine (will be created on demand)
2900 // this is the case for all wxWindowDCs except wxPaintDC
2901 wxMacCoreGraphicsContext
*context
=
2902 new wxMacCoreGraphicsContext( this, cgctx
, (wxDouble
) w
, (wxDouble
) h
);
2903 context
->EnableOffset(true);
2909 wxGraphicsContext
* wxMacCoreGraphicsRenderer::CreateContext( const wxMemoryDC
& dc
)
2912 const wxDCImpl
* impl
= dc
.GetImpl();
2913 wxMemoryDCImpl
*mem_impl
= wxDynamicCast( impl
, wxMemoryDCImpl
);
2917 mem_impl
->GetSize( &w
, &h
);
2918 wxMacCoreGraphicsContext
* context
= new wxMacCoreGraphicsContext( this,
2919 (CGContextRef
)(mem_impl
->GetGraphicsContext()->GetNativeContext()), (wxDouble
) w
, (wxDouble
) h
);
2920 context
->EnableOffset(true);
2927 #if wxUSE_PRINTING_ARCHITECTURE
2928 wxGraphicsContext
* wxMacCoreGraphicsRenderer::CreateContext( const wxPrinterDC
& dc
)
2931 const wxDCImpl
* impl
= dc
.GetImpl();
2932 wxPrinterDCImpl
*print_impl
= wxDynamicCast( impl
, wxPrinterDCImpl
);
2936 print_impl
->GetSize( &w
, &h
);
2937 return new wxMacCoreGraphicsContext( this,
2938 (CGContextRef
)(print_impl
->GetGraphicsContext()->GetNativeContext()), (wxDouble
) w
, (wxDouble
) h
);
2945 wxGraphicsContext
* wxMacCoreGraphicsRenderer::CreateContextFromNativeContext( void * context
)
2947 return new wxMacCoreGraphicsContext(this,(CGContextRef
)context
);
2950 wxGraphicsContext
* wxMacCoreGraphicsRenderer::CreateContextFromNativeWindow( void * window
)
2952 #if wxOSX_USE_CARBON
2953 wxMacCoreGraphicsContext
* context
= new wxMacCoreGraphicsContext(this,(WindowRef
)window
);
2954 context
->EnableOffset(true);
2957 wxUnusedVar(window
);
2962 wxGraphicsContext
* wxMacCoreGraphicsRenderer::CreateContext( wxWindow
* window
)
2964 return new wxMacCoreGraphicsContext(this, window
);
2967 wxGraphicsContext
* wxMacCoreGraphicsRenderer::CreateMeasuringContext()
2969 return new wxMacCoreGraphicsContext(this);
2975 wxMacCoreGraphicsRenderer::CreateContextFromImage(wxImage
& image
)
2977 return new wxMacCoreGraphicsImageContext(this, image
);
2980 #endif // wxUSE_IMAGE
2984 wxGraphicsPath
wxMacCoreGraphicsRenderer::CreatePath()
2987 m
.SetRefData( new wxMacCoreGraphicsPathData(this));
2994 wxGraphicsMatrix
wxMacCoreGraphicsRenderer::CreateMatrix( wxDouble a
, wxDouble b
, wxDouble c
, wxDouble d
,
2995 wxDouble tx
, wxDouble ty
)
2998 wxMacCoreGraphicsMatrixData
* data
= new wxMacCoreGraphicsMatrixData( this );
2999 data
->Set( a
,b
,c
,d
,tx
,ty
) ;
3004 wxGraphicsPen
wxMacCoreGraphicsRenderer::CreatePen(const wxPen
& pen
)
3006 if ( !pen
.IsOk() || pen
.GetStyle() == wxTRANSPARENT
)
3007 return wxNullGraphicsPen
;
3011 p
.SetRefData(new wxMacCoreGraphicsPenData( this, pen
));
3016 wxGraphicsBrush
wxMacCoreGraphicsRenderer::CreateBrush(const wxBrush
& brush
)
3018 if ( !brush
.IsOk() || brush
.GetStyle() == wxTRANSPARENT
)
3019 return wxNullGraphicsBrush
;
3023 p
.SetRefData(new wxMacCoreGraphicsBrushData( this, brush
));
3028 wxGraphicsBitmap
wxMacCoreGraphicsRenderer::CreateBitmap( const wxBitmap
& bmp
)
3033 p
.SetRefData(new wxMacCoreGraphicsBitmapData( this , bmp
.CreateCGImage(), bmp
.GetDepth() == 1 ) );
3037 return wxNullGraphicsBitmap
;
3043 wxMacCoreGraphicsRenderer::CreateBitmapFromImage(const wxImage
& image
)
3045 // We don't have any direct way to convert wxImage to CGImage so pass by
3046 // wxBitmap. This makes this function pretty useless in this implementation
3047 // but it allows to have the same API as with Cairo backend where we can
3048 // convert wxImage to a Cairo surface directly, bypassing wxBitmap.
3049 return CreateBitmap(wxBitmap(image
));
3052 #endif // wxUSE_IMAGE
3054 wxGraphicsBitmap
wxMacCoreGraphicsRenderer::CreateBitmapFromNativeBitmap( void* bitmap
)
3056 if ( bitmap
!= NULL
)
3059 p
.SetRefData(new wxMacCoreGraphicsBitmapData( this , (CGImageRef
) bitmap
, false ));
3063 return wxNullGraphicsBitmap
;
3066 wxGraphicsBitmap
wxMacCoreGraphicsRenderer::CreateSubBitmap( const wxGraphicsBitmap
&bmp
, wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
)
3068 wxMacCoreGraphicsBitmapData
* refdata
=static_cast<wxMacCoreGraphicsBitmapData
*>(bmp
.GetRefData());
3069 CGImageRef img
= refdata
->GetBitmap();
3073 CGImageRef subimg
= CGImageCreateWithImageInRect(img
,CGRectMake( (CGFloat
) x
, (CGFloat
) y
, (CGFloat
) w
, (CGFloat
) h
));
3074 p
.SetRefData(new wxMacCoreGraphicsBitmapData( this , subimg
, refdata
->IsMonochrome() ) );
3078 return wxNullGraphicsBitmap
;
3082 wxMacCoreGraphicsRenderer::CreateLinearGradientBrush(wxDouble x1
, wxDouble y1
,
3083 wxDouble x2
, wxDouble y2
,
3084 const wxGraphicsGradientStops
& stops
)
3087 wxMacCoreGraphicsBrushData
* d
= new wxMacCoreGraphicsBrushData( this );
3088 d
->CreateLinearGradientBrush(x1
, y1
, x2
, y2
, stops
);
3094 wxMacCoreGraphicsRenderer::CreateRadialGradientBrush(wxDouble xo
, wxDouble yo
,
3095 wxDouble xc
, wxDouble yc
,
3097 const wxGraphicsGradientStops
& stops
)
3100 wxMacCoreGraphicsBrushData
* d
= new wxMacCoreGraphicsBrushData( this );
3101 d
->CreateRadialGradientBrush(xo
, yo
, xc
, yc
, radius
, stops
);
3106 wxGraphicsFont
wxMacCoreGraphicsRenderer::CreateFont( const wxFont
&font
, const wxColour
&col
)
3111 p
.SetRefData(new wxMacCoreGraphicsFontData( this , font
, col
));
3115 return wxNullGraphicsFont
;
3119 wxMacCoreGraphicsRenderer::CreateFont(double sizeInPixels
,
3120 const wxString
& facename
,
3122 const wxColour
& col
)
3124 // This implementation is not ideal as we don't support fractional font
3125 // sizes right now, but it's the simplest one.
3127 // Notice that under Mac we always use 72 DPI so the font size in pixels is
3128 // the same as the font size in points and we can pass it directly to wxFont
3130 wxFont
font(wxRound(sizeInPixels
),
3131 wxFONTFAMILY_DEFAULT
,
3132 flags
& wxFONTFLAG_ITALIC
? wxFONTSTYLE_ITALIC
3133 : wxFONTSTYLE_NORMAL
,
3134 flags
& wxFONTFLAG_BOLD
? wxFONTWEIGHT_BOLD
3135 : wxFONTWEIGHT_NORMAL
,
3136 (flags
& wxFONTFLAG_UNDERLINED
) != 0,
3140 f
.SetRefData(new wxMacCoreGraphicsFontData(this, font
, col
));
3145 // CoreGraphics Helper Methods
3148 // Data Providers and Consumers
3150 size_t UMAPutBytesCFRefCallback( void *info
, const void *bytes
, size_t count
)
3152 CFMutableDataRef data
= (CFMutableDataRef
) info
;
3155 CFDataAppendBytes( data
, (const UInt8
*) bytes
, count
);
3160 void wxMacReleaseCFDataProviderCallback(void *info
,
3161 const void *WXUNUSED(data
),
3162 size_t WXUNUSED(count
))
3165 CFRelease( (CFDataRef
) info
);
3168 void wxMacReleaseCFDataConsumerCallback( void *info
)
3171 CFRelease( (CFDataRef
) info
);
3174 CGDataProviderRef
wxMacCGDataProviderCreateWithCFData( CFDataRef data
)
3179 return CGDataProviderCreateWithCFData( data
);
3182 CGDataConsumerRef
wxMacCGDataConsumerCreateWithCFData( CFMutableDataRef data
)
3187 return CGDataConsumerCreateWithCFData( data
);
3191 wxMacReleaseMemoryBufferProviderCallback(void *info
,
3192 const void * WXUNUSED_UNLESS_DEBUG(data
),
3193 size_t WXUNUSED(size
))
3195 wxMemoryBuffer
* membuf
= (wxMemoryBuffer
*) info
;
3197 wxASSERT( data
== membuf
->GetData() ) ;
3202 CGDataProviderRef
wxMacCGDataProviderCreateWithMemoryBuffer( const wxMemoryBuffer
& buf
)
3204 wxMemoryBuffer
* b
= new wxMemoryBuffer( buf
);
3205 if ( b
->GetDataLen() == 0 )
3208 return CGDataProviderCreateWithData( b
, (const void *) b
->GetData() , b
->GetDataLen() ,
3209 wxMacReleaseMemoryBufferProviderCallback
);