+//-----------------------------------------------------------------------------
+// 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
+{
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4
+ if ( CGPathContainsPoint!=NULL )
+ {
+ return CGPathContainsPoint( m_path, NULL, CGPointMake(x,y), fillStyle == wxODDEVEN_RULE );
+ }
+ else
+#endif
+ {
+ // TODO : implementation for 10.3
+ CGRect bounds = CGPathGetBoundingBox( m_path ) ;
+ return CGRectContainsPoint( bounds, CGPointMake(x,y) ) == 1;
+ }
+}
+
+//
+// Graphics Context
+//
+
+//-----------------------------------------------------------------------------
+// wxMacCoreGraphicsContext declaration
+//-----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxMacCoreGraphicsContext : public wxGraphicsContext
+{
+public:
+ wxMacCoreGraphicsContext( wxGraphicsRenderer* renderer, CGContextRef cgcontext );
+
+ wxMacCoreGraphicsContext( wxGraphicsRenderer* renderer, WindowRef window );
+
+ wxMacCoreGraphicsContext( wxGraphicsRenderer* renderer, wxWindow* window );
+
+ wxMacCoreGraphicsContext( wxGraphicsRenderer* renderer);
+
+ wxMacCoreGraphicsContext();
+
+ ~wxMacCoreGraphicsContext();
+
+ void Init();
+
+ // 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;
+
+ 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)
+
+void wxMacCoreGraphicsContext::Init()
+{
+ m_cgContext = NULL;
+ m_releaseContext = false;
+ m_windowRef = NULL;
+
+ HIRect r = CGRectMake(0,0,0,0);
+ m_clipRgn.Set(HIShapeCreateWithRect(&r));
+}
+
+wxMacCoreGraphicsContext::wxMacCoreGraphicsContext( wxGraphicsRenderer* renderer, CGContextRef cgcontext ) : wxGraphicsContext(renderer)
+{
+ Init();
+ SetNativeContext(cgcontext);
+}
+
+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;
+ GetWindowBounds( m_windowRef, kWindowContentRgn, &bounds );
+
+ 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::EnsureIsValid()
+{
+ if ( !m_cgContext )
+ {
+ OSStatus status = QDBeginCGContext( GetWindowPort( m_windowRef ) , &m_cgContext );
+ 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 );
+ }
+}
+
+bool wxMacCoreGraphicsContext::SetLogicalFunction( int function )
+{
+ if (m_logicalFunction == function)
+ return true;
+
+ EnsureIsValid();
+
+ bool retval = false;
+
+ if ( function == wxCOPY )
+ {
+ retval = true;
+#if wxMAC_USE_CORE_GRAPHICS_BLEND_MODES
+ if ( CGContextSetBlendMode != NULL )
+ {
+ CGContextSetBlendMode( m_cgContext, kCGBlendModeNormal );
+ CGContextSetShouldAntialias( m_cgContext, true );
+ }
+#endif
+ }
+ else if ( function == wxINVERT || function == wxXOR )
+ {
+#if wxMAC_USE_CORE_GRAPHICS_BLEND_MODES
+ if ( CGContextSetBlendMode != NULL )
+ {
+ // change color to white
+ CGContextSetBlendMode( m_cgContext, kCGBlendModeExclusion );
+ CGContextSetShouldAntialias( m_cgContext, false );
+ retval = true;
+ }
+#endif
+ }
+
+ if (retval)
+ m_logicalFunction = function;
+ return retval ;
+}
+
+void wxMacCoreGraphicsContext::Clip( const wxRegion ®ion )
+{
+ if( m_cgContext )
+ {
+ HIShapeRef shape = HIShapeCreateWithQDRgn( (RgnHandle) region.GetWXHRGN() );
+ HIShapeReplacePathInCGContext( shape, m_cgContext );
+ CGContextClip( m_cgContext );
+ CFRelease( shape );
+ }
+ 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
+ wxMacCFRefHolder<HIShapeRef> hishape ;
+ hishape.Set( HIShapeCreateWithQDRgn( (RgnHandle) region.GetWXHRGN() ));
+ HIMutableShapeRef mutableShape = HIShapeCreateMutableCopy( hishape );
+
+ 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));
+ }
+}
projects / wxWidgets.git / blobdiff