]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/mac/dc.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
a base for geometry operations
[wxWidgets.git] / src / mac / dc.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: dc.cpp
3// Purpose: wxDC class
4// Author: AUTHOR
5// Modified by:
6// Created: 01/02/97
7// RCS-ID: $Id$
8// Copyright: (c) AUTHOR
9// Licence: wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
12#ifdef __GNUG__
13#pragma implementation "dc.h"
14#endif
15
16#include "wx/dc.h"
17
18IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
19
20//-----------------------------------------------------------------------------
21// constants
22//-----------------------------------------------------------------------------
23
24#define mm2inches 0.0393700787402
25#define inches2mm 25.4
26#define mm2twips 56.6929133859
27#define twips2mm 0.0176388888889
28#define mm2pt 2.83464566929
29#define pt2mm 0.352777777778
30
31long wxDC::m_macCurrentPortId = 1 ;
32
33//-----------------------------------------------------------------------------
34// wxDC
35//-----------------------------------------------------------------------------
36
37wxDC::wxDC(void)
38{
39 m_ok = FALSE;
40 m_optimize = FALSE;
41 m_autoSetting = FALSE;
42 m_colour = TRUE;
43 m_clipping = FALSE;
44
45 m_mm_to_pix_x = 1.0;
46 m_mm_to_pix_y = 1.0;
47
48 m_logicalOriginX = 0;
49 m_logicalOriginY = 0;
50 m_deviceOriginX = 0;
51 m_deviceOriginY = 0;
52 m_internalDeviceOriginX = 0;
53 m_internalDeviceOriginY = 0;
54 m_externalDeviceOriginX = 0;
55 m_externalDeviceOriginY = 0;
56
57 m_logicalScaleX = 1.0;
58 m_logicalScaleY = 1.0;
59 m_userScaleX = 1.0;
60 m_userScaleY = 1.0;
61 m_scaleX = 1.0;
62 m_scaleY = 1.0;
63
64 m_mappingMode = wxMM_TEXT;
65 m_needComputeScaleX = FALSE;
66 m_needComputeScaleY = FALSE;
67
68 m_signX = 1; // default x-axis left to right
69 m_signY = 1; // default y-axis top down
70
71 m_maxX = m_maxY = -100000;
72 m_minY = m_minY = 100000;
73
74 m_logicalFunction = wxCOPY;
75// m_textAlignment = wxALIGN_TOP_LEFT;
76 m_backgroundMode = wxTRANSPARENT;
77
78 m_textForegroundColour = *wxBLACK;
79 m_textBackgroundColour = *wxWHITE;
80 m_pen = *wxBLACK_PEN;
81 m_font = *wxNORMAL_FONT;
82 m_brush = *wxTRANSPARENT_BRUSH;
83 m_backgroundBrush = *wxWHITE_BRUSH;
84
85// m_palette = wxAPP_COLOURMAP;
86 m_macPort = NULL ;
87 m_ok = FALSE ;
88
89 m_macFontInstalled = false ;
90 m_macBrushInstalled = false ;
91 m_macPenInstalled = false ;
92
93 m_macPortId = 0 ;
94 m_macLocalOrigin.h = m_macLocalOrigin.v = 0 ;
95 m_macClipRect.left = -32000 ;
96 m_macClipRect.top = -32000 ;
97 m_macClipRect.right = 32000 ;
98 m_macClipRect.bottom = 32000 ;
99 ::GetPort( &m_macOrigPort ) ;
100};
101
102wxDC::~wxDC(void)
103{
104 if ( m_macPort )
105 {
106 ::SetOrigin( 0 , 0 ) ;
107 ::ClipRect( &m_macPort->portRect ) ;
108 ::PenNormal() ;
109 ::SetPort( m_macOrigPort ) ;
110 }
111 ++m_macCurrentPortId ;
112};
113
114void wxDC::MacSetupPort() const
115{
116 m_macPortId = ++m_macCurrentPortId ;
117 ::SetPort(m_macPort);
118 ::SetOrigin(-m_macLocalOrigin.h, -m_macLocalOrigin.v);
119 ::ClipRect(&m_macClipRect);
120
121 m_macFontInstalled = false ;
122 m_macBrushInstalled = false ;
123 m_macPenInstalled = false ;
124}
125
126void wxDC::DrawBitmap( const wxBitmap &bmp, long x, long y, bool useMask )
127{
128 if (!Ok())
129 return;
130 MacVerifySetup() ;
131
132 long xx1 = XLOG2DEV(x);
133 long yy1 = YLOG2DEV(y);
134
135 {
136 wxBitmapRefData * bmap = (wxBitmapRefData*) ( bmp.GetRefData()) ;
137
138 if ( bmap )
139 {
140 if ( bmap->m_bitmapType == kMacBitmapTypePict )
141 {
142 Rect bitmaprect = { 0 , 0 , bmap->m_height , bmap->m_width } ;
143 ::OffsetRect( &bitmaprect , xx1 , yy1 ) ;
144 ::DrawPicture( bmap->m_hPict , &bitmaprect ) ;
145 }
146 else if ( bmap->m_bitmapType == kMacBitmapTypeGrafWorld )
147 {
148 if ( bmap->m_hBitmap )
149 {
150 GWorldPtr bmapworld = bmap->m_hBitmap ;
151 PixMapHandle bmappixels ;
152 RGBColor white = { 0xFFFF, 0xFFFF,0xFFFF} ;
153 RGBColor black = { 0,0,0} ;
154 RGBForeColor( &black ) ;
155 RGBBackColor( &white ) ;
156 // RGBForeColor( &m_textForegroundColour.GetPixel() ) ;
157 // RGBBackColor( &m_textBackgroundColour.GetPixel() ) ;
158
159 bmappixels = GetGWorldPixMap( bmapworld ) ;
160 if ( LockPixels(bmappixels) )
161 {
162 Rect source , dest ;
163 source.top = 0 ;
164 source.left = 0 ;
165 source.right = bmap->m_width ;
166 source.bottom = bmap->m_height ;
167 dest.top = YLOG2DEV(y) ;
168 dest.left = XLOG2DEV(x) ;
169 dest.bottom = YLOG2DEV(y + bmap->m_height ) ;
170 dest.right = XLOG2DEV(x + bmap->m_width ) ;
171 // ::ClipRect(&m_macClipRect);
172 CopyBits( &GrafPtr( bmapworld )->portBits , &GrafPtr( m_macPort )->portBits ,
173 &source, &dest, srcCopy, NULL ) ;
174 /*
175 if ( m_clipping )
176 {
177 long x1 = XLOG2DEV(m_clipX1);
178 long y1 = YLOG2DEV(m_clipY1);
179 long x2 = XLOG2DEV(m_clipX2);
180 long y2 = YLOG2DEV(m_clipY2);
181
182 Rect clip = { y1 , x1 , y2 , x2 } ;
183 ::ClipRect(&clip);
184 }
185 */
186 UnlockPixels( bmappixels ) ;
187 }
188 m_macPenInstalled = false ;
189 m_macBrushInstalled = false ;
190 m_macFontInstalled = false ;
191 }
192 }
193 }
194 }
195}
196
197void wxDC::DrawIcon( const wxIcon &icon, long x, long y, bool useMask )
198{
199 if (!Ok())
200 return;
201 MacVerifySetup() ;
202
203 long xx1 = XLOG2DEV(x);
204 long yy1 = YLOG2DEV(y);
205
206 {
207 wxIconRefData * iconref = (wxIconRefData*) ( icon.GetRefData()) ;
208
209 if ( iconref && iconref->m_ok && iconref->m_hIcon )
210 {
211 Rect bitmaprect = { 0 , 0 , iconref->m_height , iconref->m_width } ;
212 OffsetRect( &bitmaprect , xx1 , yy1 ) ;
213 PlotCIconHandle( &bitmaprect , atNone , ttNone , iconref->m_hIcon ) ;
214 }
215 }
216};
217
218void wxDC::DrawPoint( wxPoint& point )
219{
220 DrawPoint( point.x, point.y );
221};
222
223void wxDC::DrawPolygon( wxList *list, long xoffset, long yoffset, int fillStyle )
224{
225 int n = list->Number();
226 wxPoint *points = new wxPoint[n];
227
228 int i = 0;
229 for( wxNode *node = list->First(); node; node = node->Next() )
230 {
231 wxPoint *point = (wxPoint *)node->Data();
232 points[i].x = point->x;
233 points[i++].y = point->y;
234 };
235 DrawPolygon( n, points, xoffset, yoffset, fillStyle );
236 delete[] points;
237};
238
239void wxDC::DrawLines( wxList *list, long xoffset, long yoffset )
240{
241 int n = list->Number();
242 wxPoint *points = new wxPoint[n];
243
244 int i = 0;
245 for( wxNode *node = list->First(); node; node = node->Next() )
246 {
247 wxPoint *point = (wxPoint *)node->Data();
248 points[i].x = point->x;
249 points[i++].y = point->y;
250 };
251 DrawLines( n, points, xoffset, yoffset );
252 delete []points;
253};
254
255void wxDC::DrawSpline( long x1, long y1, long x2, long y2, long x3, long y3 )
256{
257 wxList list;
258 list.Append( (wxObject*)new wxPoint(x1, y1) );
259 list.Append( (wxObject*)new wxPoint(x2, y2) );
260 list.Append( (wxObject*)new wxPoint(x3, y3) );
261 DrawSpline(&list);
262 wxNode *node = list.First();
263 while (node)
264 {
265 wxPoint *p = (wxPoint*)node->Data();
266 delete p;
267 node = node->Next();
268 };
269};
270
271void wxDC::DrawSpline( int n, wxPoint points[] )
272{
273 wxList list;
274 for (int i = 0; i < n; i++) list.Append( (wxObject*)&points[i] );
275 DrawSpline( &list );
276};
277
278void wxDC::SetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
279{
280 MacVerifySetup() ;
281 if( m_clipping )
282 {
283 m_clipX1 = wxMax( m_clipX1 , x ) ;
284 m_clipY1 = wxMax( m_clipY1 ,y );
285 m_clipX2 = wxMin( m_clipX2, (x + width));
286 m_clipY2 = wxMin( m_clipY2,(y + height));
287
288 }
289 else
290 {
291 m_clipping = TRUE;
292 m_clipX1 = x;
293 m_clipY1 = y;
294 m_clipX2 = x + width;
295 m_clipY2 = y + height;
296 }
297
298 long x1 = XLOG2DEV(m_clipX1);
299 long y1 = YLOG2DEV(m_clipY1);
300 long x2 = XLOG2DEV(m_clipX2);
301 long y2 = YLOG2DEV(m_clipY2);
302
303 Rect clip = { y1 , x1 , y2 , x2 } ;
304
305 ::ClipRect( &clip ) ;
306
307};
308
309void wxDC::SetClippingRegion(const wxRect& rect)
310{
311 SetClippingRegion(rect.x, rect.y, rect.width, rect.height);
312}
313
314void wxDC::DestroyClippingRegion(void)
315{
316 MacVerifySetup() ;
317 m_clipping = FALSE;
318// Rect clip = { -32000 , -32000 , 32000 , 32000 } ;
319 ::ClipRect(&m_macClipRect);
320};
321
322void wxDC::GetClippingBox( wxCoord *x, wxCoord *y, wxCoord *width, wxCoord *height ) const
323{
324 if (m_clipping)
325 {
326 if (x) *x = m_clipX1;
327 if (y) *y = m_clipY1;
328 if (width) *width = (m_clipX2 - m_clipX1);
329 if (height) *height = (m_clipY2 - m_clipY1);
330 }
331 else
332 *x = *y = *width = *height = 0;
333};
334
335void wxDC::GetClippingBox( long *x, long *y, long *width, long *height ) const
336{
337 if (m_clipping)
338 {
339 if (x) *x = m_clipX1;
340 if (y) *y = m_clipY1;
341 if (width) *width = (m_clipX2 - m_clipX1);
342 if (height) *height = (m_clipY2 - m_clipY1);
343 }
344 else
345 *x = *y = *width = *height = 0;
346};
347
348void wxDC::GetClippingBox(wxRect& rect) const
349{
350 // Necessary to use intermediate variables for 16-bit compilation
351 wxCoord x, y, w, h;
352 GetClippingBox(&x, &y, &w, &h);
353 rect.x = x; rect.y = y; rect.width = w; rect.height = h;
354}
355
356void wxDC::GetSize( int* width, int* height ) const
357{
358 *width = m_maxX-m_minX;
359 *height = m_maxY-m_minY;
360};
361
362void wxDC::GetSizeMM( long* width, long* height ) const
363{
364 int w = 0;
365 int h = 0;
366 GetSize( &w, &h );
367 *width = long( double(w) / (m_scaleX*m_mm_to_pix_x) );
368 *height = long( double(h) / (m_scaleY*m_mm_to_pix_y) );
369};
370
371void wxDC::SetTextForeground( const wxColour &col )
372{
373 if (!Ok()) return;
374 m_textForegroundColour = col;
375 m_macFontInstalled = false ;
376};
377
378void wxDC::SetTextBackground( const wxColour &col )
379{
380 if (!Ok()) return;
381 m_textBackgroundColour = col;
382 m_macFontInstalled = false ;
383};
384
385void wxDC::SetMapMode( int mode )
386{
387 switch (mode)
388 {
389 case wxMM_TWIPS:
390 SetLogicalScale( twips2mm*m_mm_to_pix_x, twips2mm*m_mm_to_pix_y );
391 break;
392 case wxMM_POINTS:
393 SetLogicalScale( pt2mm*m_mm_to_pix_x, pt2mm*m_mm_to_pix_y );
394 break;
395 case wxMM_METRIC:
396 SetLogicalScale( m_mm_to_pix_x, m_mm_to_pix_y );
397 break;
398 case wxMM_LOMETRIC:
399 SetLogicalScale( m_mm_to_pix_x/10.0, m_mm_to_pix_y/10.0 );
400 break;
401 default:
402 case wxMM_TEXT:
403 SetLogicalScale( 1.0, 1.0 );
404 break;
405 };
406 if (mode != wxMM_TEXT)
407 {
408 m_needComputeScaleX = TRUE;
409 m_needComputeScaleY = TRUE;
410 };
411};
412
413void wxDC::SetUserScale( double x, double y )
414{
415 // allow negative ? -> no
416 m_userScaleX = x;
417 m_userScaleY = y;
418 ComputeScaleAndOrigin();
419};
420
421void wxDC::GetUserScale( double *x, double *y )
422{
423 if (x) *x = m_userScaleX;
424 if (y) *y = m_userScaleY;
425};
426
427void wxDC::SetLogicalScale( double x, double y )
428{
429 // allow negative ?
430 m_logicalScaleX = x;
431 m_logicalScaleY = y;
432 ComputeScaleAndOrigin();
433};
434
435void wxDC::GetLogicalScale( double *x, double *y )
436{
437 if (x) *x = m_logicalScaleX;
438 if (y) *y = m_logicalScaleY;
439};
440
441void wxDC::SetLogicalOrigin( long x, long y )
442{
443 m_logicalOriginX = x * m_signX; // is this still correct ?
444 m_logicalOriginY = y * m_signY;
445 ComputeScaleAndOrigin();
446};
447
448void wxDC::GetLogicalOrigin( long *x, long *y )
449{
450 if (x) *x = m_logicalOriginX;
451 if (y) *y = m_logicalOriginY;
452};
453
454void wxDC::SetDeviceOrigin( long x, long y )
455{
456 m_externalDeviceOriginX = x;
457 m_externalDeviceOriginY = y;
458 ComputeScaleAndOrigin();
459};
460
461void wxDC::GetDeviceOrigin( long *x, long *y )
462{
463// if (x) *x = m_externalDeviceOriginX;
464// if (y) *y = m_externalDeviceOriginY;
465 if (x) *x = m_deviceOriginX;
466 if (y) *y = m_deviceOriginY;
467};
468
469void wxDC::SetInternalDeviceOrigin( long x, long y )
470{
471 m_internalDeviceOriginX = x;
472 m_internalDeviceOriginY = y;
473 ComputeScaleAndOrigin();
474};
475
476void wxDC::GetInternalDeviceOrigin( long *x, long *y )
477{
478 if (x) *x = m_internalDeviceOriginX;
479 if (y) *y = m_internalDeviceOriginY;
480};
481
482void wxDC::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
483{
484 m_signX = (xLeftRight ? 1 : -1);
485 m_signY = (yBottomUp ? -1 : 1);
486 ComputeScaleAndOrigin();
487};
488
489long wxDC::DeviceToLogicalX(long x) const
490{
491 return XDEV2LOG(x);
492};
493
494long wxDC::DeviceToLogicalY(long y) const
495{
496 return YDEV2LOG(y);
497};
498
499long wxDC::DeviceToLogicalXRel(long x) const
500{
501 return XDEV2LOGREL(x);
502};
503
504long wxDC::DeviceToLogicalYRel(long y) const
505{
506 return YDEV2LOGREL(y);
507};
508
509long wxDC::LogicalToDeviceX(long x) const
510{
511 return XLOG2DEV(x);
512};
513
514long wxDC::LogicalToDeviceY(long y) const
515{
516 return YLOG2DEV(y);
517};
518
519long wxDC::LogicalToDeviceXRel(long x) const
520{
521 return XLOG2DEVREL(x);
522};
523
524long wxDC::LogicalToDeviceYRel(long y) const
525{
526 return YLOG2DEVREL(y);
527};
528
529void wxDC::CalcBoundingBox( long x, long y )
530{
531 if (x < m_minX) m_minX = x;
532 if (y < m_minY) m_minY = y;
533 if (x > m_maxX) m_maxX = x;
534 if (y > m_maxY) m_maxY = y;
535};
536
537void wxDC::ComputeScaleAndOrigin(void)
538{
539 // CMB: copy scale to see if it changes
540 double origScaleX = m_scaleX;
541 double origScaleY = m_scaleY;
542
543 m_scaleX = m_logicalScaleX * m_userScaleX;
544 m_scaleY = m_logicalScaleY * m_userScaleY;
545
546 m_deviceOriginX = m_internalDeviceOriginX + m_externalDeviceOriginX;
547 m_deviceOriginY = m_internalDeviceOriginY + m_externalDeviceOriginY;
548
549 // CMB: if scale has changed call SetPen to recalulate the line width
550 if (m_scaleX != origScaleX || m_scaleY != origScaleY)
551 {
552 // this is a bit artificial, but we need to force wxDC to think
553 // the pen has changed
554 wxPen* pen = & GetPen();
555 wxPen tempPen;
556 m_pen = tempPen;
557 SetPen(* pen);
558 }
559};
560
561void wxDC::SetPalette( const wxPalette& palette )
562{
563}
564
565void wxDC::SetBackgroundMode( int mode )
566{
567 m_backgroundMode = mode ;
568}
569
570void wxDC::SetFont( const wxFont &font )
571{
572 if (!Ok())
573 return;
574
575 MacVerifySetup() ;
576
577 m_font = font;
578 m_macFontInstalled = false ;
579}
580
581void wxDC::SetPen( const wxPen &pen )
582{
583 if (!Ok() )
584 return;
585
586 MacVerifySetup() ;
587
588 if ( m_pen == pen )
589 return ;
590
591 m_pen = pen;
592/*
593 if (!m_pen.Ok())
594 return;
595*/
596 m_macPenInstalled = false ;
597}
598
599void wxDC::SetBrush( const wxBrush &brush )
600{
601 if (!Ok() )
602 return;
603 MacVerifySetup() ;
604
605 if (m_brush == brush)
606 return;
607
608 m_brush = brush;
609 m_macBrushInstalled = false ;
610}
611
612void wxDC::SetBackground( const wxBrush &brush )
613{
614 if (!Ok())
615 return;
616 MacVerifySetup() ;
617
618 if (m_backgroundBrush == brush)
619 return;
620
621 m_backgroundBrush = brush;
622
623 if (!m_backgroundBrush.Ok())
624 return;
625 m_macBrushInstalled = false ;
626}
627
628void wxDC::SetLogicalFunction( int function )
629{
630 if (m_logicalFunction == function)
631 return;
632
633 m_logicalFunction = function ;
634 m_macFontInstalled = false ;
635 m_macBrushInstalled = false ;
636 m_macPenInstalled = false ;
637}
638
639void wxDC::FloodFill( long x1, long y1, const wxColour& col, int style )
640{
641}
642
643bool wxDC::GetPixel( long x1, long y1, wxColour *col ) const
644{
645 return true ;
646}
647
648void wxDC::DrawLine( long x1, long y1, long x2, long y2 )
649{
650 if (!Ok())
651 return;
652
653 MacVerifySetup() ;
654
655 if (m_pen.GetStyle() != wxTRANSPARENT)
656 {
657 MacInstallPen() ;
658 int offset = (m_pen.GetWidth() - 1) / 2 ;
659 long xx1 = XLOG2DEV(x1);
660 long yy1 = YLOG2DEV(y1);
661 long xx2 = XLOG2DEV(x2);
662 long yy2 = YLOG2DEV(y2);
663
664 ::MoveTo(xx1 - offset ,yy1 - offset);
665 ::LineTo(xx2 - offset , yy2 - offset );
666 };
667}
668
669void wxDC::CrossHair( long x, long y )
670{
671}
672
673void wxDC::DrawArc( long x1, long y1, long x2, long y2, long xc, long yc )
674{
675}
676
677void wxDC::DrawEllipticArc( long x, long y, long width, long height, double sa, double ea )
678{
679}
680
681void wxDC::DrawPoint( long x, long y )
682{
683 if (!Ok())
684 return;
685
686 MacVerifySetup() ;
687
688 if (m_pen.GetStyle() != wxTRANSPARENT)
689 {
690 MacInstallPen() ;
691 long xx1 = XLOG2DEV(x);
692 long yy1 = YLOG2DEV(y);
693
694 ::MoveTo(xx1,yy1);
695 ::LineTo(xx1+1, yy1+1);
696 };
697}
698
699void wxDC::DrawLines( int n, wxPoint points[], long xoffset , long yoffset )
700{
701 if (!Ok())
702 return;
703 MacVerifySetup() ;
704
705 if (m_pen.GetStyle() == wxTRANSPARENT)
706 return;
707
708 MacInstallPen() ;
709
710 int offset = (m_pen.GetWidth() - 1 ) / 2 ;
711 long x1, x2 , y1 , y2 ;
712 x1 = XLOG2DEV(points[0].x + xoffset);
713 y1 = YLOG2DEV(points[0].y + yoffset);
714 ::MoveTo(x1 - offset ,y1 - offset );
715
716 for (int i = 0; i < n-1; i++)
717 {
718 long x2 = XLOG2DEV(points[i+1].x + xoffset);
719 long y2 = YLOG2DEV(points[i+1].y + yoffset);
720 ::LineTo(x2 - offset , y2 - offset );
721 }
722}
723
724void wxDC::DrawPolygon( int n, wxPoint points[], long xoffset , long yoffset ,
725 int fillStyle )
726{
727 if (!Ok())
728 return;
729 MacVerifySetup() ;
730
731 PolyHandle polygon = OpenPoly() ;
732 long x1, x2 , y1 , y2 ;
733 x1 = XLOG2DEV(points[0].x + xoffset);
734 y1 = YLOG2DEV(points[0].y + yoffset);
735 ::MoveTo(x1,y1);
736
737 for (int i = 0; i < n-1; i++)
738 {
739 long x2 = XLOG2DEV(points[i+1].x + xoffset);
740 long y2 = YLOG2DEV(points[i+1].y + yoffset);
741 ::LineTo(x2, y2);
742 }
743
744 ClosePoly() ;
745 if (m_brush.GetStyle() != wxTRANSPARENT)
746 {
747 MacInstallBrush() ;
748 ::PaintPoly( polygon ) ;
749 };
750
751 if (m_pen.GetStyle() != wxTRANSPARENT)
752 {
753 MacInstallPen() ;
754 ::FramePoly( polygon ) ;
755 };
756 KillPoly( polygon ) ;
757}
758
759void wxDC::DrawRectangle( long x, long y, long width, long height )
760{
761 if (!Ok())
762 return;
763 MacVerifySetup() ;
764
765 long xx = XLOG2DEV(x);
766 long yy = YLOG2DEV(y);
767 long ww = m_signX * XLOG2DEVREL(width);
768 long hh = m_signY * YLOG2DEVREL(height);
769
770 // CMB: draw nothing if transformed w or h is 0
771 if (ww == 0 || hh == 0)
772 return;
773
774 // CMB: handle -ve width and/or height
775 if (ww < 0)
776 {
777 ww = -ww;
778 xx = xx - ww;
779 }
780
781 if (hh < 0)
782 {
783 hh = -hh;
784 yy = yy - hh;
785 }
786
787 Rect rect = { yy , xx , yy + hh , xx + ww } ;
788
789 if (m_brush.GetStyle() != wxTRANSPARENT)
790 {
791 MacInstallBrush() ;
792 ::PaintRect( &rect ) ;
793 };
794
795 if (m_pen.GetStyle() != wxTRANSPARENT)
796 {
797 MacInstallPen() ;
798 ::FrameRect( &rect ) ;
799 };
800}
801
802void wxDC::DrawRoundedRectangle( long x, long y, long width, long height, double radius )
803{
804 if (!Ok())
805 return;
806 MacVerifySetup() ;
807
808 if (radius < 0.0)
809 radius = - radius * ((width < height) ? width : height);
810
811 long xx = XLOG2DEV(x);
812 long yy = YLOG2DEV(y);
813 long ww = m_signX * XLOG2DEVREL(width);
814 long hh = m_signY * YLOG2DEVREL(height);
815
816 // CMB: draw nothing if transformed w or h is 0
817 if (ww == 0 || hh == 0)
818 return;
819
820 // CMB: handle -ve width and/or height
821 if (ww < 0)
822 {
823 ww = -ww;
824 xx = xx - ww;
825 }
826
827 if (hh < 0)
828 {
829 hh = -hh;
830 yy = yy - hh;
831 }
832
833 Rect rect = { yy , xx , yy + hh , xx + ww } ;
834
835 if (m_brush.GetStyle() != wxTRANSPARENT)
836 {
837 MacInstallBrush() ;
838 ::PaintRoundRect( &rect , radius * 2 , radius * 2 ) ;
839 };
840
841 if (m_pen.GetStyle() != wxTRANSPARENT)
842 {
843 MacInstallPen() ;
844 ::FrameRoundRect( &rect , radius * 2 , radius * 2 ) ;
845 };
846}
847
848void wxDC::DrawEllipse( long x, long y, long width, long height )
849{
850 if (!Ok())
851 return;
852 MacVerifySetup() ;
853
854 long xx = XLOG2DEV(x);
855 long yy = YLOG2DEV(y);
856 long ww = m_signX * XLOG2DEVREL(width);
857 long hh = m_signY * YLOG2DEVREL(height);
858
859 // CMB: draw nothing if transformed w or h is 0
860 if (ww == 0 || hh == 0)
861 return;
862
863 // CMB: handle -ve width and/or height
864 if (ww < 0)
865 {
866 ww = -ww;
867 xx = xx - ww;
868 }
869
870 if (hh < 0)
871 {
872 hh = -hh;
873 yy = yy - hh;
874 }
875
876 Rect rect = { yy , xx , yy + hh , xx + ww } ;
877
878 if (m_brush.GetStyle() != wxTRANSPARENT)
879 {
880 MacInstallBrush() ;
881 ::PaintOval( &rect ) ;
882 };
883
884 if (m_pen.GetStyle() != wxTRANSPARENT)
885 {
886 MacInstallPen() ;
887 ::FrameOval( &rect ) ;
888 };
889}
890
891// ----------------------------------- spline code ----------------------------------------
892
893static void wx_quadratic_spline(double a1, double b1, double a2, double b2,
894 double a3, double b3, double a4, double b4);
895static void wx_clear_stack(void);
896static int wx_spline_pop(double *x1, double *y1, double *x2, double *y2, double *x3,
897 double *y3, double *x4, double *y4);
898static void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3,
899 double x4, double y4);
900static bool wx_spline_add_point(double x, double y);
901static void wx_spline_draw_point_array(wxDC *dc);
902
903static wxList wx_spline_point_list;
904
905#define half(z1, z2) ((z1+z2)/2.0)
906#define THRESHOLD 5
907
908/* iterative version */
909
910static void wx_quadratic_spline(double a1, double b1, double a2, double b2, double a3, double b3, double a4,
911 double b4)
912{
913 register double xmid, ymid;
914 double x1, y1, x2, y2, x3, y3, x4, y4;
915
916 wx_clear_stack();
917 wx_spline_push(a1, b1, a2, b2, a3, b3, a4, b4);
918
919 while (wx_spline_pop(&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4)) {
920 xmid = (double)half(x2, x3);
921 ymid = (double)half(y2, y3);
922 if (fabs(x1 - xmid) < THRESHOLD && fabs(y1 - ymid) < THRESHOLD &&
923 fabs(xmid - x4) < THRESHOLD && fabs(ymid - y4) < THRESHOLD) {
924 wx_spline_add_point( x1, y1 );
925 wx_spline_add_point( xmid, ymid );
926 } else {
927 wx_spline_push(xmid, ymid, (double)half(xmid, x3), (double)half(ymid, y3),
928 (double)half(x3, x4), (double)half(y3, y4), x4, y4);
929 wx_spline_push(x1, y1, (double)half(x1, x2), (double)half(y1, y2),
930 (double)half(x2, xmid), (double)half(y2, ymid), xmid, ymid);
931 }
932 }
933}
934
935/* utilities used by spline drawing routines */
936
937typedef struct wx_spline_stack_struct {
938 double x1, y1, x2, y2, x3, y3, x4, y4;
939} Stack;
940
941#define SPLINE_STACK_DEPTH 20
942static Stack wx_spline_stack[SPLINE_STACK_DEPTH];
943static Stack *wx_stack_top;
944static int wx_stack_count;
945
946static void wx_clear_stack(void)
947{
948 wx_stack_top = wx_spline_stack;
949 wx_stack_count = 0;
950}
951
952static void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
953{
954 wx_stack_top->x1 = x1;
955 wx_stack_top->y1 = y1;
956 wx_stack_top->x2 = x2;
957 wx_stack_top->y2 = y2;
958 wx_stack_top->x3 = x3;
959 wx_stack_top->y3 = y3;
960 wx_stack_top->x4 = x4;
961 wx_stack_top->y4 = y4;
962 wx_stack_top++;
963 wx_stack_count++;
964}
965
966static int wx_spline_pop(double *x1, double *y1, double *x2, double *y2,
967 double *x3, double *y3, double *x4, double *y4)
968{
969 if (wx_stack_count == 0)
970 return (0);
971 wx_stack_top--;
972 wx_stack_count--;
973 *x1 = wx_stack_top->x1;
974 *y1 = wx_stack_top->y1;
975 *x2 = wx_stack_top->x2;
976 *y2 = wx_stack_top->y2;
977 *x3 = wx_stack_top->x3;
978 *y3 = wx_stack_top->y3;
979 *x4 = wx_stack_top->x4;
980 *y4 = wx_stack_top->y4;
981 return (1);
982}
983
984static bool wx_spline_add_point(double x, double y)
985{
986 wxPoint *point = new wxPoint ;
987 point->x = (int) x;
988 point->y = (int) y;
989 wx_spline_point_list.Append((wxObject*)point);
990 return TRUE;
991}
992
993static void wx_spline_draw_point_array(wxDC *dc)
994{
995 dc->DrawLines(&wx_spline_point_list, 0, 0 );
996 wxNode *node = wx_spline_point_list.First();
997 while (node)
998 {
999 wxPoint *point = (wxPoint *)node->Data();
1000 delete point;
1001 delete node;
1002 node = wx_spline_point_list.First();
1003 }
1004}
1005
1006void wxDC::DrawSpline( wxList *points )
1007{
1008 wxPoint *p;
1009 double cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
1010 double x1, y1, x2, y2;
1011
1012 wxNode *node = points->First();
1013 p = (wxPoint *)node->Data();
1014
1015 x1 = p->x;
1016 y1 = p->y;
1017
1018 node = node->Next();
1019 p = (wxPoint *)node->Data();
1020
1021 x2 = p->x;
1022 y2 = p->y;
1023 cx1 = (double)((x1 + x2) / 2);
1024 cy1 = (double)((y1 + y2) / 2);
1025 cx2 = (double)((cx1 + x2) / 2);
1026 cy2 = (double)((cy1 + y2) / 2);
1027
1028 wx_spline_add_point(x1, y1);
1029
1030 while ((node = node->Next()) != NULL)
1031 {
1032 p = (wxPoint *)node->Data();
1033 x1 = x2;
1034 y1 = y2;
1035 x2 = p->x;
1036 y2 = p->y;
1037 cx4 = (double)(x1 + x2) / 2;
1038 cy4 = (double)(y1 + y2) / 2;
1039 cx3 = (double)(x1 + cx4) / 2;
1040 cy3 = (double)(y1 + cy4) / 2;
1041
1042 wx_quadratic_spline(cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4);
1043
1044 cx1 = cx4;
1045 cy1 = cy4;
1046 cx2 = (double)(cx1 + x2) / 2;
1047 cy2 = (double)(cy1 + y2) / 2;
1048 }
1049
1050 wx_spline_add_point( cx1, cy1 );
1051 wx_spline_add_point( x2, y2 );
1052
1053 wx_spline_draw_point_array( this );
1054}
1055
1056
1057
1058bool wxDC::CanDrawBitmap(void) const
1059{
1060 return true ;
1061}
1062
1063
1064bool wxDC::Blit( long xdest, long ydest, long width, long height,
1065 wxDC *source, long xsrc, long ysrc, int logical_func , bool useMask )
1066{
1067 if (!Ok()) return FALSE;
1068 MacVerifySetup() ;
1069
1070 CGrafPtr sourcePort = (CGrafPtr) source->m_macPort ;
1071 PixMapHandle bmappixels = GetGWorldPixMap( sourcePort ) ;
1072 RGBColor white = { 0xFFFF, 0xFFFF,0xFFFF} ;
1073 RGBColor black = { 0,0,0} ;
1074// RGBForeColor( &black ) ;
1075// RGBBackColor( &white ) ;
1076 RGBForeColor( &m_textForegroundColour.GetPixel() ) ;
1077 RGBBackColor( &m_textBackgroundColour.GetPixel() ) ;
1078
1079 if ( LockPixels(bmappixels) )
1080 {
1081 Rect srcrect , dstrect ;
1082 srcrect.top = source->YLOG2DEV(ysrc) ;
1083 srcrect.left = source->XLOG2DEV(xsrc) ;
1084 srcrect.right = source->XLOG2DEV(xsrc + width ) ;
1085 srcrect.bottom = source->YLOG2DEV(ysrc + height) ;
1086 dstrect.top = YLOG2DEV(ydest) ;
1087 dstrect.left = XLOG2DEV(xdest) ;
1088 dstrect.bottom = YLOG2DEV(ydest + height ) ;
1089 dstrect.right = XLOG2DEV(xdest + width ) ;
1090// ::ClipRect(&m_macClipRect);
1091 CopyBits( &GrafPtr( sourcePort )->portBits , &GrafPtr( m_macPort )->portBits ,
1092 &srcrect, &dstrect, srcCopy, NULL ) ;
1093/*
1094 if ( m_clipping )
1095 {
1096 long x1 = XLOG2DEV(m_clipX1);
1097 long y1 = YLOG2DEV(m_clipY1);
1098 long x2 = XLOG2DEV(m_clipX2);
1099 long y2 = YLOG2DEV(m_clipY2);
1100
1101 Rect clip = { y1 , x1 , y2 , x2 } ;
1102 ::ClipRect(&clip);
1103 }
1104*/
1105 UnlockPixels( bmappixels ) ;
1106 }
1107
1108 m_macPenInstalled = false ;
1109 m_macBrushInstalled = false ;
1110 m_macFontInstalled = false ;
1111
1112 return TRUE;
1113}
1114
1115void wxDC::DrawText( const wxString &string, long x, long y, bool use16)
1116{
1117 if (!Ok())
1118 return;
1119 MacVerifySetup() ;
1120
1121 long xx = XLOG2DEV(x);
1122 long yy = YLOG2DEV(y);
1123
1124// if (m_pen.GetStyle() != wxTRANSPARENT)
1125 {
1126 MacInstallFont() ;
1127 /*
1128 Rect clip = { -32000 , -32000 , 32000 , 32000 } ;
1129
1130 ::ClipRect( &clip ) ;
1131 */
1132
1133 FontInfo fi ;
1134 ::GetFontInfo( &fi ) ;
1135
1136 yy += fi.ascent ;
1137 ::MoveTo( xx , yy );
1138 if ( m_backgroundMode == wxTRANSPARENT )
1139 {
1140 ::TextMode( srcOr) ;
1141 }
1142 else
1143 {
1144 ::TextMode( srcCopy ) ;
1145 }
1146
1147 const char *text = NULL ;
1148 int length = 0 ;
1149 wxString macText ;
1150
1151 if ( wxApp::s_macDefaultEncodingIsPC )
1152 {
1153 macText = wxMacMakeMacStringFromPC( string ) ;
1154 text = macText ;
1155 length = macText.Length() ;
1156 }
1157 else
1158 {
1159 text = string ;
1160 length = string.Length() ;
1161 }
1162
1163 int laststop = 0 ;
1164 int i = 0 ;
1165 int line = 0 ;
1166
1167 while( i < length )
1168 {
1169 if( text[i] == 13 || text[i] == 10)
1170 {
1171 ::DrawText( text , laststop , i - laststop ) ;
1172 line++ ;
1173 ::MoveTo( xx , yy + line*(fi.descent + fi.ascent + fi.leading) );
1174 laststop = i+1 ;
1175 }
1176 i++ ;
1177 }
1178
1179 ::DrawText( text , laststop , i - laststop ) ;
1180 ::TextMode( srcOr ) ;
1181 }
1182}
1183
1184bool wxDC::CanGetTextExtent(void) const
1185{
1186 if ( !Ok() )
1187 return false ;
1188
1189 return true ;
1190}
1191
1192void wxDC::GetTextExtent( const wxString &string, long *width, long *height,
1193 long *descent, long *externalLeading ,
1194 wxFont *theFont , bool use16 ) const
1195{
1196 if (!Ok())
1197 return;
1198
1199 MacVerifySetup() ;
1200
1201 wxFont formerFont = m_font ;
1202
1203 if ( theFont )
1204 {
1205 wxFontRefData * font = (wxFontRefData*) m_font.GetRefData() ;
1206
1207 if ( font )
1208 {
1209 long yy1 = YLOG2DEV(0);
1210 long yy2 = YLOG2DEV(font->m_macFontSize);
1211
1212 ::TextFont( font->m_macFontNum ) ;
1213 ::TextSize( abs( yy2-yy1) ) ;
1214 ::TextFace( font->m_macFontStyle ) ;
1215 }
1216 }
1217 else
1218 {
1219 MacInstallFont() ;
1220 }
1221
1222 FontInfo fi ;
1223 ::GetFontInfo( &fi ) ;
1224
1225 *height = fi.descent + fi.ascent ;
1226 *descent = fi.descent ;
1227 *externalLeading = fi.leading ;
1228
1229 const char *text = NULL ;
1230 int length = 0 ;
1231 wxString macText ;
1232 if ( wxApp::s_macDefaultEncodingIsPC )
1233 {
1234 macText = wxMacMakeMacStringFromPC( string ) ;
1235 text = macText ;
1236 length = macText.Length() ;
1237 }
1238 else
1239 {
1240 text = string ;
1241 length = string.Length() ;
1242 }
1243
1244 int laststop = 0 ;
1245 int i = 0 ;
1246 int curwidth = 0 ;
1247 *width = 0 ;
1248
1249 while( i < length )
1250 {
1251 if( text[i] == 13 || text[i] == 10)
1252 {
1253 *height += fi.descent + fi.ascent + fi.leading;
1254 curwidth = ::TextWidth( text , laststop , i - laststop ) ;
1255 if ( curwidth > *width )
1256 *width = curwidth ;
1257 laststop = i+1 ;
1258 }
1259 i++ ;
1260 }
1261
1262 curwidth = ::TextWidth( text , laststop , i - laststop ) ;
1263 if ( curwidth > *width )
1264 *width = curwidth ;
1265
1266 if ( theFont )
1267 {
1268 m_macFontInstalled = false ;
1269 }
1270}
1271
1272wxCoord wxDC::GetCharWidth(void) const
1273{
1274 if (!Ok())
1275 return 1;
1276
1277 MacVerifySetup() ;
1278
1279 MacInstallFont() ;
1280
1281 FontInfo fi ;
1282 ::GetFontInfo( &fi ) ;
1283
1284 return (fi.descent + fi.ascent) / 2 ;
1285}
1286
1287wxCoord wxDC::GetCharHeight(void) const
1288{
1289 if (!Ok())
1290 return 1;
1291
1292 MacVerifySetup() ;
1293
1294 MacInstallFont() ;
1295
1296 FontInfo fi ;
1297 ::GetFontInfo( &fi ) ;
1298
1299 return fi.descent + fi.ascent ;
1300}
1301
1302void wxDC::Clear(void)
1303{
1304 if (!Ok())
1305 return;
1306 MacVerifySetup() ;
1307 Rect rect = { -32767 , -32767 , 32767 , 32767 } ;
1308
1309 if (m_backgroundBrush.GetStyle() != wxTRANSPARENT)
1310 {
1311 MacInstallBrush() ;
1312 ::EraseRect( &rect ) ;
1313 };
1314}
1315
1316void wxDC::MacInstallFont() const
1317{
1318 if (!Ok())
1319 return;
1320 MacVerifySetup() ;
1321
1322 if ( m_macFontInstalled )
1323 return ;
1324
1325 wxFontRefData * font = (wxFontRefData*) m_font.GetRefData() ;
1326
1327 if ( font )
1328 {
1329 ::TextFont( font->m_macFontNum ) ;
1330 ::TextSize( m_scaleY * font->m_macFontSize ) ;
1331 ::TextFace( font->m_macFontStyle ) ;
1332
1333 m_macFontInstalled = true ;
1334 m_macBrushInstalled = false ;
1335 m_macPenInstalled = false ;
1336
1337 ::RGBForeColor(&m_textForegroundColour.GetPixel() );
1338 ::RGBBackColor(&m_textBackgroundColour.GetPixel() );
1339 }
1340 else
1341 {
1342 short fontnum ;
1343
1344 GetFNum( "\pGeneva" , &fontnum ) ;
1345 ::TextFont( fontnum ) ;
1346 ::TextSize( m_scaleY * 10 ) ;
1347 ::TextFace( 0 ) ;
1348
1349 // todo reset after spacing changes - or store the current spacing somewhere
1350
1351 m_macFontInstalled = true ;
1352 m_macBrushInstalled = false ;
1353 m_macPenInstalled = false ;
1354 ::RGBForeColor( &(m_textForegroundColour.GetPixel()) );
1355 ::RGBBackColor(&m_textBackgroundColour.GetPixel() );
1356 }
1357
1358
1359 short mode = patCopy ;
1360
1361 // todo :
1362
1363 switch( m_logicalFunction )
1364 {
1365 case wxCOPY: // src
1366 mode = patCopy ;
1367 break ;
1368 case wxINVERT: // NOT dst
1369 ::PenPat(&qd.black);
1370 mode = patXor ;
1371 break ;
1372 case wxXOR: // src XOR dst
1373 mode = patXor ;
1374 break ;
1375 case wxOR_REVERSE: // src OR (NOT dst)
1376 mode = notPatOr ;
1377 break ;
1378 case wxSRC_INVERT: // (NOT src)
1379 mode = notPatCopy ;
1380 break ;
1381
1382 // unsupported TODO
1383
1384 case wxCLEAR: // 0
1385 case wxAND_REVERSE:// src AND (NOT dst)
1386 case wxAND: // src AND dst
1387 case wxAND_INVERT: // (NOT src) AND dst
1388 case wxNO_OP: // dst
1389 case wxNOR: // (NOT src) AND (NOT dst)
1390 case wxEQUIV: // (NOT src) XOR dst
1391 case wxOR_INVERT: // (NOT src) OR dst
1392 case wxNAND: // (NOT src) OR (NOT dst)
1393 case wxOR: // src OR dst
1394 case wxSET: // 1
1395 case wxSRC_OR: // source _bitmap_ OR destination
1396 case wxSRC_AND: // source _bitmap_ AND destination
1397 break ;
1398 }
1399 ::PenMode( mode ) ;
1400}
1401
1402static void wxMacGetHatchPattern(int hatchStyle, Pattern *pattern)
1403{
1404 int thePatListID = sysPatListID;
1405 int theIndex;
1406 switch(hatchStyle)
1407 {
1408 case wxBDIAGONAL_HATCH:
1409 theIndex = 34; // WCH: this is not good
1410 break;
1411 case wxFDIAGONAL_HATCH:
1412 theIndex = 26;
1413 break;
1414 case wxCROSS_HATCH:
1415 theIndex = 5;
1416 break;
1417 case wxHORIZONTAL_HATCH:
1418 theIndex = 25;
1419 break;
1420 case wxVERTICAL_HATCH:
1421 theIndex = 6;
1422 break;
1423 case wxCROSSDIAG_HATCH:
1424 theIndex = 4; // WCH: this is not good
1425 break;
1426 default:
1427 theIndex = 1; // solid pattern
1428 break;
1429 }
1430 GetIndPattern( pattern, thePatListID, theIndex);
1431}
1432
1433void wxDC::MacInstallPen() const
1434{
1435 if (!Ok())
1436 return;
1437 MacVerifySetup() ;
1438
1439 if ( m_macPenInstalled )
1440 return ;
1441
1442 ::RGBForeColor(&m_pen.GetColour().GetPixel() );
1443 ::RGBBackColor(&m_backgroundBrush.GetColour().GetPixel() );
1444
1445 ::PenNormal() ;
1446 int penWidth = m_pen.GetWidth();
1447 ::PenSize(penWidth, penWidth);
1448
1449 int penStyle = m_pen.GetStyle();
1450
1451 if (penStyle == wxSOLID)
1452 ::PenPat(&qd.black);
1453 else if (IS_HATCH(penStyle))
1454 {
1455 Pattern pat ;
1456 wxMacGetHatchPattern(penStyle, &pat);
1457 ::PenPat(&pat);
1458 }
1459 else
1460 {
1461 ::PenPat(&qd.black);
1462 }
1463
1464 short mode = patCopy ;
1465
1466 // todo :
1467
1468 switch( m_logicalFunction )
1469 {
1470 case wxCOPY: // src
1471 mode = patCopy ;
1472 break ;
1473 case wxINVERT: // NOT dst
1474 ::PenPat(&qd.black);
1475 mode = patXor ;
1476 break ;
1477 case wxXOR: // src XOR dst
1478 mode = patXor ;
1479 break ;
1480 case wxOR_REVERSE: // src OR (NOT dst)
1481 mode = notPatOr ;
1482 break ;
1483 case wxSRC_INVERT: // (NOT src)
1484 mode = notPatCopy ;
1485 break ;
1486
1487 // unsupported TODO
1488
1489 case wxCLEAR: // 0
1490 case wxAND_REVERSE:// src AND (NOT dst)
1491 case wxAND: // src AND dst
1492 case wxAND_INVERT: // (NOT src) AND dst
1493 case wxNO_OP: // dst
1494 case wxNOR: // (NOT src) AND (NOT dst)
1495 case wxEQUIV: // (NOT src) XOR dst
1496 case wxOR_INVERT: // (NOT src) OR dst
1497 case wxNAND: // (NOT src) OR (NOT dst)
1498 case wxOR: // src OR dst
1499 case wxSET: // 1
1500 case wxSRC_OR: // source _bitmap_ OR destination
1501 case wxSRC_AND: // source _bitmap_ AND destination
1502 break ;
1503 }
1504 ::PenMode( mode ) ;
1505 m_macPenInstalled = true ;
1506 m_macBrushInstalled = false ;
1507 m_macFontInstalled = false ;
1508}
1509
1510void wxDC::MacInstallBrush() const
1511{
1512 if (!Ok())
1513 return;
1514 MacVerifySetup() ;
1515
1516 if ( m_macBrushInstalled )
1517 return ;
1518
1519 // foreground
1520
1521 ::RGBForeColor(&m_brush.GetColour().GetPixel() );
1522 ::RGBBackColor(&m_backgroundBrush.GetColour().GetPixel() );
1523
1524 int brushStyle = m_brush.GetStyle();
1525 if (brushStyle == wxSOLID)
1526 ::PenPat(&qd.black);
1527 else if (IS_HATCH(brushStyle))
1528 {
1529 Pattern pat ;
1530 wxMacGetHatchPattern(brushStyle, &pat);
1531 ::PenPat(&pat);
1532 }
1533 else
1534 {
1535 ::PenPat(&qd.black);
1536 }
1537
1538
1539 // background
1540
1541 brushStyle = m_backgroundBrush.GetStyle();
1542 if (brushStyle == wxSOLID)
1543 ::BackPat(&qd.white);
1544 else if (IS_HATCH(brushStyle))
1545 {
1546 Pattern pat ;
1547 wxMacGetHatchPattern(brushStyle, &pat);
1548 ::BackPat(&pat);
1549 }
1550 else
1551 {
1552 ::BackPat(&qd.white);
1553 }
1554
1555 short mode = patCopy ;
1556
1557 // todo :
1558
1559 switch( m_logicalFunction )
1560 {
1561 case wxCOPY: // src
1562 mode = patCopy ;
1563 break ;
1564 case wxINVERT: // NOT dst
1565 ::PenPat(&qd.black);
1566 mode = patXor ;
1567 break ;
1568 case wxXOR: // src XOR dst
1569 mode = patXor ;
1570 break ;
1571 case wxOR_REVERSE: // src OR (NOT dst)
1572 mode = notPatOr ;
1573 break ;
1574 case wxSRC_INVERT: // (NOT src)
1575 mode = notPatCopy ;
1576 break ;
1577
1578 // unsupported TODO
1579
1580 case wxCLEAR: // 0
1581 case wxAND_REVERSE:// src AND (NOT dst)
1582 case wxAND: // src AND dst
1583 case wxAND_INVERT: // (NOT src) AND dst
1584 case wxNO_OP: // dst
1585 case wxNOR: // (NOT src) AND (NOT dst)
1586 case wxEQUIV: // (NOT src) XOR dst
1587 case wxOR_INVERT: // (NOT src) OR dst
1588 case wxNAND: // (NOT src) OR (NOT dst)
1589 case wxOR: // src OR dst
1590 case wxSET: // 1
1591 case wxSRC_OR: // source _bitmap_ OR destination
1592 case wxSRC_AND: // source _bitmap_ AND destination
1593 break ;
1594 }
1595 ::PenMode( mode ) ;
1596 m_macBrushInstalled = true ;
1597 m_macPenInstalled = false ;
1598 m_macFontInstalled = false ;
1599}
1600
1601
wxWidgets (Impactor)