+ // gets the last point of the current path, (0,0) if not yet set
+ virtual void GetCurrentPoint( wxDouble* x, wxDouble* y) const;
+
+ // adds an arc of a circle centering at (x,y) with radius (r) from startAngle to endAngle
+ virtual void AddArc( wxDouble x, wxDouble y, wxDouble r, wxDouble startAngle, wxDouble endAngle, bool clockwise );
+
+ //
+ // These are convenience functions which - if not available natively will be assembled
+ // using the primitives from above
+ //
+
+ // adds a quadratic Bezier curve from the current point, using a control point and an end point
+ virtual void AddQuadCurveToPoint( wxDouble cx, wxDouble cy, wxDouble x, wxDouble y );
+
+ // appends a rectangle as a new closed subpath
+ virtual void AddRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h );
+
+ // appends an ellipsis as a new closed subpath fitting the passed rectangle
+ virtual void AddCircle( wxDouble x, wxDouble y, wxDouble r );
+
+ // 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)
+ virtual void AddArcToPoint( wxDouble x1, wxDouble y1 , wxDouble x2, wxDouble y2, wxDouble r );
+
+ // adds another path
+ virtual void AddPath( const wxGraphicsPathData* path );
+
+ // returns the native path
+ virtual void * GetNativePath() const { return m_path; }
+
+ // give the native path returned by GetNativePath() back (there might be some deallocations necessary)
+ virtual void UnGetNativePath(void *WXUNUSED(p)) const {}
+
+ // transforms each point of this path by the matrix
+ virtual void Transform( const wxGraphicsMatrixData* matrix );
+
+ // gets the bounding box enclosing all points (possibly including control points)
+ virtual void GetBox(wxDouble *x, wxDouble *y, wxDouble *w, wxDouble *y) const;
+
+ virtual bool Contains( wxDouble x, wxDouble y, int fillStyle = wxODDEVEN_RULE) const;
+private :
+ CGMutablePathRef m_path;
+};
+
+//-----------------------------------------------------------------------------
+// wxMacCoreGraphicsPath implementation
+//-----------------------------------------------------------------------------
+
+wxMacCoreGraphicsPathData::wxMacCoreGraphicsPathData( wxGraphicsRenderer* renderer, CGMutablePathRef path) : wxGraphicsPathData(renderer)
+{
+ if ( path )
+ m_path = path;
+ else
+ m_path = CGPathCreateMutable();
+}
+
+wxMacCoreGraphicsPathData::~wxMacCoreGraphicsPathData()
+{
+ CGPathRelease( m_path );
+}
+
+wxGraphicsObjectRefData* wxMacCoreGraphicsPathData::Clone() const
+{
+ wxMacCoreGraphicsPathData* clone = new wxMacCoreGraphicsPathData(GetRenderer(),CGPathCreateMutableCopy(m_path));
+ return clone ;
+}
+
+
+// opens (starts) a new subpath
+void wxMacCoreGraphicsPathData::MoveToPoint( wxDouble x1 , wxDouble y1 )
+{
+ CGPathMoveToPoint( m_path , NULL , x1 , y1 );
+}
+
+void wxMacCoreGraphicsPathData::AddLineToPoint( wxDouble x1 , wxDouble y1 )
+{
+ CGPathAddLineToPoint( m_path , NULL , x1 , y1 );
+}
+
+void wxMacCoreGraphicsPathData::AddCurveToPoint( wxDouble cx1, wxDouble cy1, wxDouble cx2, wxDouble cy2, wxDouble x, wxDouble y )
+{
+ CGPathAddCurveToPoint( m_path , NULL , cx1 , cy1 , cx2, cy2, x , y );
+}
+
+void wxMacCoreGraphicsPathData::AddQuadCurveToPoint( wxDouble cx1, wxDouble cy1, wxDouble x, wxDouble y )
+{
+ CGPathAddQuadCurveToPoint( m_path , NULL , cx1 , cy1 , x , y );
+}
+
+void wxMacCoreGraphicsPathData::AddRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h )
+{
+ CGRect cgRect = { { x , y } , { w , h } };
+ CGPathAddRect( m_path , NULL , cgRect );
+}
+
+void wxMacCoreGraphicsPathData::AddCircle( wxDouble x, wxDouble y , wxDouble r )
+{
+ CGPathAddArc( m_path , NULL , x , y , r , 0.0 , 2 * M_PI , true );
+}
+
+// adds an arc of a circle centering at (x,y) with radius (r) from startAngle to endAngle
+void wxMacCoreGraphicsPathData::AddArc( wxDouble x, wxDouble y, wxDouble r, wxDouble startAngle, wxDouble endAngle, bool clockwise )
+{
+ // inverse direction as we the 'normal' state is a y axis pointing down, ie mirrored to the standard core graphics setup
+ CGPathAddArc( m_path, NULL , x, y, r, startAngle, endAngle, !clockwise);
+}
+
+void wxMacCoreGraphicsPathData::AddArcToPoint( wxDouble x1, wxDouble y1 , wxDouble x2, wxDouble y2, wxDouble r )
+{
+ CGPathAddArcToPoint( m_path, NULL , x1, y1, x2, y2, r);
+}
+
+void wxMacCoreGraphicsPathData::AddPath( const wxGraphicsPathData* path )
+{
+ CGPathAddPath( m_path , NULL, (CGPathRef) path->GetNativePath() );
+}
+
+// closes the current subpath
+void wxMacCoreGraphicsPathData::CloseSubpath()
+{
+ CGPathCloseSubpath( m_path );
+}
+
+// gets the last point of the current path, (0,0) if not yet set
+void wxMacCoreGraphicsPathData::GetCurrentPoint( wxDouble* x, wxDouble* y) const
+{
+ CGPoint p = CGPathGetCurrentPoint( m_path );
+ *x = p.x;
+ *y = p.y;
+}
+
+// transforms each point of this path by the matrix
+void wxMacCoreGraphicsPathData::Transform( const wxGraphicsMatrixData* matrix )
+{
+ CGMutablePathRef p = CGPathCreateMutable() ;
+ CGPathAddPath( p, (CGAffineTransform*) matrix->GetNativeMatrix() , m_path );
+ CGPathRelease( m_path );
+ m_path = p;
+}
+
+// gets the bounding box enclosing all points (possibly including control points)
+void wxMacCoreGraphicsPathData::GetBox(wxDouble *x, wxDouble *y, wxDouble *w, wxDouble *h) const
+{
+ CGRect bounds = CGPathGetBoundingBox( m_path ) ;
+ *x = bounds.origin.x;
+ *y = bounds.origin.y;
+ *w = bounds.size.width;
+ *h = bounds.size.height;
+}
+
+bool wxMacCoreGraphicsPathData::Contains( wxDouble x, wxDouble y, int fillStyle) const
+{
+ return CGPathContainsPoint( m_path, NULL, CGPointMake(x,y), fillStyle == wxODDEVEN_RULE );
+}
+
+//
+// Graphics Context
+//
+
+//-----------------------------------------------------------------------------
+// wxMacCoreGraphicsContext declaration
+//-----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxMacCoreGraphicsContext : public wxGraphicsContext
+{
+public:
+ wxMacCoreGraphicsContext( wxGraphicsRenderer* renderer, CGContextRef cgcontext, wxDouble width = 0, wxDouble height = 0 );
+
+ wxMacCoreGraphicsContext( wxGraphicsRenderer* renderer, WindowRef window );
+
+ wxMacCoreGraphicsContext( wxGraphicsRenderer* renderer, wxWindow* window );
+
+ wxMacCoreGraphicsContext( wxGraphicsRenderer* renderer);
+
+ wxMacCoreGraphicsContext();
+
+ ~wxMacCoreGraphicsContext();
+
+ void Init();
+
+ // returns the size of the graphics context in device coordinates
+ virtual void GetSize( wxDouble* width, wxDouble* height);
+
+ virtual void StartPage( wxDouble width, wxDouble height );
+
+ virtual void EndPage();
+
+ virtual void Flush();
+
+ // push the current state of the context, ie the transformation matrix on a stack
+ virtual void PushState();
+
+ // pops a stored state from the stack
+ virtual void PopState();
+
+ // clips drawings to the region
+ virtual void Clip( const wxRegion ®ion );
+
+ // clips drawings to the rect
+ virtual void Clip( wxDouble x, wxDouble y, wxDouble w, wxDouble h );
+
+ // resets the clipping to original extent
+ virtual void ResetClip();
+
+ virtual void * GetNativeContext();
+
+ bool SetLogicalFunction( int function );
+ //
+ // transformation
+ //
+
+ // translate
+ virtual void Translate( wxDouble dx , wxDouble dy );
+
+ // scale
+ virtual void Scale( wxDouble xScale , wxDouble yScale );
+
+ // rotate (radians)
+ virtual void Rotate( wxDouble angle );
+
+ // concatenates this transform with the current transform of this context
+ virtual void ConcatTransform( const wxGraphicsMatrix& matrix );
+
+ // sets the transform of this context
+ virtual void SetTransform( const wxGraphicsMatrix& matrix );
+
+ // gets the matrix of this context
+ virtual wxGraphicsMatrix GetTransform() const;
+ //
+ // setting the paint
+ //
+
+ // strokes along a path with the current pen
+ virtual void StrokePath( const wxGraphicsPath &path );
+
+ // fills a path with the current brush
+ virtual void FillPath( const wxGraphicsPath &path, int fillStyle = wxODDEVEN_RULE );
+
+ // draws a path by first filling and then stroking
+ virtual void DrawPath( const wxGraphicsPath &path, int fillStyle = wxODDEVEN_RULE );
+
+ virtual bool ShouldOffset() const
+ {
+ int penwidth = 0 ;
+ if ( !m_pen.IsNull() )
+ {
+ penwidth = (int)((wxMacCoreGraphicsPenData*)m_pen.GetRefData())->GetWidth();
+ if ( penwidth == 0 )
+ penwidth = 1;
+ }
+ return ( penwidth % 2 ) == 1;
+ }
+ //
+ // text
+ //
+
+ virtual void DrawText( const wxString &str, wxDouble x, wxDouble y );
+
+ virtual void DrawText( const wxString &str, wxDouble x, wxDouble y, wxDouble angle );
+
+ virtual void GetTextExtent( const wxString &text, wxDouble *width, wxDouble *height,
+ wxDouble *descent, wxDouble *externalLeading ) const;
+
+ virtual void GetPartialTextExtents(const wxString& text, wxArrayDouble& widths) const;
+
+ //
+ // image support
+ //
+
+ virtual void DrawBitmap( const wxBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h );
+
+ virtual void DrawIcon( const wxIcon &icon, wxDouble x, wxDouble y, wxDouble w, wxDouble h );
+
+ void SetNativeContext( CGContextRef cg );
+
+ DECLARE_NO_COPY_CLASS(wxMacCoreGraphicsContext)
+ DECLARE_DYNAMIC_CLASS(wxMacCoreGraphicsContext)
+
+private:
+ void EnsureIsValid();
+
+ CGContextRef m_cgContext;
+ WindowRef m_windowRef;
+ bool m_releaseContext;
+ CGAffineTransform m_windowTransform;
+ wxDouble m_width;
+ wxDouble m_height;
+
+ wxMacCFRefHolder<HIShapeRef> m_clipRgn;
+};
+
+//-----------------------------------------------------------------------------
+// device context implementation
+//
+// more and more of the dc functionality should be implemented by calling
+// the appropricate wxMacCoreGraphicsContext, but we will have to do that step by step
+// also coordinate conversions should be moved to native matrix ops
+//-----------------------------------------------------------------------------
+
+// we always stock two context states, one at entry, to be able to preserve the
+// state we were called with, the other one after changing to HI Graphics orientation
+// (this one is used for getting back clippings etc)
+
+//-----------------------------------------------------------------------------
+// wxMacCoreGraphicsContext implementation
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_DYNAMIC_CLASS(wxMacCoreGraphicsContext, wxGraphicsContext)
+
+class wxQuartzOffsetHelper
+{
+public :
+ wxQuartzOffsetHelper( CGContextRef cg , bool offset )
+ {
+ m_cg = cg;
+ m_offset = offset;
+ if ( m_offset )
+ CGContextTranslateCTM( m_cg, 0.5, 0.5 );
+ }
+ ~wxQuartzOffsetHelper( )
+ {
+ if ( m_offset )
+ CGContextTranslateCTM( m_cg, -0.5, -0.5 );
+ }
+public :
+ CGContextRef m_cg;
+ bool m_offset;
+} ;
+
+void wxMacCoreGraphicsContext::Init()
+{
+ m_cgContext = NULL;
+ m_releaseContext = false;
+ m_windowRef = NULL;
+ m_width = 0;
+ m_height = 0;
+
+ HIRect r = CGRectMake(0,0,0,0);
+ m_clipRgn.Set(HIShapeCreateWithRect(&r));
+}
+
+wxMacCoreGraphicsContext::wxMacCoreGraphicsContext( wxGraphicsRenderer* renderer, CGContextRef cgcontext, wxDouble width, wxDouble height ) : wxGraphicsContext(renderer)
+{
+ Init();
+ SetNativeContext(cgcontext);
+ m_width = width;
+ m_height = height;
+}
+
+wxMacCoreGraphicsContext::wxMacCoreGraphicsContext( wxGraphicsRenderer* renderer, WindowRef window ): wxGraphicsContext(renderer)
+{
+ Init();
+ m_windowRef = window;
+}
+
+wxMacCoreGraphicsContext::wxMacCoreGraphicsContext( wxGraphicsRenderer* renderer, wxWindow* window ): wxGraphicsContext(renderer)
+{
+ Init();
+ m_windowRef = (WindowRef) window->MacGetTopLevelWindowRef();
+ int originX , originY;
+ originX = originY = 0;
+ window->MacWindowToRootWindow( &originX , &originY );
+
+ Rect bounds = { 0,0,0,0 };
+#ifdef __LP64__
+#else
+ GetWindowBounds( m_windowRef, kWindowContentRgn, &bounds );
+#endif
+ m_windowTransform = CGAffineTransformMakeTranslation( 0 , bounds.bottom - bounds.top );
+ m_windowTransform = CGAffineTransformScale( m_windowTransform , 1 , -1 );
+ m_windowTransform = CGAffineTransformTranslate( m_windowTransform, originX, originY ) ;
+}
+
+wxMacCoreGraphicsContext::wxMacCoreGraphicsContext(wxGraphicsRenderer* renderer) : wxGraphicsContext(renderer)
+{
+ Init();
+}
+
+wxMacCoreGraphicsContext::wxMacCoreGraphicsContext() : wxGraphicsContext(NULL)
+{
+ Init();
+ wxLogDebug(wxT("Illegal Constructor called"));
+}
+
+wxMacCoreGraphicsContext::~wxMacCoreGraphicsContext()
+{
+ SetNativeContext(NULL);
+}
+
+void wxMacCoreGraphicsContext::GetSize( wxDouble* width, wxDouble* height)
+{
+ *width = m_width;
+ *height = m_height;
+}
+
+
+void wxMacCoreGraphicsContext::StartPage( wxDouble width, wxDouble height )
+{
+ CGRect r;
+ if ( width != 0 && height != 0)
+ r = CGRectMake( 0 , 0 , width , height );
+ else
+ r = CGRectMake( 0 , 0 , m_width , m_height );
+
+ CGContextBeginPage(m_cgContext, &r );
+// CGContextTranslateCTM( m_cgContext , 0 , height == 0 ? m_height : height );
+// CGContextScaleCTM( m_cgContext , 1 , -1 );
+}
+
+void wxMacCoreGraphicsContext::EndPage()
+{
+ CGContextEndPage(m_cgContext);
+}
+
+void wxMacCoreGraphicsContext::Flush()
+{
+ CGContextFlush(m_cgContext);
+}
+
+void wxMacCoreGraphicsContext::EnsureIsValid()
+{
+ if ( !m_cgContext )
+ {
+ OSStatus status =
+#ifndef __LP64__
+ QDBeginCGContext( GetWindowPort( m_windowRef ) , &m_cgContext );
+#else
+ paramErr;
+#endif
+ wxASSERT_MSG( status == noErr , wxT("Cannot nest wxDCs on the same window") );
+
+ CGContextConcatCTM( m_cgContext, m_windowTransform );
+ CGContextSaveGState( m_cgContext );
+ m_releaseContext = true;
+ if ( !HIShapeIsEmpty(m_clipRgn) )
+ {
+ // the clip region is in device coordinates, so we convert this again to user coordinates
+ wxMacCFRefHolder<HIMutableShapeRef> hishape ;
+ hishape.Set( HIShapeCreateMutableCopy( m_clipRgn ) );
+ CGPoint transformedOrigin = CGPointApplyAffineTransform( CGPointZero,m_windowTransform);
+ HIShapeOffset( hishape, -transformedOrigin.x, -transformedOrigin.y );
+ HIShapeReplacePathInCGContext( hishape, m_cgContext );
+ CGContextClip( m_cgContext );
+ }
+ CGContextSaveGState( m_cgContext );
+ }
+}
+
+// TODO test whether the private CGContextSetCompositeOperation works under 10.3 (using NSCompositingModes)
+
+bool wxMacCoreGraphicsContext::SetLogicalFunction( int function )
+{
+ if (m_logicalFunction == function)
+ return true;
+
+ EnsureIsValid();
+
+ bool retval = false;
+
+ if ( function == wxCOPY )
+ {
+ retval = true;
+ CGContextSetBlendMode( m_cgContext, kCGBlendModeNormal );
+ }
+ else if ( function == wxINVERT || function == wxXOR )
+ {
+ // change color to white
+ CGContextSetBlendMode( m_cgContext, kCGBlendModeExclusion );
+ CGContextSetShouldAntialias( m_cgContext, false );
+ retval = true;
+ }
+
+ if (retval)
+ m_logicalFunction = function;
+ return retval ;
+}
+
+void wxMacCoreGraphicsContext::Clip( const wxRegion ®ion )
+{
+ if( m_cgContext )
+ {
+ HIShapeReplacePathInCGContext( region.GetWXHRGN() , m_cgContext );
+ CGContextClip( m_cgContext );
+ }
+ else
+ {
+ // this offsetting to device coords is not really correct, but since we cannot apply affine transforms
+ // to regions we try at least to have correct translations
+ HIMutableShapeRef mutableShape = HIShapeCreateMutableCopy( region.GetWXHRGN() );
+
+ CGPoint transformedOrigin = CGPointApplyAffineTransform( CGPointZero, m_windowTransform );
+ HIShapeOffset( mutableShape, transformedOrigin.x, transformedOrigin.y );
+ m_clipRgn.Set(mutableShape);
+ }
+}
+
+// clips drawings to the rect
+void wxMacCoreGraphicsContext::Clip( wxDouble x, wxDouble y, wxDouble w, wxDouble h )
+{
+ HIRect r = CGRectMake( x , y , w , h );
+ if ( m_cgContext )
+ {
+ CGContextClipToRect( m_cgContext, r );
+ }
+ else
+ {
+ // the clipping itself must be stored as device coordinates, otherwise
+ // we cannot apply it back correctly
+ r.origin= CGPointApplyAffineTransform( r.origin, m_windowTransform );
+ m_clipRgn.Set(HIShapeCreateWithRect(&r));
+ }
+}
+
+ // resets the clipping to original extent
+void wxMacCoreGraphicsContext::ResetClip()
+{
+ if ( m_cgContext )
+ {
+ // there is no way for clearing the clip, we can only revert to the stored
+ // state, but then we have to make sure everything else is NOT restored
+ CGAffineTransform transform = CGContextGetCTM( m_cgContext );
+ CGContextRestoreGState( m_cgContext );
+ CGContextSaveGState( m_cgContext );
+ CGAffineTransform transformNew = CGContextGetCTM( m_cgContext );
+ transformNew = CGAffineTransformInvert( transformNew ) ;
+ CGContextConcatCTM( m_cgContext, transformNew);
+ CGContextConcatCTM( m_cgContext, transform);
+ }
+ else
+ {
+ HIRect r = CGRectMake(0,0,0,0);
+ m_clipRgn.Set(HIShapeCreateWithRect(&r));
+ }
+}
+
+void wxMacCoreGraphicsContext::StrokePath( const wxGraphicsPath &path )
+{
+ if ( m_pen.IsNull() )
+ return ;
+
+ EnsureIsValid();
+
+ wxQuartzOffsetHelper helper( m_cgContext , ShouldOffset() );
+
+ ((wxMacCoreGraphicsPenData*)m_pen.GetRefData())->Apply(this);
+ CGContextAddPath( m_cgContext , (CGPathRef) path.GetNativePath() );
+ CGContextStrokePath( m_cgContext );
+}
+
+void wxMacCoreGraphicsContext::DrawPath( const wxGraphicsPath &path , int fillStyle )
+{
+ if ( !m_brush.IsNull() && ((wxMacCoreGraphicsBrushData*)m_brush.GetRefData())->IsShading() )
+ {
+ // when using shading, we cannot draw pen and brush at the same time
+ // revert to the base implementation of first filling and then stroking
+ wxGraphicsContext::DrawPath( path, fillStyle );
+ return;
+ }
+
+ CGPathDrawingMode mode = kCGPathFill ;
+ if ( m_brush.IsNull() )
+ {
+ if ( m_pen.IsNull() )
+ return;
+ else
+ mode = kCGPathStroke;
+ }
+ else
+ {
+ if ( m_pen.IsNull() )
+ {
+ if ( fillStyle == wxODDEVEN_RULE )
+ mode = kCGPathEOFill;
+ else
+ mode = kCGPathFill;
+ }
+ else
+ {
+ if ( fillStyle == wxODDEVEN_RULE )
+ mode = kCGPathEOFillStroke;
+ else
+ mode = kCGPathFillStroke;
+ }
+ }
+
+ EnsureIsValid();
+
+ if ( !m_brush.IsNull() )
+ ((wxMacCoreGraphicsBrushData*)m_brush.GetRefData())->Apply(this);
+ if ( !m_pen.IsNull() )
+ ((wxMacCoreGraphicsPenData*)m_pen.GetRefData())->Apply(this);
+
+ wxQuartzOffsetHelper helper( m_cgContext , ShouldOffset() );
+
+ CGContextAddPath( m_cgContext , (CGPathRef) path.GetNativePath() );
+ CGContextDrawPath( m_cgContext , mode );
+}
+
+void wxMacCoreGraphicsContext::FillPath( const wxGraphicsPath &path , int fillStyle )
+{
+ if ( m_brush.IsNull() )
+ return;
+
+ EnsureIsValid();
+
+ if ( ((wxMacCoreGraphicsBrushData*)m_brush.GetRefData())->IsShading() )
+ {
+ CGContextSaveGState( m_cgContext );
+ CGContextAddPath( m_cgContext , (CGPathRef) path.GetNativePath() );
+ CGContextClip( m_cgContext );
+ CGContextDrawShading( m_cgContext, ((wxMacCoreGraphicsBrushData*)m_brush.GetRefData())->GetShading() );
+ CGContextRestoreGState( m_cgContext);
+ }
+ else
+ {
+ ((wxMacCoreGraphicsBrushData*)m_brush.GetRefData())->Apply(this);
+ CGContextAddPath( m_cgContext , (CGPathRef) path.GetNativePath() );
+ if ( fillStyle == wxODDEVEN_RULE )
+ CGContextEOFillPath( m_cgContext );
+ else
+ CGContextFillPath( m_cgContext );
+ }
+}
+
+void wxMacCoreGraphicsContext::SetNativeContext( CGContextRef cg )
+{
+ // we allow either setting or clearing but not replacing
+ wxASSERT( m_cgContext == NULL || cg == NULL );
+
+ if ( m_cgContext )
+ {
+ // TODO : when is this necessary - should we add a Flush() method ? CGContextSynchronize( m_cgContext );
+ CGContextRestoreGState( m_cgContext );
+ CGContextRestoreGState( m_cgContext );
+ if ( m_releaseContext )
+ {
+#ifndef __LP64__
+ QDEndCGContext( GetWindowPort( m_windowRef ) , &m_cgContext);
+#endif
+ }
+ else
+ CGContextRelease(m_cgContext);
+ }
+
+
+ m_cgContext = cg;
+
+ // FIXME: This check is needed because currently we need to use a DC/GraphicsContext
+ // in order to get font properties, like wxFont::GetPixelSize, but since we don't have
+ // a native window attached to use, I create a wxGraphicsContext with a NULL CGContextRef
+ // for this one operation.
+
+ // When wxFont::GetPixelSize on Mac no longer needs a graphics context, this check
+ // can be removed.
+ if (m_cgContext)
+ {
+ CGContextRetain(m_cgContext);
+ CGContextSaveGState( m_cgContext );
+ CGContextSaveGState( m_cgContext );
+ m_releaseContext = false;
+ }
+}
+
+void wxMacCoreGraphicsContext::Translate( wxDouble dx , wxDouble dy )
+{
+ if ( m_cgContext )
+ CGContextTranslateCTM( m_cgContext, dx, dy );
+ else
+ m_windowTransform = CGAffineTransformTranslate(m_windowTransform,dx,dy);
+}
+
+void wxMacCoreGraphicsContext::Scale( wxDouble xScale , wxDouble yScale )
+{
+ if ( m_cgContext )
+ CGContextScaleCTM( m_cgContext , xScale , yScale );
+ else
+ m_windowTransform = CGAffineTransformScale(m_windowTransform,xScale,yScale);
+}
+
+void wxMacCoreGraphicsContext::Rotate( wxDouble angle )
+{
+ if ( m_cgContext )
+ CGContextRotateCTM( m_cgContext , angle );
+ else
+ m_windowTransform = CGAffineTransformRotate(m_windowTransform,angle);
+}
+
+void wxMacCoreGraphicsContext::DrawBitmap( const wxBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h )
+{
+ EnsureIsValid();
+
+ CGImageRef image = (CGImageRef)( bmp.CreateCGImage() );
+ HIRect r = CGRectMake( x , y , w , h );
+ if ( bmp.GetDepth() == 1 )
+ {
+ // is is a mask, the '1' in the mask tell where to draw the current brush
+ if ( !m_brush.IsNull() )
+ {
+ if ( ((wxMacCoreGraphicsBrushData*)m_brush.GetRefData())->IsShading() )
+ {
+ // TODO clip to mask
+ /*
+ CGContextSaveGState( m_cgContext );
+ CGContextAddPath( m_cgContext , (CGPathRef) path.GetNativePath() );
+ CGContextClip( m_cgContext );
+ CGContextDrawShading( m_cgContext, ((wxMacCoreGraphicsBrushData*)m_brush.GetRefData())->GetShading() );
+ CGContextRestoreGState( m_cgContext);
+ */
+ }
+ else
+ {
+ ((wxMacCoreGraphicsBrushData*)m_brush.GetRefData())->Apply(this);
+ wxMacDrawCGImage( m_cgContext , &r , image );
+ }
+ }
+ }
+ else
+ {
+ wxMacDrawCGImage( m_cgContext , &r , image );
+ }
+ CGImageRelease( image );
+}
+
+void wxMacCoreGraphicsContext::DrawIcon( const wxIcon &icon, wxDouble x, wxDouble y, wxDouble w, wxDouble h )
+{
+ EnsureIsValid();
+
+ CGRect r = CGRectMake( 00 , 00 , w , h );
+ CGContextSaveGState( m_cgContext );
+ CGContextTranslateCTM( m_cgContext, x , y + h );
+ CGContextScaleCTM( m_cgContext, 1, -1 );
+ PlotIconRefInContext( m_cgContext , &r , kAlignNone , kTransformNone ,
+ NULL , kPlotIconRefNormalFlags , MAC_WXHICON( icon.GetHICON() ) );
+ CGContextRestoreGState( m_cgContext );
+}
+
+void wxMacCoreGraphicsContext::PushState()
+{
+ EnsureIsValid();
+
+ CGContextSaveGState( m_cgContext );
+}
+
+void wxMacCoreGraphicsContext::PopState()
+{
+ EnsureIsValid();
+
+ CGContextRestoreGState( m_cgContext );
+}
+
+void wxMacCoreGraphicsContext::DrawText( const wxString &str, wxDouble x, wxDouble y )
+{
+ if ( m_font.IsNull() )
+ return;
+
+ EnsureIsValid();
+#if wxMAC_USE_CORE_TEXT
+ if ( UMAGetSystemVersion() >= 0x1050 )
+ {
+ wxMacCoreGraphicsFontData* fref = (wxMacCoreGraphicsFontData*)m_font.GetRefData();
+ wxMacCFStringHolder text(str, wxLocale::GetSystemEncoding() );
+ CTFontRef font = fref->GetCTFont();
+ CGColorRef col = fref->GetColour().GetPixel();
+ CTUnderlineStyle ustyle = fref->GetUnderlined() ? kCTUnderlineStyleSingle : kCTUnderlineStyleNone ;
+ wxCFRef<CFNumberRef> underlined( CFNumberCreate(NULL, kCFNumberSInt32Type, &ustyle) );
+ CFStringRef keys[] = { kCTFontAttributeName , kCTForegroundColorAttributeName, kCTUnderlineStyleAttributeName };
+ CFTypeRef values[] = { font, col, underlined };
+ wxCFRef<CFDictionaryRef> attributes( CFDictionaryCreate(kCFAllocatorDefault, (const void**) &keys, (const void**) &values,
+ WXSIZEOF( keys ), &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks) );
+ wxCFRef<CFAttributedStringRef> attrtext( CFAttributedStringCreate(kCFAllocatorDefault, text, attributes) );
+ wxCFRef<CTLineRef> line( CTLineCreateWithAttributedString(attrtext) );
+
+ y += CTFontGetAscent(font);
+
+ CGContextSaveGState(m_cgContext);
+ CGContextTranslateCTM(m_cgContext, x, y);
+ CGContextScaleCTM(m_cgContext, 1, -1);
+ CGContextSetTextPosition(m_cgContext, 0, 0);
+ CTLineDraw( line, m_cgContext );
+ CGContextRestoreGState(m_cgContext);
+ return;
+ }
+#endif
+#if wxMAC_USE_ATSU_TEXT
+ {
+ DrawText(str, x, y, 0.0);
+ return;
+ }
+#endif
+#if wxMAC_USE_CG_TEXT
+ // TODO core graphics text implementation here
+#endif
+}
+
+void wxMacCoreGraphicsContext::DrawText( const wxString &str, wxDouble x, wxDouble y, wxDouble angle )
+{
+ if ( m_font.IsNull() )
+ return;
+
+ EnsureIsValid();
+#if wxMAC_USE_CORE_TEXT
+ if ( UMAGetSystemVersion() >= 0x1050 )
+ {
+ // default implementation takes care of rotation and calls non rotated DrawText afterwards
+ wxGraphicsContext::DrawText( str, x, y, angle );
+ return;
+ }
+#endif
+#if wxMAC_USE_ATSU_TEXT
+ {
+ OSStatus status = noErr;
+ ATSUTextLayout atsuLayout;
+ UniCharCount chars = str.length();
+ UniChar* ubuf = NULL;
+
+#if SIZEOF_WCHAR_T == 4
+ wxMBConvUTF16 converter;
+#if wxUSE_UNICODE
+ size_t unicharlen = converter.WC2MB( NULL , str.wc_str() , 0 );
+ ubuf = (UniChar*) malloc( unicharlen + 2 );
+ converter.WC2MB( (char*) ubuf , str.wc_str(), unicharlen + 2 );
+#else
+ const wxWCharBuffer wchar = str.wc_str( wxConvLocal );
+ size_t unicharlen = converter.WC2MB( NULL , wchar.data() , 0 );
+ ubuf = (UniChar*) malloc( unicharlen + 2 );
+ converter.WC2MB( (char*) ubuf , wchar.data() , unicharlen + 2 );
+#endif
+ chars = unicharlen / 2;
+#else
+#if wxUSE_UNICODE
+ ubuf = (UniChar*) str.wc_str();
+#else
+ wxWCharBuffer wchar = str.wc_str( wxConvLocal );
+ chars = wxWcslen( wchar.data() );
+ ubuf = (UniChar*) wchar.data();
+#endif
+#endif
+
+ ATSUStyle style = (((wxMacCoreGraphicsFontData*)m_font.GetRefData())->GetATSUStyle());
+ status = ::ATSUCreateTextLayoutWithTextPtr( (UniCharArrayPtr) ubuf , 0 , chars , chars , 1 ,
+ &chars , &style , &atsuLayout );
+
+ wxASSERT_MSG( status == noErr , wxT("couldn't create the layout of the rotated text") );
+
+ status = ::ATSUSetTransientFontMatching( atsuLayout , true );
+ wxASSERT_MSG( status == noErr , wxT("couldn't setup transient font matching") );
+
+ int iAngle = int( angle * RAD2DEG );
+ if ( abs(iAngle) > 0 )
+ {
+ Fixed atsuAngle = IntToFixed( iAngle );
+ ATSUAttributeTag atsuTags[] =
+ {
+ kATSULineRotationTag ,
+ };
+ ByteCount atsuSizes[sizeof(atsuTags) / sizeof(ATSUAttributeTag)] =
+ {
+ sizeof( Fixed ) ,
+ };
+ ATSUAttributeValuePtr atsuValues[sizeof(atsuTags) / sizeof(ATSUAttributeTag)] =
projects / wxWidgets.git / blobdiff