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


4cd27e7247bc10502346be1ba9314ae988e5db25
[wxWidgets.git] / src / mac / carbon / dccg.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/mac/carbon/dccg.cpp
3 // Purpose: wxDC class
4 // Author: Stefan Csomor
5 // Modified by:
6 // Created: 01/02/97
7 // RCS-ID: $Id$
8 // Copyright: (c) Stefan Csomor
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #include "wx/wxprec.h"
13
14 #include "wx/dc.h"
15
16 #if wxMAC_USE_CORE_GRAPHICS
17
18 #ifndef WX_PRECOMP
19 #include "wx/log.h"
20 #include "wx/dcmemory.h"
21 #include "wx/region.h"
22 #endif
23
24 #include "wx/mac/uma.h"
25
26 #ifdef __MSL__
27 #if __MSL__ >= 0x6000
28 #include "math.h"
29 // in case our functions were defined outside std, we make it known all the same
30 namespace std { }
31 using namespace std ;
32 #endif
33 #endif
34
35 #include "wx/mac/private.h"
36
37
38 #ifndef wxMAC_USE_CORE_GRAPHICS_BLEND_MODES
39 #define wxMAC_USE_CORE_GRAPHICS_BLEND_MODES 0
40 #endif
41
42 #if MAC_OS_X_VERSION_MAX_ALLOWED <= MAC_OS_X_VERSION_10_4
43 typedef float CGFloat ;
44 #endif
45
46 //-----------------------------------------------------------------------------
47 // constants
48 //-----------------------------------------------------------------------------
49
50 #if !defined( __DARWIN__ ) || defined(__MWERKS__)
51 #ifndef M_PI
52 const double M_PI = 3.14159265358979 ;
53 #endif
54 #endif
55
56 static const double RAD2DEG = 180.0 / M_PI;
57
58 #ifndef __LP64__
59
60 // TODO: update
61 // The textctrl implementation still needs that (needs what?) for the non-HIView implementation
62 //
63 wxMacWindowClipper::wxMacWindowClipper( const wxWindow* win ) :
64 wxMacPortSaver( (GrafPtr) GetWindowPort( (WindowRef) win->MacGetTopLevelWindowRef() ) )
65 {
66 m_newPort = (GrafPtr) GetWindowPort( (WindowRef) win->MacGetTopLevelWindowRef() ) ;
67 m_formerClip = NewRgn() ;
68 m_newClip = NewRgn() ;
69 GetClip( m_formerClip ) ;
70
71 if ( win )
72 {
73 // guard against half constructed objects, this just leads to a empty clip
74 if ( win->GetPeer() )
75 {
76 int x = 0 , y = 0;
77 win->MacWindowToRootWindow( &x, &y ) ;
78
79 // get area including focus rect
80 CopyRgn( (RgnHandle) ((wxWindow*)win)->MacGetVisibleRegion(true).GetWXHRGN() , m_newClip ) ;
81 if ( !EmptyRgn( m_newClip ) )
82 OffsetRgn( m_newClip , x , y ) ;
83 }
84
85 SetClip( m_newClip ) ;
86 }
87 }
88
89 wxMacWindowClipper::~wxMacWindowClipper()
90 {
91 SetPort( m_newPort ) ;
92 SetClip( m_formerClip ) ;
93 DisposeRgn( m_newClip ) ;
94 DisposeRgn( m_formerClip ) ;
95 }
96
97 wxMacWindowStateSaver::wxMacWindowStateSaver( const wxWindow* win ) :
98 wxMacWindowClipper( win )
99 {
100 // the port is already set at this point
101 m_newPort = (GrafPtr) GetWindowPort( (WindowRef) win->MacGetTopLevelWindowRef() ) ;
102 GetThemeDrawingState( &m_themeDrawingState ) ;
103 }
104
105 wxMacWindowStateSaver::~wxMacWindowStateSaver()
106 {
107 SetPort( m_newPort ) ;
108 SetThemeDrawingState( m_themeDrawingState , true ) ;
109 }
110
111 // minimal implementation only used for appearance drawing < 10.3
112
113 #ifndef wxMAC_USE_CORE_GRAPHICS
114 wxMacPortSetter::wxMacPortSetter( const wxDC* dc ) :
115 m_ph( (GrafPtr) dc->m_macPort )
116 {
117 wxASSERT( dc->Ok() ) ;
118 m_dc = dc ;
119
120 // dc->MacSetupPort(&m_ph) ;
121 }
122
123 wxMacPortSetter::~wxMacPortSetter()
124 {
125 // m_dc->MacCleanupPort(&m_ph) ;
126 }
127
128 #endif
129
130 #endif
131
132 //-----------------------------------------------------------------------------
133 // Local functions
134 //-----------------------------------------------------------------------------
135
136 static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; }
137
138 //-----------------------------------------------------------------------------
139 // device context implementation
140 //
141 // more and more of the dc functionality should be implemented by calling
142 // the appropricate wxMacCGContext, but we will have to do that step by step
143 // also coordinate conversions should be moved to native matrix ops
144 //-----------------------------------------------------------------------------
145
146 // we always stock two context states, one at entry, to be able to preserve the
147 // state we were called with, the other one after changing to HI Graphics orientation
148 // (this one is used for getting back clippings etc)
149
150 //-----------------------------------------------------------------------------
151 // wxGraphicPath implementation
152 //-----------------------------------------------------------------------------
153
154 #if !wxUSE_GRAPHICS_CONTEXT
155
156 IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
157
158 wxMacCGPath::wxMacCGPath()
159 {
160 m_path = CGPathCreateMutable() ;
161 }
162
163 wxMacCGPath::~wxMacCGPath()
164 {
165 CGPathRelease( m_path ) ;
166 }
167
168 // opens (starts) a new subpath
169 void wxMacCGPath::MoveToPoint( wxCoord x1 , wxCoord y1 )
170 {
171 CGPathMoveToPoint( m_path , NULL , x1 , y1 ) ;
172 }
173
174 void wxMacCGPath::AddLineToPoint( wxCoord x1 , wxCoord y1 )
175 {
176 CGPathAddLineToPoint( m_path , NULL , x1 , y1 ) ;
177 }
178
179 void wxMacCGPath::AddQuadCurveToPoint( wxCoord cx1, wxCoord cy1, wxCoord x1, wxCoord y1 )
180 {
181 CGPathAddQuadCurveToPoint( m_path , NULL , cx1 , cy1 , x1 , y1 );
182 }
183
184 void wxMacCGPath::AddRectangle( wxCoord x, wxCoord y, wxCoord w, wxCoord h )
185 {
186 CGRect cgRect = { { x , y } , { w , h } } ;
187 CGPathAddRect( m_path , NULL , cgRect ) ;
188 }
189
190 void wxMacCGPath::AddCircle( wxCoord x, wxCoord y , wxCoord r )
191 {
192 CGPathAddArc( m_path , NULL , x , y , r , 0.0 , 2 * M_PI , true ) ;
193 }
194
195 // closes the current subpath
196 void wxMacCGPath::CloseSubpath()
197 {
198 CGPathCloseSubpath( m_path ) ;
199 }
200
201 CGPathRef wxMacCGPath::GetPath() const
202 {
203 return m_path ;
204 }
205
206 void wxMacCGPath::AddArcToPoint( wxCoord x1, wxCoord y1 , wxCoord x2, wxCoord y2, wxCoord r )
207 {
208 CGPathAddArcToPoint( m_path, NULL , x1, y1, x2, y2, r);
209 }
210
211 void wxMacCGPath::AddArc( wxCoord x, wxCoord y, wxCoord r, double startAngle, double endAngle, bool clockwise )
212 {
213 CGPathAddArc( m_path, NULL , x, y, r, startAngle, endAngle, clockwise);
214 }
215
216 //-----------------------------------------------------------------------------
217 // wxGraphicContext implementation
218 //-----------------------------------------------------------------------------
219
220 wxMacCGContext::wxMacCGContext( CGrafPtr port )
221 {
222 m_qdPort = port ;
223 m_cgContext = NULL ;
224 m_mode = kCGPathFill;
225 m_macATSUIStyle = NULL ;
226 }
227
228 wxMacCGContext::wxMacCGContext( CGContextRef cgcontext )
229 {
230 m_qdPort = NULL ;
231 m_cgContext = cgcontext ;
232 m_mode = kCGPathFill;
233 m_macATSUIStyle = NULL ;
234 CGContextSaveGState( m_cgContext ) ;
235 CGContextSaveGState( m_cgContext ) ;
236 }
237
238 wxMacCGContext::wxMacCGContext()
239 {
240 m_qdPort = NULL ;
241 m_cgContext = NULL ;
242 m_mode = kCGPathFill;
243 m_macATSUIStyle = NULL ;
244 }
245
246 wxMacCGContext::~wxMacCGContext()
247 {
248 if ( m_cgContext )
249 {
250 CGContextSynchronize( m_cgContext ) ;
251 CGContextRestoreGState( m_cgContext ) ;
252 CGContextRestoreGState( m_cgContext ) ;
253 }
254 #ifndef __LP64__
255 if ( m_qdPort )
256 QDEndCGContext( m_qdPort, &m_cgContext ) ;
257 #endif
258 }
259
260
261 void wxMacCGContext::Clip( const wxRegion &region )
262 {
263 // ClipCGContextToRegion ( m_cgContext, &bounds , (RgnHandle) dc->m_macCurrentClipRgn ) ;
264 }
265
266 void wxMacCGContext::StrokePath( const wxGraphicPath *p )
267 {
268 const wxMacCGPath* path = dynamic_cast< const wxMacCGPath*>( p ) ;
269
270 int width = m_pen.GetWidth();
271 if ( width == 0 )
272 width = 1 ;
273 if ( m_pen.GetStyle() == wxTRANSPARENT )
274 width = 0 ;
275
276 bool offset = ( width % 2 ) == 1 ;
277
278 if ( offset )
279 CGContextTranslateCTM( m_cgContext, 0.5, 0.5 );
280
281 CGContextAddPath( m_cgContext , path->GetPath() ) ;
282 CGContextStrokePath( m_cgContext ) ;
283
284 if ( offset )
285 CGContextTranslateCTM( m_cgContext, -0.5, -0.5 );
286 }
287
288 void wxMacCGContext::DrawPath( const wxGraphicPath *p , int fillStyle )
289 {
290 const wxMacCGPath* path = dynamic_cast< const wxMacCGPath*>( p ) ;
291 CGPathDrawingMode mode = m_mode ;
292
293 if ( fillStyle == wxODDEVEN_RULE )
294 {
295 if ( mode == kCGPathFill )
296 mode = kCGPathEOFill ;
297 else if ( mode == kCGPathFillStroke )
298 mode = kCGPathEOFillStroke ;
299 }
300
301 int width = m_pen.GetWidth();
302 if ( width == 0 )
303 width = 1 ;
304 if ( m_pen.GetStyle() == wxTRANSPARENT )
305 width = 0 ;
306
307 bool offset = ( width % 2 ) == 1 ;
308
309 if ( offset )
310 CGContextTranslateCTM( m_cgContext, 0.5, 0.5 );
311
312 CGContextAddPath( m_cgContext , path->GetPath() ) ;
313 CGContextDrawPath( m_cgContext , mode ) ;
314
315 if ( offset )
316 CGContextTranslateCTM( m_cgContext, -0.5, -0.5 );
317 }
318
319 void wxMacCGContext::FillPath( const wxGraphicPath *p , const wxColor &fillColor , int fillStyle )
320 {
321 const wxMacCGPath* path = dynamic_cast< const wxMacCGPath*>( p ) ;
322 CGContextSaveGState( m_cgContext ) ;
323
324 RGBColor col = MAC_WXCOLORREF( fillColor.GetPixel() ) ;
325 CGContextSetRGBFillColor( m_cgContext , col.red / 65536.0 , col.green / 65536.0 , col.blue / 65536.0 , 1.0 ) ;
326 CGPathDrawingMode mode = kCGPathFill ;
327
328 if ( fillStyle == wxODDEVEN_RULE )
329 mode = kCGPathEOFill ;
330
331 CGContextBeginPath( m_cgContext ) ;
332 CGContextAddPath( m_cgContext , path->GetPath() ) ;
333 CGContextClosePath( m_cgContext ) ;
334 CGContextDrawPath( m_cgContext , mode ) ;
335
336 CGContextRestoreGState( m_cgContext ) ;
337 }
338
339 wxGraphicPath* wxMacCGContext::CreatePath()
340 {
341 // make sure that we now have a real cgref, before doing
342 // anything with paths
343 CGContextRef cg = GetNativeContext() ;
344 cg = NULL ;
345
346 return new wxMacCGPath() ;
347 }
348
349 // in case we only got a QDPort only create a cgref now
350
351 CGContextRef wxMacCGContext::GetNativeContext()
352 {
353 if ( m_cgContext == NULL )
354 {
355 Rect bounds ;
356 OSStatus status = noErr;
357 #ifndef __LP64__
358 GetPortBounds( (CGrafPtr) m_qdPort , &bounds ) ;
359 status = QDBeginCGContext((CGrafPtr) m_qdPort , &m_cgContext) ;
360 #endif
361 CGContextSaveGState( m_cgContext ) ;
362
363 wxASSERT_MSG( status == noErr , wxT("Cannot nest wxDCs on the same window") ) ;
364
365 CGContextTranslateCTM( m_cgContext , 0 , bounds.bottom - bounds.top ) ;
366 CGContextScaleCTM( m_cgContext , 1 , -1 ) ;
367
368 CGContextSaveGState( m_cgContext ) ;
369 SetPen( m_pen ) ;
370 SetBrush( m_brush ) ;
371 }
372
373 return m_cgContext ;
374 }
375
376 void wxMacCGContext::SetNativeContext( CGContextRef cg )
377 {
378 // we allow either setting or clearing but not replacing
379 wxASSERT( m_cgContext == NULL || cg == NULL ) ;
380
381 if ( cg )
382 CGContextSaveGState( cg ) ;
383 m_cgContext = cg ;
384 }
385
386 void wxMacCGContext::Translate( wxCoord dx , wxCoord dy )
387 {
388 CGContextTranslateCTM( m_cgContext, dx, dy );
389 }
390
391 void wxMacCGContext::Scale( wxCoord xScale , wxCoord yScale )
392 {
393 CGContextScaleCTM( m_cgContext , xScale , yScale ) ;
394 }
395
396 void wxMacCGContext::DrawBitmap( const wxBitmap &bmp, wxCoord x, wxCoord y, wxCoord w, wxCoord h )
397 {
398 CGImageRef image = (CGImageRef)( bmp.CGImageCreate() ) ;
399 HIRect r = CGRectMake( 0 , 0 , w , h );
400
401 CGContextSaveGState( m_cgContext );
402 CGContextTranslateCTM( m_cgContext, x , y + h );
403 CGContextScaleCTM( m_cgContext, 1, -1 );
404
405 // in case image is a mask, set the foreground color
406 CGContextSetRGBFillColor( m_cgContext , m_textForegroundColor.Red() / 255.0 , m_textForegroundColor.Green() / 255.0 ,
407 m_textForegroundColor.Blue() / 255.0 , m_textForegroundColor.Alpha() / 255.0 ) ;
408 CGContextDrawImage( m_cgContext, r, image );
409 CGContextRestoreGState( m_cgContext );
410
411 CGImageRelease( image ) ;
412 }
413
414 void wxMacCGContext::DrawIcon( const wxIcon &icon, wxCoord x, wxCoord y, wxCoord w, wxCoord h )
415 {
416 CGRect r = CGRectMake( 0 , 0 , w , h ) ;
417 CGContextSaveGState( m_cgContext );
418 CGContextTranslateCTM( m_cgContext, x , y + h );
419 CGContextScaleCTM( m_cgContext, 1, -1 );
420 PlotIconRefInContext( m_cgContext , &r , kAlignNone , kTransformNone ,
421 NULL , kPlotIconRefNormalFlags , MAC_WXHICON( icon.GetHICON() ) ) ;
422 CGContextRestoreGState( m_cgContext ) ;
423 }
424
425 void wxMacCGContext::PushState()
426 {
427 CGContextSaveGState( m_cgContext );
428 }
429
430 void wxMacCGContext::PopState()
431 {
432 CGContextRestoreGState( m_cgContext );
433 }
434
435 void wxMacCGContext::SetTextColor( const wxColour &col )
436 {
437 m_textForegroundColor = col ;
438 }
439
440 #pragma mark -
441 #pragma mark wxMacCGPattern, ImagePattern, HatchPattern classes
442
443 // CGPattern wrapper class: always allocate on heap, never call destructor
444
445 class wxMacCGPattern
446 {
447 public :
448 wxMacCGPattern() {}
449
450 // is guaranteed to be called only with a non-Null CGContextRef
451 virtual void Render( CGContextRef ctxRef ) = 0 ;
452
453 operator CGPatternRef() const { return m_patternRef ; }
454
455 protected :
456 virtual ~wxMacCGPattern()
457 {
458 // as this is called only when the m_patternRef is been released;
459 // don't release it again
460 }
461
462 static void _Render( void *info, CGContextRef ctxRef )
463 {
464 wxMacCGPattern* self = (wxMacCGPattern*) info ;
465 if ( self && ctxRef )
466 self->Render( ctxRef ) ;
467 }
468
469 static void _Dispose( void *info )
470 {
471 wxMacCGPattern* self = (wxMacCGPattern*) info ;
472 delete self ;
473 }
474
475 CGPatternRef m_patternRef ;
476
477 static const CGPatternCallbacks ms_Callbacks ;
478 } ;
479
480 const CGPatternCallbacks wxMacCGPattern::ms_Callbacks = { 0, &wxMacCGPattern::_Render, &wxMacCGPattern::_Dispose };
481
482 class ImagePattern : public wxMacCGPattern
483 {
484 public :
485 ImagePattern( const wxBitmap* bmp , const CGAffineTransform& transform )
486 {
487 wxASSERT( bmp && bmp->Ok() ) ;
488
489 Init( (CGImageRef) bmp->CGImageCreate() , transform ) ;
490 }
491
492 // ImagePattern takes ownership of CGImageRef passed in
493 ImagePattern( CGImageRef image , const CGAffineTransform& transform )
494 {
495 if ( image )
496 CFRetain( image ) ;
497
498 Init( image , transform ) ;
499 }
500
501 virtual void Render( CGContextRef ctxRef )
502 {
503 if (m_image != NULL)
504 HIViewDrawCGImage( ctxRef, &m_imageBounds, m_image );
505 }
506
507 protected :
508 void Init( CGImageRef image, const CGAffineTransform& transform )
509 {
510 m_image = image ;
511 if ( m_image )
512 {
513 m_imageBounds = CGRectMake( 0.0, 0.0, (CGFloat)CGImageGetWidth( m_image ), (CGFloat)CGImageGetHeight( m_image ) ) ;
514 m_patternRef = CGPatternCreate(
515 this , m_imageBounds, transform ,
516 m_imageBounds.size.width, m_imageBounds.size.height,
517 kCGPatternTilingNoDistortion, true , &wxMacCGPattern::ms_Callbacks ) ;
518 }
519 }
520
521 virtual ~ImagePattern()
522 {
523 if ( m_image )
524 CGImageRelease( m_image ) ;
525 }
526
527 CGImageRef m_image ;
528 CGRect m_imageBounds ;
529 } ;
530
531 class HatchPattern : public wxMacCGPattern
532 {
533 public :
534 HatchPattern( int hatchstyle, const CGAffineTransform& transform )
535 {
536 m_hatch = hatchstyle ;
537 m_imageBounds = CGRectMake( 0.0, 0.0, 8.0 , 8.0 ) ;
538 m_patternRef = CGPatternCreate(
539 this , m_imageBounds, transform ,
540 m_imageBounds.size.width, m_imageBounds.size.height,
541 kCGPatternTilingNoDistortion, false , &wxMacCGPattern::ms_Callbacks ) ;
542 }
543
544 void StrokeLineSegments( CGContextRef ctxRef , const CGPoint pts[] , size_t count )
545 {
546 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4
547 if ( UMAGetSystemVersion() >= 0x1040 )
548 {
549 CGContextStrokeLineSegments( ctxRef , pts , count ) ;
550 }
551 else
552 #endif
553 {
554 CGContextBeginPath( ctxRef );
555 for (size_t i = 0; i < count; i += 2)
556 {
557 CGContextMoveToPoint(ctxRef, pts[i].x, pts[i].y);
558 CGContextAddLineToPoint(ctxRef, pts[i+1].x, pts[i+1].y);
559 }
560 CGContextStrokePath(ctxRef);
561 }
562 }
563
564 virtual void Render( CGContextRef ctxRef )
565 {
566 switch ( m_hatch )
567 {
568 case wxBDIAGONAL_HATCH :
569 {
570 CGPoint pts[] =
571 {
572 { 8.0 , 0.0 } , { 0.0 , 8.0 }
573 };
574 StrokeLineSegments( ctxRef , pts , 2 ) ;
575 }
576 break ;
577
578 case wxCROSSDIAG_HATCH :
579 {
580 CGPoint pts[] =
581 {
582 { 0.0 , 0.0 } , { 8.0 , 8.0 } ,
583 { 8.0 , 0.0 } , { 0.0 , 8.0 }
584 };
585 StrokeLineSegments( ctxRef , pts , 4 ) ;
586 }
587 break ;
588
589 case wxFDIAGONAL_HATCH :
590 {
591 CGPoint pts[] =
592 {
593 { 0.0 , 0.0 } , { 8.0 , 8.0 }
594 };
595 StrokeLineSegments( ctxRef , pts , 2 ) ;
596 }
597 break ;
598
599 case wxCROSS_HATCH :
600 {
601 CGPoint pts[] =
602 {
603 { 0.0 , 4.0 } , { 8.0 , 4.0 } ,
604 { 4.0 , 0.0 } , { 4.0 , 8.0 } ,
605 };
606 StrokeLineSegments( ctxRef , pts , 4 ) ;
607 }
608 break ;
609
610 case wxHORIZONTAL_HATCH :
611 {
612 CGPoint pts[] =
613 {
614 { 0.0 , 4.0 } , { 8.0 , 4.0 } ,
615 };
616 StrokeLineSegments( ctxRef , pts , 2 ) ;
617 }
618 break ;
619
620 case wxVERTICAL_HATCH :
621 {
622 CGPoint pts[] =
623 {
624 { 4.0 , 0.0 } , { 4.0 , 8.0 } ,
625 };
626 StrokeLineSegments( ctxRef , pts , 2 ) ;
627 }
628 break ;
629
630 default:
631 break;
632 }
633 }
634
635 protected :
636 virtual ~HatchPattern() {}
637
638 CGRect m_imageBounds ;
639 int m_hatch ;
640 };
641
642 #pragma mark -
643
644 void wxMacCGContext::SetPen( const wxPen &pen )
645 {
646 m_pen = pen ;
647 if ( m_cgContext == NULL )
648 return ;
649
650 bool fill = m_brush.GetStyle() != wxTRANSPARENT ;
651 bool stroke = pen.GetStyle() != wxTRANSPARENT ;
652
653 #if 0
654 // we can benchmark performance; should go into a setting eventually
655 CGContextSetShouldAntialias( m_cgContext , false ) ;
656 #endif
657
658 if ( fill || stroke )
659 {
660 // set up brushes
661 m_mode = kCGPathFill ; // just a default
662
663 if ( stroke )
664 {
665 CGContextSetRGBStrokeColor( m_cgContext , pen.GetColour().Red() / 255.0 , pen.GetColour().Green() / 255.0 ,
666 pen.GetColour().Blue() / 255.0 , pen.GetColour().Alpha() / 255.0 ) ;
667
668 // TODO: * m_dc->m_scaleX
669 CGFloat penWidth = pen.GetWidth();
670 if (penWidth <= 0.0)
671 penWidth = 0.1;
672 CGContextSetLineWidth( m_cgContext , penWidth ) ;
673
674 CGLineCap cap ;
675 switch ( pen.GetCap() )
676 {
677 case wxCAP_ROUND :
678 cap = kCGLineCapRound ;
679 break ;
680
681 case wxCAP_PROJECTING :
682 cap = kCGLineCapSquare ;
683 break ;
684
685 case wxCAP_BUTT :
686 cap = kCGLineCapButt ;
687 break ;
688
689 default :
690 cap = kCGLineCapButt ;
691 break ;
692 }
693
694 CGLineJoin join ;
695 switch ( pen.GetJoin() )
696 {
697 case wxJOIN_BEVEL :
698 join = kCGLineJoinBevel ;
699 break ;
700
701 case wxJOIN_MITER :
702 join = kCGLineJoinMiter ;
703 break ;
704
705 case wxJOIN_ROUND :
706 join = kCGLineJoinRound ;
707 break ;
708
709 default :
710 join = kCGLineJoinMiter ;
711 break;
712 }
713
714 m_mode = kCGPathStroke ;
715 int count = 0 ;
716
717 const CGFloat *lengths = NULL ;
718 CGFloat *userLengths = NULL ;
719
720 const CGFloat dashUnit = penWidth < 1.0 ? 1.0 : penWidth;
721
722 const CGFloat dotted[] = { dashUnit , dashUnit + 2.0 };
723 const CGFloat short_dashed[] = { 9.0 , 6.0 };
724 const CGFloat dashed[] = { 19.0 , 9.0 };
725 const CGFloat dotted_dashed[] = { 9.0 , 6.0 , 3.0 , 3.0 };
726
727 switch ( pen.GetStyle() )
728 {
729 case wxSOLID :
730 break ;
731
732 case wxDOT :
733 lengths = dotted ;
734 count = WXSIZEOF(dotted);
735 break ;
736
737 case wxLONG_DASH :
738 lengths = dashed ;
739 count = WXSIZEOF(dashed) ;
740 break ;
741
742 case wxSHORT_DASH :
743 lengths = short_dashed ;
744 count = WXSIZEOF(short_dashed) ;
745 break ;
746
747 case wxDOT_DASH :
748 lengths = dotted_dashed ;
749 count = WXSIZEOF(dotted_dashed);
750 break ;
751
752 case wxUSER_DASH :
753 wxDash *dashes ;
754 count = pen.GetDashes( &dashes ) ;
755 if ((dashes != NULL) && (count > 0))
756 {
757 userLengths = new CGFloat[count] ;
758 for ( int i = 0 ; i < count ; ++i )
759 {
760 userLengths[i] = dashes[i] * dashUnit ;
761
762 if ( i % 2 == 1 && userLengths[i] < dashUnit + 2.0 )
763 userLengths[i] = dashUnit + 2.0 ;
764 else if ( i % 2 == 0 && userLengths[i] < dashUnit )
765 userLengths[i] = dashUnit ;
766 }
767 }
768 lengths = userLengths ;
769 break ;
770
771 case wxSTIPPLE :
772 {
773 CGFloat alphaArray[1] = { 1.0 } ;
774 wxBitmap* bmp = pen.GetStipple() ;
775 if ( bmp && bmp->Ok() )
776 {
777 wxMacCFRefHolder<CGColorSpaceRef> patternSpace( CGColorSpaceCreatePattern( NULL ) ) ;
778 CGContextSetStrokeColorSpace( m_cgContext , patternSpace ) ;
779 wxMacCFRefHolder<CGPatternRef> pattern( *( new ImagePattern( bmp , CGContextGetCTM( m_cgContext ) ) ) );
780 CGContextSetStrokePattern( m_cgContext, pattern , alphaArray ) ;
781 }
782 }
783 break ;
784
785 default :
786 {
787 wxMacCFRefHolder<CGColorSpaceRef> patternSpace( CGColorSpaceCreatePattern( wxMacGetGenericRGBColorSpace() ) ) ;
788 CGContextSetStrokeColorSpace( m_cgContext , patternSpace ) ;
789 wxMacCFRefHolder<CGPatternRef> pattern( *( new HatchPattern( pen.GetStyle() , CGContextGetCTM( m_cgContext ) ) ) );
790
791 CGFloat colorArray[4] = { pen.GetColour().Red() / 255.0 , pen.GetColour().Green() / 255.0 ,
792 pen.GetColour().Blue() / 255.0 , pen.GetColour().Alpha() / 255.0 } ;
793
794 CGContextSetStrokePattern( m_cgContext, pattern , colorArray ) ;
795 }
796 break ;
797 }
798
799 if ((lengths != NULL) && (count > 0))
800 {
801 CGContextSetLineDash( m_cgContext , 0 , lengths , count ) ;
802 // force the line cap, otherwise we get artifacts (overlaps) and just solid lines
803 cap = kCGLineCapButt ;
804 }
805 else
806 {
807 CGContextSetLineDash( m_cgContext , 0 , NULL , 0 ) ;
808 }
809
810 CGContextSetLineCap( m_cgContext , cap ) ;
811 CGContextSetLineJoin( m_cgContext , join ) ;
812
813 delete[] userLengths ;
814 }
815
816 if ( fill && stroke )
817 m_mode = kCGPathFillStroke ;
818 }
819 }
820
821 void wxMacCGContext::SetBrush( const wxBrush &brush )
822 {
823 m_brush = brush ;
824 if ( m_cgContext == NULL )
825 return ;
826
827 bool fill = brush.GetStyle() != wxTRANSPARENT ;
828 bool stroke = m_pen.GetStyle() != wxTRANSPARENT ;
829
830 #if 0
831 // we can benchmark performance, should go into a setting later
832 CGContextSetShouldAntialias( m_cgContext , false ) ;
833 #endif
834
835 if ( fill || stroke )
836 {
837 // setup brushes
838 m_mode = kCGPathFill ; // just a default
839
840 if ( fill )
841 {
842 if ( brush.GetStyle() == wxSOLID )
843 {
844 CGContextSetRGBFillColor( m_cgContext , brush.GetColour().Red() / 255.0 , brush.GetColour().Green() / 255.0 ,
845 brush.GetColour().Blue() / 255.0 , brush.GetColour().Alpha() / 255.0 ) ;
846 }
847 else if ( brush.IsHatch() )
848 {
849 wxMacCFRefHolder<CGColorSpaceRef> patternSpace( CGColorSpaceCreatePattern( wxMacGetGenericRGBColorSpace() ) ) ;
850 CGContextSetFillColorSpace( m_cgContext , patternSpace ) ;
851 wxMacCFRefHolder<CGPatternRef> pattern( *( new HatchPattern( brush.GetStyle() , CGContextGetCTM( m_cgContext ) ) ) );
852
853 CGFloat colorArray[4] = { brush.GetColour().Red() / 255.0 , brush.GetColour().Green() / 255.0 ,
854 brush.GetColour().Blue() / 255.0 , brush.GetColour().Alpha() / 255.0 } ;
855
856 CGContextSetFillPattern( m_cgContext, pattern , colorArray ) ;
857 }
858 else
859 {
860 // now brush is a bitmap
861 CGFloat alphaArray[1] = { 1.0 } ;
862 wxBitmap* bmp = brush.GetStipple() ;
863 if ( bmp && bmp->Ok() )
864 {
865 wxMacCFRefHolder<CGColorSpaceRef> patternSpace( CGColorSpaceCreatePattern( NULL ) ) ;
866 CGContextSetFillColorSpace( m_cgContext , patternSpace ) ;
867 wxMacCFRefHolder<CGPatternRef> pattern( *( new ImagePattern( bmp , CGContextGetCTM( m_cgContext ) ) ) );
868 CGContextSetFillPattern( m_cgContext, pattern , alphaArray ) ;
869 }
870 }
871
872 m_mode = kCGPathFill ;
873 }
874
875 if ( fill && stroke )
876 m_mode = kCGPathFillStroke ;
877 else if ( stroke )
878 m_mode = kCGPathStroke ;
879 }
880 }
881
882 void wxMacCGContext::DrawText( const wxString &str, wxCoord x, wxCoord y, double angle )
883 {
884 OSStatus status = noErr ;
885 ATSUTextLayout atsuLayout ;
886 UniCharCount chars = str.length() ;
887 UniChar* ubuf = NULL ;
888
889 #if SIZEOF_WCHAR_T == 4
890 wxMBConvUTF16 converter ;
891 #if wxUSE_UNICODE
892 size_t unicharlen = converter.WC2MB( NULL , str.wc_str() , 0 ) ;
893 ubuf = (UniChar*) malloc( unicharlen + 2 ) ;
894 converter.WC2MB( (char*) ubuf , str.wc_str(), unicharlen + 2 ) ;
895 #else
896 const wxWCharBuffer wchar = str.wc_str( wxConvLocal ) ;
897 size_t unicharlen = converter.WC2MB( NULL , wchar.data() , 0 ) ;
898 ubuf = (UniChar*) malloc( unicharlen + 2 ) ;
899 converter.WC2MB( (char*) ubuf , wchar.data() , unicharlen + 2 ) ;
900 #endif
901 chars = unicharlen / 2 ;
902 #else
903 #if wxUSE_UNICODE
904 ubuf = (UniChar*) str.wc_str() ;
905 #else
906 wxWCharBuffer wchar = str.wc_str( wxConvLocal ) ;
907 chars = wxWcslen( wchar.data() ) ;
908 ubuf = (UniChar*) wchar.data() ;
909 #endif
910 #endif
911
912 status = ::ATSUCreateTextLayoutWithTextPtr( (UniCharArrayPtr) ubuf , 0 , chars , chars , 1 ,
913 &chars , (ATSUStyle*) &m_macATSUIStyle , &atsuLayout ) ;
914
915 wxASSERT_MSG( status == noErr , wxT("couldn't create the layout of the rotated text") );
916
917 status = ::ATSUSetTransientFontMatching( atsuLayout , true ) ;
918 wxASSERT_MSG( status == noErr , wxT("couldn't setup transient font matching") );
919
920 int iAngle = int( angle );
921 if ( abs(iAngle) > 0 )
922 {
923 Fixed atsuAngle = IntToFixed( iAngle ) ;
924 ATSUAttributeTag atsuTags[] =
925 {
926 kATSULineRotationTag ,
927 } ;
928 ByteCount atsuSizes[sizeof(atsuTags) / sizeof(ATSUAttributeTag)] =
929 {
930 sizeof( Fixed ) ,
931 } ;
932 ATSUAttributeValuePtr atsuValues[sizeof(atsuTags) / sizeof(ATSUAttributeTag)] =
933 {
934 &atsuAngle ,
935 } ;
936 status = ::ATSUSetLayoutControls(atsuLayout , sizeof(atsuTags) / sizeof(ATSUAttributeTag),
937 atsuTags, atsuSizes, atsuValues ) ;
938 }
939
940 {
941 ATSUAttributeTag atsuTags[] =
942 {
943 kATSUCGContextTag ,
944 } ;
945 ByteCount atsuSizes[sizeof(atsuTags) / sizeof(ATSUAttributeTag)] =
946 {
947 sizeof( CGContextRef ) ,
948 } ;
949 ATSUAttributeValuePtr atsuValues[sizeof(atsuTags) / sizeof(ATSUAttributeTag)] =
950 {
951 &m_cgContext ,
952 } ;
953 status = ::ATSUSetLayoutControls(atsuLayout , sizeof(atsuTags) / sizeof(ATSUAttributeTag),
954 atsuTags, atsuSizes, atsuValues ) ;
955 }
956
957 ATSUTextMeasurement textBefore, textAfter ;
958 ATSUTextMeasurement ascent, descent ;
959
960 status = ::ATSUGetUnjustifiedBounds( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd,
961 &textBefore , &textAfter, &ascent , &descent );
962
963 wxASSERT_MSG( status == noErr , wxT("couldn't measure the rotated text") );
964
965 Rect rect ;
966 /*
967 // TODO
968 if ( m_backgroundMode == wxSOLID )
969 {
970 wxGraphicPath* path = m_graphicContext->CreatePath() ;
971 path->MoveToPoint( drawX , drawY ) ;
972 path->AddLineToPoint(
973 (int) (drawX + sin(angle / RAD2DEG) * FixedToInt(ascent + descent)) ,
974 (int) (drawY + cos(angle / RAD2DEG) * FixedToInt(ascent + descent)) ) ;
975 path->AddLineToPoint(
976 (int) (drawX + sin(angle / RAD2DEG) * FixedToInt(ascent + descent ) + cos(angle / RAD2DEG) * FixedToInt(textAfter)) ,
977 (int) (drawY + cos(angle / RAD2DEG) * FixedToInt(ascent + descent) - sin(angle / RAD2DEG) * FixedToInt(textAfter)) ) ;
978 path->AddLineToPoint(
979 (int) (drawX + cos(angle / RAD2DEG) * FixedToInt(textAfter)) ,
980 (int) (drawY - sin(angle / RAD2DEG) * FixedToInt(textAfter)) ) ;
981
982 m_graphicContext->FillPath( path , m_textBackgroundColour ) ;
983 delete path ;
984 }
985 */
986 x += (int)(sin(angle / RAD2DEG) * FixedToInt(ascent));
987 y += (int)(cos(angle / RAD2DEG) * FixedToInt(ascent));
988
989 status = ::ATSUMeasureTextImage( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd,
990 IntToFixed(x) , IntToFixed(y) , &rect );
991 wxASSERT_MSG( status == noErr , wxT("couldn't measure the rotated text") );
992
993 CGContextSaveGState(m_cgContext);
994 CGContextTranslateCTM(m_cgContext, x, y);
995 CGContextScaleCTM(m_cgContext, 1, -1);
996 status = ::ATSUDrawText( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd,
997 IntToFixed(0) , IntToFixed(0) );
998
999 wxASSERT_MSG( status == noErr , wxT("couldn't draw the rotated text") );
1000
1001 CGContextRestoreGState(m_cgContext) ;
1002
1003 ::ATSUDisposeTextLayout(atsuLayout);
1004
1005 #if SIZEOF_WCHAR_T == 4
1006 free( ubuf ) ;
1007 #endif
1008 }
1009
1010 void wxMacCGContext::GetTextExtent( const wxString &str, wxCoord *width, wxCoord *height,
1011 wxCoord *descent, wxCoord *externalLeading ) const
1012 {
1013 wxCHECK_RET( m_macATSUIStyle != NULL, wxT("wxDC(cg)::DoGetTextExtent - no valid font set") ) ;
1014
1015 OSStatus status = noErr ;
1016
1017 ATSUTextLayout atsuLayout ;
1018 UniCharCount chars = str.length() ;
1019 UniChar* ubuf = NULL ;
1020
1021 #if SIZEOF_WCHAR_T == 4
1022 wxMBConvUTF16 converter ;
1023 #if wxUSE_UNICODE
1024 size_t unicharlen = converter.WC2MB( NULL , str.wc_str() , 0 ) ;
1025 ubuf = (UniChar*) malloc( unicharlen + 2 ) ;
1026 converter.WC2MB( (char*) ubuf , str.wc_str(), unicharlen + 2 ) ;
1027 #else
1028 const wxWCharBuffer wchar = str.wc_str( wxConvLocal ) ;
1029 size_t unicharlen = converter.WC2MB( NULL , wchar.data() , 0 ) ;
1030 ubuf = (UniChar*) malloc( unicharlen + 2 ) ;
1031 converter.WC2MB( (char*) ubuf , wchar.data() , unicharlen + 2 ) ;
1032 #endif
1033 chars = unicharlen / 2 ;
1034 #else
1035 #if wxUSE_UNICODE
1036 ubuf = (UniChar*) str.wc_str() ;
1037 #else
1038 wxWCharBuffer wchar = str.wc_str( wxConvLocal ) ;
1039 chars = wxWcslen( wchar.data() ) ;
1040 ubuf = (UniChar*) wchar.data() ;
1041 #endif
1042 #endif
1043
1044 status = ::ATSUCreateTextLayoutWithTextPtr( (UniCharArrayPtr) ubuf , 0 , chars , chars , 1 ,
1045 &chars , (ATSUStyle*) &m_macATSUIStyle , &atsuLayout ) ;
1046
1047 wxASSERT_MSG( status == noErr , wxT("couldn't create the layout of the text") );
1048
1049 ATSUTextMeasurement textBefore, textAfter ;
1050 ATSUTextMeasurement textAscent, textDescent ;
1051
1052 status = ::ATSUGetUnjustifiedBounds( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd,
1053 &textBefore , &textAfter, &textAscent , &textDescent );
1054
1055 if ( height )
1056 *height = FixedToInt(textAscent + textDescent) ;
1057 if ( descent )
1058 *descent = FixedToInt(textDescent) ;
1059 if ( externalLeading )
1060 *externalLeading = 0 ;
1061 if ( width )
1062 *width = FixedToInt(textAfter - textBefore) ;
1063
1064 ::ATSUDisposeTextLayout(atsuLayout);
1065 }
1066
1067 void wxMacCGContext::GetPartialTextExtents(const wxString& text, wxArrayInt& widths) const
1068 {
1069 widths.Empty();
1070 widths.Add(0, text.length());
1071
1072 if (text.empty())
1073 return ;
1074
1075 ATSUTextLayout atsuLayout ;
1076 UniCharCount chars = text.length() ;
1077 UniChar* ubuf = NULL ;
1078
1079 #if SIZEOF_WCHAR_T == 4
1080 wxMBConvUTF16 converter ;
1081 #if wxUSE_UNICODE
1082 size_t unicharlen = converter.WC2MB( NULL , text.wc_str() , 0 ) ;
1083 ubuf = (UniChar*) malloc( unicharlen + 2 ) ;
1084 converter.WC2MB( (char*) ubuf , text.wc_str(), unicharlen + 2 ) ;
1085 #else
1086 const wxWCharBuffer wchar = text.wc_str( wxConvLocal ) ;
1087 size_t unicharlen = converter.WC2MB( NULL , wchar.data() , 0 ) ;
1088 ubuf = (UniChar*) malloc( unicharlen + 2 ) ;
1089 converter.WC2MB( (char*) ubuf , wchar.data() , unicharlen + 2 ) ;
1090 #endif
1091 chars = unicharlen / 2 ;
1092 #else
1093 #if wxUSE_UNICODE
1094 ubuf = (UniChar*) text.wc_str() ;
1095 #else
1096 wxWCharBuffer wchar = text.wc_str( wxConvLocal ) ;
1097 chars = wxWcslen( wchar.data() ) ;
1098 ubuf = (UniChar*) wchar.data() ;
1099 #endif
1100 #endif
1101
1102 ::ATSUCreateTextLayoutWithTextPtr( (UniCharArrayPtr) ubuf , 0 , chars , chars , 1 ,
1103 &chars , (ATSUStyle*) &m_macATSUIStyle , &atsuLayout ) ;
1104
1105 for ( int pos = 0; pos < (int)chars; pos ++ )
1106 {
1107 unsigned long actualNumberOfBounds = 0;
1108 ATSTrapezoid glyphBounds;
1109
1110 // We get a single bound, since the text should only require one. If it requires more, there is an issue
1111 OSStatus result;
1112 result = ATSUGetGlyphBounds( atsuLayout, 0, 0, kATSUFromTextBeginning, pos + 1,
1113 kATSUseDeviceOrigins, 1, &glyphBounds, &actualNumberOfBounds );
1114 if (result != noErr || actualNumberOfBounds != 1 )
1115 return ;
1116
1117 widths[pos] = FixedToInt( glyphBounds.upperRight.x - glyphBounds.upperLeft.x );
1118 //unsigned char uch = s[i];
1119 }
1120
1121 ::ATSUDisposeTextLayout(atsuLayout);
1122 }
1123
1124 void wxMacCGContext::SetFont( const wxFont &font )
1125 {
1126 if ( m_macATSUIStyle )
1127 {
1128 ::ATSUDisposeStyle((ATSUStyle)m_macATSUIStyle);
1129 m_macATSUIStyle = NULL ;
1130 }
1131
1132 if ( font.Ok() )
1133 {
1134 OSStatus status ;
1135
1136 status = ATSUCreateAndCopyStyle( (ATSUStyle) font.MacGetATSUStyle() , (ATSUStyle*) &m_macATSUIStyle ) ;
1137
1138 wxASSERT_MSG( status == noErr, wxT("couldn't create ATSU style") ) ;
1139
1140 // we need the scale here ...
1141
1142 Fixed atsuSize = IntToFixed( int( /*m_scaleY*/ 1 * font.MacGetFontSize()) ) ;
1143 RGBColor atsuColor = MAC_WXCOLORREF( m_textForegroundColor.GetPixel() ) ;
1144 ATSUAttributeTag atsuTags[] =
1145 {
1146 kATSUSizeTag ,
1147 kATSUColorTag ,
1148 } ;
1149 ByteCount atsuSizes[sizeof(atsuTags) / sizeof(ATSUAttributeTag)] =
1150 {
1151 sizeof( Fixed ) ,
1152 sizeof( RGBColor ) ,
1153 } ;
1154 ATSUAttributeValuePtr atsuValues[sizeof(atsuTags) / sizeof(ATSUAttributeTag)] =
1155 {
1156 &atsuSize ,
1157 &atsuColor ,
1158 } ;
1159
1160 status = ::ATSUSetAttributes(
1161 (ATSUStyle)m_macATSUIStyle, sizeof(atsuTags) / sizeof(ATSUAttributeTag) ,
1162 atsuTags, atsuSizes, atsuValues);
1163
1164 wxASSERT_MSG( status == noErr , wxT("couldn't modify ATSU style") ) ;
1165 }
1166 }
1167
1168
1169 #pragma mark -
1170
1171 wxDC::wxDC()
1172 {
1173 m_ok = false ;
1174 m_colour = true;
1175 m_mm_to_pix_x = mm2pt;
1176 m_mm_to_pix_y = mm2pt;
1177
1178 m_externalDeviceOriginX = 0;
1179 m_externalDeviceOriginY = 0;
1180 m_logicalScaleX = 1.0;
1181 m_logicalScaleY = 1.0;
1182 m_userScaleX = 1.0;
1183 m_userScaleY = 1.0;
1184 m_scaleX = 1.0;
1185 m_scaleY = 1.0;
1186 m_needComputeScaleX =
1187 m_needComputeScaleY = false;
1188
1189 m_macPort = 0 ;
1190 m_macLocalOrigin.x =
1191 m_macLocalOrigin.y = 0 ;
1192
1193 m_pen = *wxBLACK_PEN;
1194 m_font = *wxNORMAL_FONT;
1195 m_brush = *wxWHITE_BRUSH;
1196
1197 m_macATSUIStyle = NULL ;
1198 m_graphicContext = NULL ;
1199 }
1200
1201 wxDC::~wxDC()
1202 {
1203 if ( m_macATSUIStyle )
1204 {
1205 ::ATSUDisposeStyle((ATSUStyle)m_macATSUIStyle);
1206 m_macATSUIStyle = NULL ;
1207 }
1208
1209 delete m_graphicContext ;
1210 }
1211
1212 void wxDC::DoDrawBitmap( const wxBitmap &bmp, wxCoord x, wxCoord y, bool useMask )
1213 {
1214 wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoDrawBitmap - invalid DC") );
1215 wxCHECK_RET( bmp.Ok(), wxT("wxDC(cg)::DoDrawBitmap - invalid bitmap") );
1216
1217 wxCoord xx = XLOG2DEVMAC(x);
1218 wxCoord yy = YLOG2DEVMAC(y);
1219 wxCoord w = bmp.GetWidth();
1220 wxCoord h = bmp.GetHeight();
1221 wxCoord ww = XLOG2DEVREL(w);
1222 wxCoord hh = YLOG2DEVREL(h);
1223
1224 if ( bmp.GetDepth()==1 )
1225 {
1226 wxGraphicPath* path = m_graphicContext->CreatePath() ;
1227 path->AddRectangle( xx , yy , ww , hh ) ;
1228 m_graphicContext->FillPath( path , m_textBackgroundColour, wxODDEVEN_RULE) ;
1229 delete path;
1230 m_graphicContext->DrawBitmap( bmp, xx , yy , ww , hh ) ;
1231 }
1232 else
1233 {
1234 m_graphicContext->DrawBitmap( bmp, xx , yy , ww , hh ) ;
1235 }
1236 }
1237
1238 void wxDC::DoDrawIcon( const wxIcon &icon, wxCoord x, wxCoord y )
1239 {
1240 wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoDrawIcon - invalid DC") );
1241 wxCHECK_RET( icon.Ok(), wxT("wxDC(cg)::DoDrawIcon - invalid icon") );
1242
1243 wxCoord xx = XLOG2DEVMAC(x);
1244 wxCoord yy = YLOG2DEVMAC(y);
1245 wxCoord w = icon.GetWidth();
1246 wxCoord h = icon.GetHeight();
1247 wxCoord ww = XLOG2DEVREL(w);
1248 wxCoord hh = YLOG2DEVREL(h);
1249
1250 m_graphicContext->DrawIcon( icon , xx, yy, ww, hh ) ;
1251 }
1252
1253 void wxDC::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
1254 {
1255 wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoSetClippingRegion - invalid DC") );
1256
1257 wxCoord xx, yy, ww, hh;
1258 xx = XLOG2DEVMAC(x);
1259 yy = YLOG2DEVMAC(y);
1260 ww = XLOG2DEVREL(width);
1261 hh = YLOG2DEVREL(height);
1262
1263 CGContextRef cgContext = ((wxMacCGContext*)(m_graphicContext))->GetNativeContext() ;
1264 CGRect clipRect = CGRectMake( xx , yy , ww, hh ) ;
1265 CGContextClipToRect( cgContext , clipRect ) ;
1266
1267 // SetRectRgn( (RgnHandle) m_macCurrentClipRgn , xx , yy , xx + ww , yy + hh ) ;
1268 // SectRgn( (RgnHandle) m_macCurrentClipRgn , (RgnHandle) m_macBoundaryClipRgn , (RgnHandle) m_macCurrentClipRgn ) ;
1269
1270 if ( m_clipping )
1271 {
1272 m_clipX1 = wxMax( m_clipX1, xx );
1273 m_clipY1 = wxMax( m_clipY1, yy );
1274 m_clipX2 = wxMin( m_clipX2, (xx + ww) );
1275 m_clipY2 = wxMin( m_clipY2, (yy + hh) );
1276 }
1277 else
1278 {
1279 m_clipping = true;
1280
1281 m_clipX1 = xx;
1282 m_clipY1 = yy;
1283 m_clipX2 = xx + ww;
1284 m_clipY2 = yy + hh;
1285 }
1286
1287 // TODO: as soon as we don't reset the context for each operation anymore
1288 // we have to update the context as well
1289 }
1290
1291 void wxDC::DoSetClippingRegionAsRegion( const wxRegion &region )
1292 {
1293 wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoSetClippingRegionAsRegion - invalid DC") );
1294
1295 if (region.Empty())
1296 {
1297 DestroyClippingRegion();
1298 return;
1299 }
1300
1301 wxCoord x, y, w, h;
1302 region.GetBox( x, y, w, h );
1303 wxCoord xx, yy, ww, hh;
1304 xx = XLOG2DEVMAC(x);
1305 yy = YLOG2DEVMAC(y);
1306 ww = XLOG2DEVREL(w);
1307 hh = YLOG2DEVREL(h);
1308
1309 // if we have a scaling that we cannot map onto native regions
1310 // we must use the box
1311 if ( ww != w || hh != h )
1312 {
1313 wxDC::DoSetClippingRegion( x, y, w, h );
1314 }
1315 else
1316 {
1317 if ( m_clipping )
1318 {
1319 m_clipX1 = wxMax( m_clipX1, xx );
1320 m_clipY1 = wxMax( m_clipY1, yy );
1321 m_clipX2 = wxMin( m_clipX2, (xx + ww) );
1322 m_clipY2 = wxMin( m_clipY2, (yy + hh) );
1323 }
1324 else
1325 {
1326 m_clipping = true;
1327
1328 m_clipX1 = xx;
1329 m_clipY1 = yy;
1330 m_clipX2 = xx + ww;
1331 m_clipY2 = yy + hh;
1332 }
1333 }
1334 }
1335
1336 void wxDC::DestroyClippingRegion()
1337 {
1338 CGContextRef cgContext = ((wxMacCGContext*)(m_graphicContext))->GetNativeContext() ;
1339 CGContextRestoreGState( cgContext );
1340 CGContextSaveGState( cgContext );
1341
1342 m_graphicContext->SetPen( m_pen ) ;
1343 m_graphicContext->SetBrush( m_brush ) ;
1344
1345 m_clipping = false;
1346 }
1347
1348 void wxDC::DoGetSizeMM( int* width, int* height ) const
1349 {
1350 int w = 0, h = 0;
1351
1352 GetSize( &w, &h );
1353 if (width)
1354 *width = long( double(w) / (m_scaleX * m_mm_to_pix_x) );
1355 if (height)
1356 *height = long( double(h) / (m_scaleY * m_mm_to_pix_y) );
1357 }
1358
1359 void wxDC::SetTextForeground( const wxColour &col )
1360 {
1361 wxCHECK_RET( Ok(), wxT("wxDC(cg)::SetTextForeground - invalid DC") );
1362
1363 if ( col != m_textForegroundColour )
1364 {
1365 m_textForegroundColour = col;
1366 m_graphicContext->SetTextColor( col );
1367 // in the current implementation the font contains the text color
1368 m_graphicContext->SetFont(m_font);
1369 }
1370 }
1371
1372 void wxDC::SetTextBackground( const wxColour &col )
1373 {
1374 wxCHECK_RET( Ok(), wxT("wxDC(cg)::SetTextBackground - invalid DC") );
1375
1376 m_textBackgroundColour = col;
1377 }
1378
1379 void wxDC::SetMapMode( int mode )
1380 {
1381 switch (mode)
1382 {
1383 case wxMM_TWIPS:
1384 SetLogicalScale( twips2mm * m_mm_to_pix_x, twips2mm * m_mm_to_pix_y );
1385 break;
1386
1387 case wxMM_POINTS:
1388 SetLogicalScale( pt2mm * m_mm_to_pix_x, pt2mm * m_mm_to_pix_y );
1389 break;
1390
1391 case wxMM_METRIC:
1392 SetLogicalScale( m_mm_to_pix_x, m_mm_to_pix_y );
1393 break;
1394
1395 case wxMM_LOMETRIC:
1396 SetLogicalScale( m_mm_to_pix_x / 10.0, m_mm_to_pix_y / 10.0 );
1397 break;
1398
1399 case wxMM_TEXT:
1400 default:
1401 SetLogicalScale( 1.0, 1.0 );
1402 break;
1403 }
1404
1405 if (mode != wxMM_TEXT)
1406 {
1407 m_needComputeScaleX =
1408 m_needComputeScaleY = true;
1409 }
1410 }
1411
1412 void wxDC::SetUserScale( double x, double y )
1413 {
1414 // allow negative ? -> no
1415 m_userScaleX = x;
1416 m_userScaleY = y;
1417 ComputeScaleAndOrigin();
1418 }
1419
1420 void wxDC::SetLogicalScale( double x, double y )
1421 {
1422 // allow negative ?
1423 m_logicalScaleX = x;
1424 m_logicalScaleY = y;
1425 ComputeScaleAndOrigin();
1426 }
1427
1428 void wxDC::SetLogicalOrigin( wxCoord x, wxCoord y )
1429 {
1430 m_logicalOriginX = x * m_signX; // is this still correct ?
1431 m_logicalOriginY = y * m_signY;
1432 ComputeScaleAndOrigin();
1433 }
1434
1435 void wxDC::SetDeviceOrigin( wxCoord x, wxCoord y )
1436 {
1437 m_externalDeviceOriginX = x;
1438 m_externalDeviceOriginY = y;
1439 ComputeScaleAndOrigin();
1440 }
1441
1442 void wxDC::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
1443 {
1444 m_signX = (xLeftRight ? 1 : -1);
1445 m_signY = (yBottomUp ? -1 : 1);
1446 ComputeScaleAndOrigin();
1447 }
1448
1449 wxSize wxDC::GetPPI() const
1450 {
1451 return wxSize(72, 72);
1452 }
1453
1454 int wxDC::GetDepth() const
1455 {
1456 return 32;
1457 }
1458
1459 void wxDC::ComputeScaleAndOrigin()
1460 {
1461 // CMB: copy scale to see if it changes
1462 double origScaleX = m_scaleX;
1463 double origScaleY = m_scaleY;
1464 m_scaleX = m_logicalScaleX * m_userScaleX;
1465 m_scaleY = m_logicalScaleY * m_userScaleY;
1466 m_deviceOriginX = m_externalDeviceOriginX;
1467 m_deviceOriginY = m_externalDeviceOriginY;
1468
1469 // CMB: if scale has changed call SetPen to recalulate the line width
1470 if (m_scaleX != origScaleX || m_scaleY != origScaleY)
1471 {
1472 // this is a bit artificial, but we need to force wxDC to think
1473 // the pen has changed
1474 wxPen pen( GetPen() );
1475
1476 m_pen = wxNullPen;
1477 SetPen( pen );
1478 }
1479 }
1480
1481 void wxDC::SetPalette( const wxPalette& palette )
1482 {
1483 }
1484
1485 void wxDC::SetBackgroundMode( int mode )
1486 {
1487 m_backgroundMode = mode ;
1488 }
1489
1490 void wxDC::SetFont( const wxFont &font )
1491 {
1492 m_font = font;
1493 if ( m_graphicContext )
1494 m_graphicContext->SetFont( font ) ;
1495 }
1496
1497 void wxDC::SetPen( const wxPen &pen )
1498 {
1499 if ( m_pen == pen )
1500 return ;
1501
1502 m_pen = pen;
1503 if ( m_graphicContext )
1504 {
1505 if ( m_pen.GetStyle() == wxSOLID || m_pen.GetStyle() == wxTRANSPARENT )
1506 {
1507 m_graphicContext->SetPen( m_pen ) ;
1508 }
1509 else
1510 {
1511 // we have to compensate for moved device origins etc. otherwise patterned pens are standing still
1512 // eg when using a wxScrollWindow and scrolling around
1513 int origX = XLOG2DEVMAC( 0 ) ;
1514 int origY = YLOG2DEVMAC( 0 ) ;
1515 m_graphicContext->Translate( origX , origY ) ;
1516 m_graphicContext->SetPen( m_pen ) ;
1517 m_graphicContext->Translate( -origX , -origY ) ;
1518 }
1519 }
1520 }
1521
1522 void wxDC::SetBrush( const wxBrush &brush )
1523 {
1524 if (m_brush == brush)
1525 return;
1526
1527 m_brush = brush;
1528 if ( m_graphicContext )
1529 {
1530 if ( brush.GetStyle() == wxSOLID || brush.GetStyle() == wxTRANSPARENT )
1531 {
1532 m_graphicContext->SetBrush( m_brush ) ;
1533 }
1534 else
1535 {
1536 // we have to compensate for moved device origins etc. otherwise patterned brushes are standing still
1537 // eg when using a wxScrollWindow and scrolling around
1538 int origX = XLOG2DEVMAC(0) ;
1539 int origY = YLOG2DEVMAC(0) ;
1540 m_graphicContext->Translate( origX , origY ) ;
1541 m_graphicContext->SetBrush( m_brush ) ;
1542 m_graphicContext->Translate( -origX , -origY ) ;
1543 }
1544 }
1545 }
1546
1547 void wxDC::SetBackground( const wxBrush &brush )
1548 {
1549 if (m_backgroundBrush == brush)
1550 return;
1551
1552 m_backgroundBrush = brush;
1553 if (!m_backgroundBrush.Ok())
1554 return;
1555 }
1556
1557 void wxDC::SetLogicalFunction( int function )
1558 {
1559 if (m_logicalFunction == function)
1560 return;
1561
1562 m_logicalFunction = function ;
1563 #if wxMAC_USE_CORE_GRAPHICS_BLEND_MODES
1564 CGContextRef cgContext = ((wxMacCGContext*)(m_graphicContext))->GetNativeContext() ;
1565 if ( m_logicalFunction == wxCOPY )
1566 CGContextSetBlendMode( cgContext, kCGBlendModeNormal ) ;
1567 else if ( m_logicalFunction == wxINVERT )
1568 CGContextSetBlendMode( cgContext, kCGBlendModeExclusion ) ;
1569 else
1570 CGContextSetBlendMode( cgContext, kCGBlendModeNormal ) ;
1571 #endif
1572 }
1573
1574 extern bool wxDoFloodFill(wxDC *dc, wxCoord x, wxCoord y,
1575 const wxColour & col, int style);
1576
1577 bool wxDC::DoFloodFill(wxCoord x, wxCoord y,
1578 const wxColour& col, int style)
1579 {
1580 return wxDoFloodFill(this, x, y, col, style);
1581 }
1582
1583 bool wxDC::DoGetPixel( wxCoord x, wxCoord y, wxColour *col ) const
1584 {
1585 wxCHECK_MSG( Ok(), false, wxT("wxDC(cg)::DoGetPixel - invalid DC") );
1586
1587 RGBColor colour;
1588 #ifndef __LP64__
1589 wxMacPortSaver helper((CGrafPtr)m_macPort) ;
1590 // NB: GetCPixel is a deprecated QD call, and a slow one at that
1591 GetCPixel(
1592 XLOG2DEVMAC(x) + m_macLocalOriginInPort.x - m_macLocalOrigin.x,
1593 YLOG2DEVMAC(y) + m_macLocalOriginInPort.y - m_macLocalOrigin.y, &colour );
1594 #endif
1595 // convert from Mac colour to wx
1596 *col = colour;
1597
1598 return true ;
1599 }
1600
1601 void wxDC::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 )
1602 {
1603 wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoDrawLine - invalid DC") );
1604
1605 #if !wxMAC_USE_CORE_GRAPHICS_BLEND_MODES
1606 if ( m_logicalFunction != wxCOPY )
1607 return ;
1608 #endif
1609
1610 wxCoord xx1 = XLOG2DEVMAC(x1) ;
1611 wxCoord yy1 = YLOG2DEVMAC(y1) ;
1612 wxCoord xx2 = XLOG2DEVMAC(x2) ;
1613 wxCoord yy2 = YLOG2DEVMAC(y2) ;
1614
1615 wxGraphicPath* path = m_graphicContext->CreatePath() ;
1616 path->MoveToPoint( xx1, yy1 ) ;
1617 path->AddLineToPoint( xx2 , yy2 ) ;
1618 path->CloseSubpath() ;
1619 m_graphicContext->StrokePath( path ) ;
1620 delete path ;
1621
1622 CalcBoundingBox(x1, y1);
1623 CalcBoundingBox(x2, y2);
1624 }
1625
1626 void wxDC::DoCrossHair( wxCoord x, wxCoord y )
1627 {
1628 wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoCrossHair - invalid DC") );
1629
1630 if ( m_logicalFunction != wxCOPY )
1631 return ;
1632
1633 int w = 0, h = 0;
1634
1635 GetSize( &w, &h );
1636 wxCoord xx = XLOG2DEVMAC(x);
1637 wxCoord yy = YLOG2DEVMAC(y);
1638
1639 wxGraphicPath* path = m_graphicContext->CreatePath() ;
1640 path->MoveToPoint( XLOG2DEVMAC(0), yy ) ;
1641 path->AddLineToPoint( XLOG2DEVMAC(w), yy ) ;
1642 path->CloseSubpath() ;
1643 path->MoveToPoint( xx, YLOG2DEVMAC(0) ) ;
1644 path->AddLineToPoint( xx, YLOG2DEVMAC(h) ) ;
1645 path->CloseSubpath() ;
1646 m_graphicContext->StrokePath( path ) ;
1647 delete path ;
1648
1649 CalcBoundingBox(x, y);
1650 CalcBoundingBox(x + w, y + h);
1651 }
1652
1653 void wxDC::DoDrawArc( wxCoord x1, wxCoord y1,
1654 wxCoord x2, wxCoord y2,
1655 wxCoord xc, wxCoord yc )
1656 {
1657 wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoDrawArc - invalid DC") );
1658
1659 if ( m_logicalFunction != wxCOPY )
1660 return ;
1661
1662 wxCoord xx1 = XLOG2DEVMAC(x1);
1663 wxCoord yy1 = YLOG2DEVMAC(y1);
1664 wxCoord xx2 = XLOG2DEVMAC(x2);
1665 wxCoord yy2 = YLOG2DEVMAC(y2);
1666 wxCoord xxc = XLOG2DEVMAC(xc);
1667 wxCoord yyc = YLOG2DEVMAC(yc);
1668
1669 double dx = xx1 - xxc;
1670 double dy = yy1 - yyc;
1671 double radius = sqrt((double)(dx * dx + dy * dy));
1672 wxCoord rad = (wxCoord)radius;
1673 double sa, ea;
1674 if (xx1 == xx2 && yy1 == yy2)
1675 {
1676 sa = 0.0;
1677 ea = 360.0;
1678 }
1679 else if (radius == 0.0)
1680 {
1681 sa = ea = 0.0;
1682 }
1683 else
1684 {
1685 sa = (xx1 - xxc == 0) ?
1686 (yy1 - yyc < 0) ? 90.0 : -90.0 :
1687 -atan2(double(yy1 - yyc), double(xx1 - xxc)) * RAD2DEG;
1688 ea = (xx2 - xxc == 0) ?
1689 (yy2 - yyc < 0) ? 90.0 : -90.0 :
1690 -atan2(double(yy2 - yyc), double(xx2 - xxc)) * RAD2DEG;
1691 }
1692
1693 bool fill = m_brush.GetStyle() != wxTRANSPARENT ;
1694
1695 wxGraphicPath* path = m_graphicContext->CreatePath() ;
1696 m_graphicContext->PushState() ;
1697 m_graphicContext->Translate( xxc, yyc ) ;
1698 m_graphicContext->Scale( 1, -1 ) ;
1699 if ( fill )
1700 path->MoveToPoint( 0, 0 ) ;
1701 path->AddArc( 0, 0, rad , DegToRad(sa) , DegToRad(ea), false ) ;
1702 if ( fill )
1703 path->AddLineToPoint( 0, 0 ) ;
1704 m_graphicContext->DrawPath( path ) ;
1705 m_graphicContext->PopState() ;
1706 delete path ;
1707 }
1708
1709 void wxDC::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord w, wxCoord h,
1710 double sa, double ea )
1711 {
1712 wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoDrawEllipticArc - invalid DC") );
1713
1714 if ( m_logicalFunction != wxCOPY )
1715 return ;
1716
1717 wxCoord xx = XLOG2DEVMAC(x);
1718 wxCoord yy = YLOG2DEVMAC(y);
1719 wxCoord ww = m_signX * XLOG2DEVREL(w);
1720 wxCoord hh = m_signY * YLOG2DEVREL(h);
1721
1722 // handle -ve width and/or height
1723 if (ww < 0)
1724 {
1725 ww = -ww;
1726 xx = xx - ww;
1727 }
1728 if (hh < 0)
1729 {
1730 hh = -hh;
1731 yy = yy - hh;
1732 }
1733
1734 bool fill = m_brush.GetStyle() != wxTRANSPARENT ;
1735
1736 wxGraphicPath* path = m_graphicContext->CreatePath() ;
1737 m_graphicContext->PushState() ;
1738 m_graphicContext->Translate( xx + ww / 2, yy + hh / 2 ) ;
1739 m_graphicContext->Scale( 1 * ww / 2 , -1 * hh / 2 ) ;
1740 if ( fill )
1741 path->MoveToPoint( 0, 0 ) ;
1742 path->AddArc( 0, 0, 1 , DegToRad(sa) , DegToRad(ea), false ) ;
1743 if ( fill )
1744 path->AddLineToPoint( 0, 0 ) ;
1745 m_graphicContext->DrawPath( path ) ;
1746 m_graphicContext->PopState() ;
1747 delete path ;
1748 }
1749
1750 void wxDC::DoDrawPoint( wxCoord x, wxCoord y )
1751 {
1752 wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoDrawPoint - invalid DC") );
1753
1754 DoDrawLine( x , y , x + 1 , y + 1 ) ;
1755 }
1756
1757 void wxDC::DoDrawLines(int n, wxPoint points[],
1758 wxCoord xoffset, wxCoord yoffset)
1759 {
1760 wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoDrawLines - invalid DC") );
1761
1762 #if !wxMAC_USE_CORE_GRAPHICS_BLEND_MODES
1763 if ( m_logicalFunction != wxCOPY )
1764 return ;
1765 #endif
1766
1767 wxCoord x1, x2 , y1 , y2 ;
1768 x1 = XLOG2DEVMAC(points[0].x + xoffset);
1769 y1 = YLOG2DEVMAC(points[0].y + yoffset);
1770 wxGraphicPath* path = m_graphicContext->CreatePath() ;
1771 path->MoveToPoint( x1 , y1 ) ;
1772 for (int i = 1; i < n; i++)
1773 {
1774 x2 = XLOG2DEVMAC(points[i].x + xoffset);
1775 y2 = YLOG2DEVMAC(points[i].y + yoffset);
1776
1777 path->AddLineToPoint( x2 , y2 ) ;
1778 }
1779
1780 m_graphicContext->StrokePath( path ) ;
1781 delete path ;
1782 }
1783
1784 #if wxUSE_SPLINES
1785 void wxDC::DoDrawSpline(wxList *points)
1786 {
1787 wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoDrawSpline - invalid DC") );
1788
1789 if ( m_logicalFunction != wxCOPY )
1790 return ;
1791
1792 wxGraphicPath* path = m_graphicContext->CreatePath() ;
1793
1794 wxList::compatibility_iterator node = points->GetFirst();
1795 if (node == wxList::compatibility_iterator())
1796 // empty list
1797 return;
1798
1799 wxPoint *p = (wxPoint *)node->GetData();
1800
1801 wxCoord x1 = p->x;
1802 wxCoord y1 = p->y;
1803
1804 node = node->GetNext();
1805 p = (wxPoint *)node->GetData();
1806
1807 wxCoord x2 = p->x;
1808 wxCoord y2 = p->y;
1809 wxCoord cx1 = ( x1 + x2 ) / 2;
1810 wxCoord cy1 = ( y1 + y2 ) / 2;
1811
1812 path->MoveToPoint( XLOG2DEVMAC( x1 ) , YLOG2DEVMAC( y1 ) ) ;
1813 path->AddLineToPoint( XLOG2DEVMAC( cx1 ) , YLOG2DEVMAC( cy1 ) ) ;
1814
1815 #if !wxUSE_STL
1816 while ((node = node->GetNext()) != NULL)
1817 #else
1818 while ((node = node->GetNext()))
1819 #endif // !wxUSE_STL
1820 {
1821 p = (wxPoint *)node->GetData();
1822 x1 = x2;
1823 y1 = y2;
1824 x2 = p->x;
1825 y2 = p->y;
1826 wxCoord cx4 = (x1 + x2) / 2;
1827 wxCoord cy4 = (y1 + y2) / 2;
1828
1829 path->AddQuadCurveToPoint(
1830 XLOG2DEVMAC( x1 ) , YLOG2DEVMAC( y1 ) ,
1831 XLOG2DEVMAC( cx4 ) , YLOG2DEVMAC( cy4 ) ) ;
1832
1833 cx1 = cx4;
1834 cy1 = cy4;
1835 }
1836
1837 path->AddLineToPoint( XLOG2DEVMAC( x2 ) , YLOG2DEVMAC( y2 ) ) ;
1838
1839 m_graphicContext->StrokePath( path ) ;
1840 delete path ;
1841 }
1842 #endif
1843
1844 void wxDC::DoDrawPolygon( int n, wxPoint points[],
1845 wxCoord xoffset, wxCoord yoffset,
1846 int fillStyle )
1847 {
1848 wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoDrawPolygon - invalid DC") );
1849
1850 if ( n <= 0 || (m_brush.GetStyle() == wxTRANSPARENT && m_pen.GetStyle() == wxTRANSPARENT ) )
1851 return ;
1852 if ( m_logicalFunction != wxCOPY )
1853 return ;
1854
1855 wxCoord x1, x2 , y1 , y2 ;
1856 x2 = x1 = XLOG2DEVMAC(points[0].x + xoffset);
1857 y2 = y1 = YLOG2DEVMAC(points[0].y + yoffset);
1858
1859 wxGraphicPath* path = m_graphicContext->CreatePath() ;
1860 path->MoveToPoint( x1 , y1 ) ;
1861 for (int i = 1; i < n; i++)
1862 {
1863 x2 = XLOG2DEVMAC(points[i].x + xoffset);
1864 y2 = YLOG2DEVMAC(points[i].y + yoffset);
1865
1866 path->AddLineToPoint( x2 , y2 ) ;
1867 }
1868
1869 if ( x1 != x2 || y1 != y2 )
1870 path->AddLineToPoint( x1, y1 ) ;
1871
1872 path->CloseSubpath() ;
1873 m_graphicContext->DrawPath( path , fillStyle ) ;
1874
1875 delete path ;
1876 }
1877
1878 void wxDC::DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
1879 {
1880 wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoDrawRectangle - invalid DC") );
1881
1882 if ( m_logicalFunction != wxCOPY )
1883 return ;
1884
1885 wxCoord xx = XLOG2DEVMAC(x);
1886 wxCoord yy = YLOG2DEVMAC(y);
1887 wxCoord ww = m_signX * XLOG2DEVREL(width);
1888 wxCoord hh = m_signY * YLOG2DEVREL(height);
1889
1890 // CMB: draw nothing if transformed w or h is 0
1891 if (ww == 0 || hh == 0)
1892 return;
1893
1894 // CMB: handle -ve width and/or height
1895 if (ww < 0)
1896 {
1897 ww = -ww;
1898 xx = xx - ww;
1899 }
1900 if (hh < 0)
1901 {
1902 hh = -hh;
1903 yy = yy - hh;
1904 }
1905
1906 int penwidth = m_pen.GetWidth();
1907 if ( penwidth == 0 )
1908 penwidth = 1 ;
1909 if ( m_pen.GetStyle() == wxTRANSPARENT )
1910 penwidth = 0 ;
1911
1912 bool offset = ( penwidth % 2 ) == 1 ;
1913
1914 wxGraphicPath* path = m_graphicContext->CreatePath() ;
1915 // if we are offsetting the entire rectangle is moved 0.5, so the border line gets off by 1
1916 if ( offset )
1917 path->AddRectangle( xx , yy , ww-1 , hh-1 ) ;
1918 else
1919 path->AddRectangle( xx , yy , ww , hh ) ;
1920
1921 m_graphicContext->DrawPath( path ) ;
1922 delete path ;
1923 }
1924
1925 void wxDC::DoDrawRoundedRectangle(wxCoord x, wxCoord y,
1926 wxCoord width, wxCoord height,
1927 double radius)
1928 {
1929 wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoDrawRoundedRectangle - invalid DC") );
1930
1931 if ( m_logicalFunction != wxCOPY )
1932 return ;
1933
1934 if (radius < 0.0)
1935 radius = - radius * ((width < height) ? width : height);
1936 wxCoord xx = XLOG2DEVMAC(x);
1937 wxCoord yy = YLOG2DEVMAC(y);
1938 wxCoord ww = m_signX * XLOG2DEVREL(width);
1939 wxCoord hh = m_signY * YLOG2DEVREL(height);
1940
1941 // CMB: draw nothing if transformed w or h is 0
1942 if (ww == 0 || hh == 0)
1943 return;
1944
1945 // CMB: handle -ve width and/or height
1946 if (ww < 0)
1947 {
1948 ww = -ww;
1949 xx = xx - ww;
1950 }
1951 if (hh < 0)
1952 {
1953 hh = -hh;
1954 yy = yy - hh;
1955 }
1956
1957 wxGraphicPath* path = m_graphicContext->CreatePath() ;
1958 if ( radius == 0)
1959 {
1960 path->AddRectangle( xx , yy , ww , hh ) ;
1961 m_graphicContext->DrawPath( path ) ;
1962 }
1963 else
1964 {
1965 path->MoveToPoint( xx + ww, yy + hh / 2);
1966 path->AddArcToPoint(xx + ww, yy + hh, xx + ww / 2,yy + hh, radius);
1967 path->AddArcToPoint(xx , yy + hh, xx , yy + hh / 2, radius);
1968 path->AddArcToPoint(xx , yy , xx + ww / 2, yy , radius);
1969 path->AddArcToPoint(xx + ww, yy , xx + ww, yy + hh / 2, radius);
1970 path->CloseSubpath();
1971 m_graphicContext->DrawPath( path ) ;
1972 }
1973 delete path ;
1974 }
1975
1976 void wxDC::DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
1977 {
1978 wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoDrawEllipse - invalid DC") );
1979
1980 if ( m_logicalFunction != wxCOPY )
1981 return ;
1982
1983 wxCoord xx = XLOG2DEVMAC(x);
1984 wxCoord yy = YLOG2DEVMAC(y);
1985 wxCoord ww = m_signX * XLOG2DEVREL(width);
1986 wxCoord hh = m_signY * YLOG2DEVREL(height);
1987
1988 // CMB: draw nothing if transformed w or h is 0
1989 if (ww == 0 || hh == 0)
1990 return;
1991
1992 // CMB: handle -ve width and/or height
1993 if (ww < 0)
1994 {
1995 ww = -ww;
1996 xx = xx - ww;
1997 }
1998 if (hh < 0)
1999 {
2000 hh = -hh;
2001 yy = yy - hh;
2002 }
2003
2004 wxGraphicPath* path = m_graphicContext->CreatePath() ;
2005 m_graphicContext->PushState() ;
2006 m_graphicContext->Translate(xx + ww / 2, yy + hh / 2);
2007 m_graphicContext->Scale(ww / 2 , hh / 2);
2008 path->AddArc( 0, 0, 1, 0 , 2 * M_PI , false ) ;
2009 m_graphicContext->DrawPath( path ) ;
2010 m_graphicContext->PopState() ;
2011 delete path ;
2012 }
2013
2014 bool wxDC::CanDrawBitmap() const
2015 {
2016 return true ;
2017 }
2018
2019 bool wxDC::DoBlit(
2020 wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
2021 wxDC *source, wxCoord xsrc, wxCoord ysrc, int logical_func , bool useMask,
2022 wxCoord xsrcMask, wxCoord ysrcMask )
2023 {
2024 wxCHECK_MSG( Ok(), false, wxT("wxDC(cg)::DoBlit - invalid DC") );
2025 wxCHECK_MSG( source->Ok(), false, wxT("wxDC(cg)::DoBlit - invalid source DC") );
2026
2027 if ( logical_func == wxNO_OP )
2028 return true ;
2029
2030 if (xsrcMask == -1 && ysrcMask == -1)
2031 {
2032 xsrcMask = xsrc;
2033 ysrcMask = ysrc;
2034 }
2035
2036 wxCoord yysrc = source->YLOG2DEVMAC(ysrc) ;
2037 wxCoord xxsrc = source->XLOG2DEVMAC(xsrc) ;
2038 wxCoord wwsrc = source->XLOG2DEVREL(width) ;
2039 wxCoord hhsrc = source->YLOG2DEVREL(height) ;
2040
2041 wxCoord yydest = YLOG2DEVMAC(ydest) ;
2042 wxCoord xxdest = XLOG2DEVMAC(xdest) ;
2043 wxCoord wwdest = XLOG2DEVREL(width) ;
2044 wxCoord hhdest = YLOG2DEVREL(height) ;
2045
2046 wxMemoryDC* memdc = dynamic_cast<wxMemoryDC*>(source) ;
2047 if ( memdc && logical_func == wxCOPY )
2048 {
2049 wxBitmap blit = memdc->GetSelectedObject() ;
2050
2051 wxASSERT_MSG( blit.Ok() , wxT("Invalid bitmap for blitting") ) ;
2052
2053 wxCoord bmpwidth = blit.GetWidth();
2054 wxCoord bmpheight = blit.GetHeight();
2055
2056 if ( xxsrc != 0 || yysrc != 0 || bmpwidth != wwsrc || bmpheight != hhsrc )
2057 {
2058 wwsrc = wxMin( wwsrc , bmpwidth - xxsrc ) ;
2059 hhsrc = wxMin( hhsrc , bmpheight - yysrc ) ;
2060 if ( wwsrc > 0 && hhsrc > 0 )
2061 {
2062 if ( xxsrc >= 0 && yysrc >= 0 )
2063 {
2064 wxRect subrect( xxsrc, yysrc, wwsrc , hhsrc ) ;
2065 // TODO we perhaps could add a DrawSubBitmap call to dc for performance reasons
2066 blit = blit.GetSubBitmap( subrect ) ;
2067 }
2068 else
2069 {
2070 // in this case we'd probably have to adjust the different coordinates, but
2071 // we have to find out proper contract first
2072 blit = wxNullBitmap ;
2073 }
2074 }
2075 else
2076 {
2077 blit = wxNullBitmap ;
2078 }
2079 }
2080
2081 if ( blit.Ok() )
2082 {
2083 m_graphicContext->DrawBitmap( blit, xxdest , yydest , wwdest , hhdest ) ;
2084 }
2085 }
2086 else
2087 {
2088 wxFAIL_MSG( wxT("Blitting is only supported from bitmap contexts, and only with wxCOPY logical operation.") ) ;
2089 return false ;
2090 }
2091
2092 return true;
2093 }
2094
2095 void wxDC::DoDrawRotatedText(const wxString& str, wxCoord x, wxCoord y,
2096 double angle)
2097 {
2098 wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoDrawRotatedText - invalid DC") );
2099 // wxCHECK_RET( m_macATSUIStyle != NULL, wxT("wxDC(cg)::DoDrawRotatedText - no valid font set") );
2100
2101 if ( str.length() == 0 )
2102 return ;
2103 if ( m_logicalFunction != wxCOPY )
2104 return ;
2105
2106 int drawX = XLOG2DEVMAC(x) ;
2107 int drawY = YLOG2DEVMAC(y) ;
2108
2109 m_graphicContext->DrawText( str, drawX ,drawY , angle ) ;
2110 }
2111
2112 void wxDC::DoDrawText(const wxString& strtext, wxCoord x, wxCoord y)
2113 {
2114 wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoDrawText - invalid DC") );
2115
2116 DoDrawRotatedText( strtext , x , y , 0.0 ) ;
2117 }
2118
2119 bool wxDC::CanGetTextExtent() const
2120 {
2121 wxCHECK_MSG( Ok(), false, wxT("wxDC(cg)::CanGetTextExtent - invalid DC") );
2122
2123 return true ;
2124 }
2125
2126 void wxDC::DoGetTextExtent( const wxString &str, wxCoord *width, wxCoord *height,
2127 wxCoord *descent, wxCoord *externalLeading ,
2128 wxFont *theFont ) const
2129 {
2130 wxCHECK_RET( Ok(), wxT("wxDC(cg)::DoGetTextExtent - invalid DC") );
2131
2132 if ( theFont )
2133 {
2134 m_graphicContext->SetFont( *theFont ) ;
2135 }
2136
2137 wxCoord h , d , e , w ;
2138
2139 m_graphicContext->GetTextExtent( str, &w, &h, &d, &e ) ;
2140
2141 if ( height )
2142 *height = YDEV2LOGREL( h ) ;
2143 if ( descent )
2144 *descent =YDEV2LOGREL( d);
2145 if ( externalLeading )
2146 *externalLeading = YDEV2LOGREL( e);
2147 if ( width )
2148 *width = XDEV2LOGREL( w ) ;
2149
2150 if ( theFont )
2151 {
2152 m_graphicContext->SetFont( m_font ) ;
2153 }
2154 }
2155
2156 bool wxDC::DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const
2157 {
2158 wxCHECK_MSG( Ok(), false, wxT("wxDC(cg)::DoGetPartialTextExtents - invalid DC") );
2159
2160 m_graphicContext->GetPartialTextExtents( text, widths ) ;
2161 for ( size_t i = 0 ; i < widths.GetCount() ; ++i )
2162 widths[i] = XDEV2LOGREL( widths[i] );
2163
2164 return true;
2165 }
2166
2167 wxCoord wxDC::GetCharWidth(void) const
2168 {
2169 wxCoord width ;
2170 DoGetTextExtent( wxT("g") , &width , NULL , NULL , NULL , NULL ) ;
2171
2172 return width ;
2173 }
2174
2175 wxCoord wxDC::GetCharHeight(void) const
2176 {
2177 wxCoord height ;
2178 DoGetTextExtent( wxT("g") , NULL , &height , NULL , NULL , NULL ) ;
2179
2180 return height ;
2181 }
2182
2183 void wxDC::Clear(void)
2184 {
2185 wxCHECK_RET( Ok(), wxT("wxDC(cg)::Clear - invalid DC") );
2186
2187 if (m_backgroundBrush.Ok() && m_backgroundBrush.GetStyle() != wxTRANSPARENT)
2188 {
2189 HIRect rect = CGRectMake( -10000 , -10000 , 20000 , 20000 ) ;
2190 CGContextRef cg = ((wxMacCGContext*)(m_graphicContext))->GetNativeContext() ;
2191 switch ( m_backgroundBrush.MacGetBrushKind() )
2192 {
2193 case kwxMacBrushTheme :
2194 {
2195 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4
2196 if ( HIThemeSetFill != 0 )
2197 {
2198 HIThemeSetFill( m_backgroundBrush.MacGetTheme(), NULL, cg, kHIThemeOrientationNormal );
2199 CGContextFillRect(cg, rect);
2200
2201 }
2202 else
2203 #endif
2204 {
2205 RGBColor color;
2206 GetThemeBrushAsColor( m_backgroundBrush.MacGetTheme(), 32, true, &color );
2207 CGContextSetRGBFillColor( cg, (CGFloat) color.red / 65536,
2208 (CGFloat) color.green / 65536, (CGFloat) color.blue / 65536, 1 );
2209 CGContextFillRect( cg, rect );
2210 }
2211
2212 // reset to normal value
2213 RGBColor col = MAC_WXCOLORREF( GetBrush().GetColour().GetPixel() ) ;
2214 CGContextSetRGBFillColor( cg, col.red / 65536.0, col.green / 65536.0, col.blue / 65536.0, 1.0 );
2215 }
2216 break ;
2217
2218 case kwxMacBrushThemeBackground :
2219 {
2220 wxFAIL_MSG( wxT("There shouldn't be theme backgrounds under Quartz") ) ;
2221
2222 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_3
2223 if ( UMAGetSystemVersion() >= 0x1030 )
2224 {
2225 HIThemeBackgroundDrawInfo drawInfo ;
2226 drawInfo.version = 0 ;
2227 drawInfo.state = kThemeStateActive ;
2228 drawInfo.kind = m_backgroundBrush.MacGetThemeBackground( NULL ) ;
2229 if ( drawInfo.kind == kThemeBackgroundMetal )
2230 {
2231 HIThemeDrawBackground( &rect, &drawInfo, cg, kHIThemeOrientationNormal ) ;
2232 HIThemeApplyBackground( &rect, &drawInfo, cg, kHIThemeOrientationNormal ) ;
2233 }
2234 }
2235 #endif
2236 }
2237 break ;
2238
2239 case kwxMacBrushColour :
2240 {
2241 // FIXME: doesn't correctly render stippled brushes !!
2242 // FIXME: should this be replaced by ::SetBrush() ??
2243
2244 RGBColor col = MAC_WXCOLORREF( m_backgroundBrush.GetColour().GetPixel()) ;
2245 CGContextSetRGBFillColor( cg , col.red / 65536.0 , col.green / 65536.0 , col.blue / 65536.0 , 1.0 ) ;
2246 CGContextFillRect(cg, rect);
2247
2248 // reset to normal value
2249 col = MAC_WXCOLORREF( GetBrush().GetColour().GetPixel() ) ;
2250 CGContextSetRGBFillColor( cg , col.red / 65536.0 , col.green / 65536.0 , col.blue / 65536.0 , 1.0 ) ;
2251 }
2252 break ;
2253
2254 default :
2255 wxFAIL_MSG( wxT("unknown brush kind") ) ;
2256 break ;
2257 }
2258 }
2259 }
2260
2261 #endif
2262
2263 #pragma mark -
2264
2265 // ---------------------------------------------------------------------------
2266 // coordinates transformations
2267 // ---------------------------------------------------------------------------
2268 /*
2269 wxCoord XLOG2DEVMAC(wxCoord x) const
2270 {
2271 long new_x = x - m_logicalOriginX;
2272 if (new_x > 0)
2273 return (wxCoord)((double)new_x * m_scaleX + 0.5) * m_signX + m_deviceOriginX + m_macLocalOrigin.x;
2274 else
2275 return (wxCoord)((double)new_x * m_scaleX - 0.5) * m_signX + m_deviceOriginX + m_macLocalOrigin.x;
2276 }
2277
2278 wxCoord YLOG2DEVMAC(wxCoord y) const
2279 {
2280 long new_y = y - m_logicalOriginY;
2281 if (new_y > 0)
2282 return (wxCoord)((double)new_y * m_scaleY + 0.5) * m_signY + m_deviceOriginY + m_macLocalOrigin.y;
2283 else
2284 return (wxCoord)((double)new_y * m_scaleY - 0.5) * m_signY + m_deviceOriginY + m_macLocalOrigin.y;
2285 }
2286 */ // TODO
2287 wxCoord wxDCBase::DeviceToLogicalX(wxCoord x) const
2288 {
2289 return wxRound((double)(x - m_deviceOriginX) / m_scaleX) * m_signX + m_logicalOriginX;
2290 }
2291
2292 wxCoord wxDCBase::DeviceToLogicalY(wxCoord y) const
2293 {
2294 return wxRound((double)(y - m_deviceOriginY) / m_scaleY) * m_signY + m_logicalOriginY;
2295 }
2296
2297 wxCoord wxDCBase::DeviceToLogicalXRel(wxCoord x) const
2298 {
2299 return wxRound((double)(x) / m_scaleX);
2300 }
2301
2302 wxCoord wxDCBase::DeviceToLogicalYRel(wxCoord y) const
2303 {
2304 return wxRound((double)(y) / m_scaleY);
2305 }
2306
2307 wxCoord wxDCBase::LogicalToDeviceX(wxCoord x) const
2308 {
2309 return wxRound((double)(x - m_logicalOriginX) * m_scaleX) * m_signX + m_deviceOriginX;
2310 }
2311
2312 wxCoord wxDCBase::LogicalToDeviceY(wxCoord y) const
2313 {
2314 return wxRound((double)(y - m_logicalOriginY) * m_scaleY) * m_signY + m_deviceOriginY;
2315 }
2316
2317 wxCoord wxDCBase::LogicalToDeviceXRel(wxCoord x) const
2318 {
2319 return wxRound((double)(x) * m_scaleX);
2320 }
2321
2322 wxCoord wxDCBase::LogicalToDeviceYRel(wxCoord y) const
2323 {
2324 return wxRound((double)(y) * m_scaleY);
2325 }
2326
2327 #endif // wxMAC_USE_CORE_GRAPHICS
wxWidgets (Impactor)