]> git.saurik.com Git - wxWidgets.git/blob - src/common/dcbase.cpp
projects / wxWidgets.git / blob
? search:


07353fba7435c1002e811eee09b99f0889521470
[wxWidgets.git] / src / common / dcbase.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/dcbase.cpp
3 // Purpose: generic methods of the wxDC Class
4 // Author: Vadim Zeitlin
5 // Modified by:
6 // Created: 05/25/99
7 // RCS-ID: $Id$
8 // Copyright: (c) wxWidgets team
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
22
23 #ifdef __BORLANDC__
24 #pragma hdrstop
25 #endif
26
27 #include "wx/dc.h"
28 #include "wx/dcclient.h"
29 #include "wx/dcmemory.h"
30 #include "wx/dcscreen.h"
31 #include "wx/dcprint.h"
32 #include "wx/dcbuffer.h" // for IMPLEMENT_DYNAMIC_CLASS
33 #include "wx/prntbase.h"
34
35 #ifndef WX_PRECOMP
36 #include "wx/math.h"
37 #endif
38
39 #ifdef __WXMSW__
40 #include "wx/msw/dcclient.h"
41 #include "wx/msw/dcmemory.h"
42 #include "wx/msw/dcscreen.h"
43 #endif
44
45 #ifdef __WXGTK__
46 #include "wx/gtk/dcclient.h"
47 #include "wx/gtk/dcmemory.h"
48 #include "wx/gtk/dcscreen.h"
49 #endif
50
51 #ifdef __WXMAC__
52 #include "wx/mac/dcclient.h"
53 #include "wx/mac/dcmemory.h"
54 #include "wx/mac/dcscreen.h"
55 #endif
56
57 #ifdef __WXX11__
58 #include "wx/x11/dcclient.h"
59 #include "wx/x11/dcmemory.h"
60 #include "wx/x11/dcscreen.h"
61 #endif
62
63 //----------------------------------------------------------------------------
64 // wxDCFactory
65 //----------------------------------------------------------------------------
66
67 wxDCFactory *wxDCFactory::m_factory = NULL;
68
69 void wxDCFactory::SetDCFactory( wxDCFactory *factory )
70 {
71 if (wxDCFactory::m_factory)
72 delete wxDCFactory::m_factory;
73
74 wxDCFactory::m_factory = factory;
75 }
76
77 wxDCFactory *wxDCFactory::GetFactory()
78 {
79 if (!wxDCFactory::m_factory)
80 wxDCFactory::m_factory = new wxNativeDCFactory;
81
82 return wxDCFactory::m_factory;
83 }
84
85 //-----------------------------------------------------------------------------
86 // wxNativeDCFactory
87 //-----------------------------------------------------------------------------
88
89 wxDCImpl* wxNativeDCFactory::CreateWindowDC( wxWindowDC *owner )
90 {
91 return new wxWindowDCImpl( owner );
92 }
93
94 wxDCImpl* wxNativeDCFactory::CreateWindowDC( wxWindowDC *owner, wxWindow *window )
95 {
96 return new wxWindowDCImpl( owner, window );
97 }
98
99 wxDCImpl* wxNativeDCFactory::CreateClientDC( wxClientDC *owner )
100 {
101 return new wxClientDCImpl( owner );
102 }
103
104 wxDCImpl* wxNativeDCFactory::CreateClientDC( wxClientDC *owner, wxWindow *window )
105 {
106 return new wxClientDCImpl( owner, window );
107 }
108
109 wxDCImpl* wxNativeDCFactory::CreatePaintDC( wxPaintDC *owner )
110 {
111 return new wxPaintDCImpl( owner );
112 }
113
114 wxDCImpl* wxNativeDCFactory::CreatePaintDC( wxPaintDC *owner, wxWindow *window )
115 {
116 return new wxPaintDCImpl( owner, window );
117 }
118
119 wxDCImpl* wxNativeDCFactory::CreateMemoryDC( wxMemoryDC *owner )
120 {
121 return new wxMemoryDCImpl( owner );
122 }
123
124 wxDCImpl* wxNativeDCFactory::CreateMemoryDC( wxMemoryDC *owner, wxBitmap &bitmap )
125 {
126 return new wxMemoryDCImpl( owner, bitmap );
127 }
128
129 wxDCImpl* wxNativeDCFactory::CreateMemoryDC( wxMemoryDC *owner, wxDC *dc )
130 {
131 return new wxMemoryDCImpl( owner, dc );
132 }
133
134 wxDCImpl* wxNativeDCFactory::CreateScreenDC( wxScreenDC *owner )
135 {
136 return new wxScreenDCImpl( owner );
137 }
138
139 wxDCImpl *wxNativeDCFactory::CreatePrinterDC( wxPrinterDC *owner, const wxPrintData &data )
140 {
141 wxPrintFactory *factory = wxPrintFactory::GetFactory();
142 return factory->CreatePrinterDCImpl( owner, data );
143 }
144
145 //-----------------------------------------------------------------------------
146 // wxWindowDC
147 //-----------------------------------------------------------------------------
148
149 IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
150
151 wxWindowDC::wxWindowDC()
152 {
153 }
154
155 wxWindowDC::wxWindowDC( wxWindow *win )
156 {
157 wxDCFactory *factory = wxDCFactory::GetFactory();
158 m_pimpl = factory->CreateWindowDC( this, win );
159 }
160
161 //-----------------------------------------------------------------------------
162 // wxClientDC
163 //-----------------------------------------------------------------------------
164
165 IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxWindowDC)
166
167 wxClientDC::wxClientDC()
168 {
169 }
170
171 wxClientDC::wxClientDC( wxWindow *win )
172 {
173 wxDCFactory *factory = wxDCFactory::GetFactory();
174 m_pimpl = factory->CreateClientDC( this, win );
175 }
176
177 //-----------------------------------------------------------------------------
178 // wxMemoryDC
179 //-----------------------------------------------------------------------------
180
181 IMPLEMENT_DYNAMIC_CLASS(wxMemoryDC, wxDC)
182
183 wxMemoryDC::wxMemoryDC()
184 {
185 wxDCFactory *factory = wxDCFactory::GetFactory();
186 m_pimpl = factory->CreateMemoryDC( this );
187 }
188
189 wxMemoryDC::wxMemoryDC( wxBitmap& bitmap )
190 {
191 wxDCFactory *factory = wxDCFactory::GetFactory();
192 m_pimpl = factory->CreateMemoryDC( this, bitmap );
193 }
194
195 wxMemoryDC::wxMemoryDC( wxDC *dc )
196 {
197 wxDCFactory *factory = wxDCFactory::GetFactory();
198 m_pimpl = factory->CreateMemoryDC( this, dc );
199 }
200
201 void wxMemoryDC::SelectObject(wxBitmap& bmp)
202 {
203 // make sure that the given wxBitmap is not sharing its data with other
204 // wxBitmap instances as its contents will be modified by any drawing
205 // operation done on this DC
206 if (bmp.IsOk())
207 bmp.UnShare();
208
209 GetImpl()->DoSelect(bmp);
210 }
211
212 void wxMemoryDC::SelectObjectAsSource(const wxBitmap& bmp)
213 {
214 GetImpl()->DoSelect(bmp);
215 }
216
217 const wxBitmap& wxMemoryDC::GetSelectedBitmap() const
218 {
219 return GetImpl()->GetSelectedBitmap();
220 }
221
222 wxBitmap& wxMemoryDC::GetSelectedBitmap()
223 {
224 return GetImpl()->GetSelectedBitmap();
225 }
226
227
228 //-----------------------------------------------------------------------------
229 // wxPaintDC
230 //-----------------------------------------------------------------------------
231
232 IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxClientDC)
233
234 wxPaintDC::wxPaintDC()
235 {
236 }
237
238 wxPaintDC::wxPaintDC( wxWindow *win )
239 {
240 wxDCFactory *factory = wxDCFactory::GetFactory();
241 m_pimpl = factory->CreatePaintDC( this, win );
242 }
243
244 //-----------------------------------------------------------------------------
245 // wxScreenDC
246 //-----------------------------------------------------------------------------
247
248 IMPLEMENT_DYNAMIC_CLASS(wxScreenDC, wxWindowDC)
249
250 wxScreenDC::wxScreenDC()
251 {
252 wxDCFactory *factory = wxDCFactory::GetFactory();
253 m_pimpl = factory->CreateScreenDC( this );
254 }
255
256 //-----------------------------------------------------------------------------
257 // wxPrinterDC
258 //-----------------------------------------------------------------------------
259
260 IMPLEMENT_DYNAMIC_CLASS(wxPrinterDC, wxDC)
261
262 wxPrinterDC::wxPrinterDC()
263 {
264 wxPrintData data; // Does this make sense?
265 wxDCFactory *factory = wxDCFactory::GetFactory();
266 m_pimpl = factory->CreatePrinterDC( this, data );
267 }
268
269 wxPrinterDC::wxPrinterDC( const wxPrintData &data )
270 {
271 wxDCFactory *factory = wxDCFactory::GetFactory();
272 m_pimpl = factory->CreatePrinterDC( this, data );
273 }
274
275 wxPrinterDC::~wxPrinterDC()
276 {
277 }
278
279 wxRect wxPrinterDC::GetPaperRect()
280 {
281 return GetImpl()->GetPaperRect();
282 }
283
284 int wxPrinterDC::GetResolution()
285 {
286 return GetImpl()->GetResolution();
287 }
288
289
290 //-----------------------------------------------------------------------------
291 // wxDCImpl
292 //-----------------------------------------------------------------------------
293
294 IMPLEMENT_ABSTRACT_CLASS(wxDCImpl, wxObject)
295
296 wxDCImpl::wxDCImpl( wxDC *owner )
297 : m_window(NULL)
298 , m_colour(wxColourDisplay())
299 , m_ok(true)
300 , m_clipping(false)
301 , m_isInteractive(0)
302 , m_isBBoxValid(false)
303 , m_logicalOriginX(0), m_logicalOriginY(0)
304 , m_deviceOriginX(0), m_deviceOriginY(0)
305 , m_deviceLocalOriginX(0), m_deviceLocalOriginY(0)
306 , m_logicalScaleX(1.0), m_logicalScaleY(1.0)
307 , m_userScaleX(1.0), m_userScaleY(1.0)
308 , m_scaleX(1.0), m_scaleY(1.0)
309 , m_signX(1), m_signY(1)
310 , m_minX(0), m_minY(0), m_maxX(0), m_maxY(0)
311 , m_clipX1(0), m_clipY1(0), m_clipX2(0), m_clipY2(0)
312 , m_logicalFunction(wxCOPY)
313 , m_backgroundMode(wxTRANSPARENT)
314 , m_mappingMode(wxMM_TEXT)
315 , m_pen()
316 , m_brush()
317 , m_backgroundBrush(*wxTRANSPARENT_BRUSH)
318 , m_textForegroundColour(*wxBLACK)
319 , m_textBackgroundColour(*wxWHITE)
320 , m_font()
321 #if wxUSE_PALETTE
322 , m_palette()
323 , m_hasCustomPalette(false)
324 #endif // wxUSE_PALETTE
325 {
326 m_owner = owner;
327
328 m_mm_to_pix_x = (double)wxGetDisplaySize().GetWidth() /
329 (double)wxGetDisplaySizeMM().GetWidth();
330 m_mm_to_pix_y = (double)wxGetDisplaySize().GetHeight() /
331 (double)wxGetDisplaySizeMM().GetHeight();
332
333 ResetBoundingBox();
334 ResetClipping();
335 }
336
337 wxDCImpl::~wxDCImpl()
338 {
339 }
340
341 // ----------------------------------------------------------------------------
342 // coordinate conversions and transforms
343 // ----------------------------------------------------------------------------
344
345 wxCoord wxDCImpl::DeviceToLogicalX(wxCoord x) const
346 {
347 return wxRound((double)(x - m_deviceOriginX - m_deviceLocalOriginX) / m_scaleX) * m_signX + m_logicalOriginX;
348 }
349
350 wxCoord wxDCImpl::DeviceToLogicalY(wxCoord y) const
351 {
352 return wxRound((double)(y - m_deviceOriginY - m_deviceLocalOriginY) / m_scaleY) * m_signY + m_logicalOriginY;
353 }
354
355 wxCoord wxDCImpl::DeviceToLogicalXRel(wxCoord x) const
356 {
357 return wxRound((double)(x) / m_scaleX);
358 }
359
360 wxCoord wxDCImpl::DeviceToLogicalYRel(wxCoord y) const
361 {
362 return wxRound((double)(y) / m_scaleY);
363 }
364
365 wxCoord wxDCImpl::LogicalToDeviceX(wxCoord x) const
366 {
367 return wxRound((double)(x - m_logicalOriginX) * m_scaleX) * m_signX + m_deviceOriginX * m_signY + m_deviceLocalOriginX;
368 }
369
370 wxCoord wxDCImpl::LogicalToDeviceY(wxCoord y) const
371 {
372 return wxRound((double)(y - m_logicalOriginY) * m_scaleY) * m_signY + m_deviceOriginY * m_signY + m_deviceLocalOriginY;
373 }
374
375 wxCoord wxDCImpl::LogicalToDeviceXRel(wxCoord x) const
376 {
377 return wxRound((double)(x) * m_scaleX);
378 }
379
380 wxCoord wxDCImpl::LogicalToDeviceYRel(wxCoord y) const
381 {
382 return wxRound((double)(y) * m_scaleY);
383 }
384
385 void wxDCImpl::ComputeScaleAndOrigin()
386 {
387 m_scaleX = m_logicalScaleX * m_userScaleX;
388 m_scaleY = m_logicalScaleY * m_userScaleY;
389 }
390
391 void wxDCImpl::SetMapMode( int mode )
392 {
393 switch (mode)
394 {
395 case wxMM_TWIPS:
396 SetLogicalScale( twips2mm*m_mm_to_pix_x, twips2mm*m_mm_to_pix_y );
397 break;
398 case wxMM_POINTS:
399 SetLogicalScale( pt2mm*m_mm_to_pix_x, pt2mm*m_mm_to_pix_y );
400 break;
401 case wxMM_METRIC:
402 SetLogicalScale( m_mm_to_pix_x, m_mm_to_pix_y );
403 break;
404 case wxMM_LOMETRIC:
405 SetLogicalScale( m_mm_to_pix_x/10.0, m_mm_to_pix_y/10.0 );
406 break;
407 default:
408 case wxMM_TEXT:
409 SetLogicalScale( 1.0, 1.0 );
410 break;
411 }
412 m_mappingMode = mode;
413 }
414
415 void wxDCImpl::SetUserScale( double x, double y )
416 {
417 // allow negative ? -> no
418 m_userScaleX = x;
419 m_userScaleY = y;
420 ComputeScaleAndOrigin();
421 }
422
423 void wxDCImpl::SetLogicalScale( double x, double y )
424 {
425 // allow negative ?
426 m_logicalScaleX = x;
427 m_logicalScaleY = y;
428 ComputeScaleAndOrigin();
429 }
430
431 void wxDCImpl::SetLogicalOrigin( wxCoord x, wxCoord y )
432 {
433 m_logicalOriginX = x * m_signX;
434 m_logicalOriginY = y * m_signY;
435 ComputeScaleAndOrigin();
436 }
437
438 void wxDCImpl::SetDeviceOrigin( wxCoord x, wxCoord y )
439 {
440 m_deviceOriginX = x;
441 m_deviceOriginY = y;
442 ComputeScaleAndOrigin();
443 }
444
445 void wxDCImpl::SetDeviceLocalOrigin( wxCoord x, wxCoord y )
446 {
447 m_deviceLocalOriginX = x;
448 m_deviceLocalOriginY = y;
449 ComputeScaleAndOrigin();
450 }
451
452 void wxDCImpl::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
453 {
454 // only wxPostScripDC has m_signX = -1, we override SetAxisOrientation there
455 // wxWidgets 2.9: no longer override it
456 m_signX = (xLeftRight ? 1 : -1);
457 m_signY = (yBottomUp ? -1 : 1);
458 ComputeScaleAndOrigin();
459 }
460
461
462 // Each element of the widths array will be the width of the string up to and
463 // including the corresponding character in text. This is the generic
464 // implementation, the port-specific classes should do this with native APIs
465 // if available and if faster. Note: pango_layout_index_to_pos is much slower
466 // than calling GetTextExtent!!
467
468 #define FWC_SIZE 256
469
470 class FontWidthCache
471 {
472 public:
473 FontWidthCache() : m_scaleX(1), m_widths(NULL) { }
474 ~FontWidthCache() { delete []m_widths; }
475
476 void Reset()
477 {
478 if (!m_widths)
479 m_widths = new int[FWC_SIZE];
480
481 memset(m_widths, 0, sizeof(int)*FWC_SIZE);
482 }
483
484 wxFont m_font;
485 double m_scaleX;
486 int *m_widths;
487 };
488
489 static FontWidthCache s_fontWidthCache;
490
491 bool wxDCImpl::DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const
492 {
493 int totalWidth = 0;
494
495 const size_t len = text.length();
496 widths.Empty();
497 widths.Add(0, len);
498
499 // reset the cache if font or horizontal scale have changed
500 if ( !s_fontWidthCache.m_widths ||
501 !wxIsSameDouble(s_fontWidthCache.m_scaleX, m_scaleX) ||
502 (s_fontWidthCache.m_font != GetFont()) )
503 {
504 s_fontWidthCache.Reset();
505 s_fontWidthCache.m_font = GetFont();
506 s_fontWidthCache.m_scaleX = m_scaleX;
507 }
508
509 // Calculate the position of each character based on the widths of
510 // the previous characters
511 int w, h;
512 for ( size_t i = 0; i < len; i++ )
513 {
514 const wxChar c = text[i];
515 unsigned int c_int = (unsigned int)c;
516
517 if ((c_int < FWC_SIZE) && (s_fontWidthCache.m_widths[c_int] != 0))
518 {
519 w = s_fontWidthCache.m_widths[c_int];
520 }
521 else
522 {
523 DoGetTextExtent(c, &w, &h);
524 if (c_int < FWC_SIZE)
525 s_fontWidthCache.m_widths[c_int] = w;
526 }
527
528 totalWidth += w;
529 widths[i] = totalWidth;
530 }
531
532 return true;
533 }
534
535 void wxDCImpl::GetMultiLineTextExtent(const wxString& text,
536 wxCoord *x,
537 wxCoord *y,
538 wxCoord *h,
539 const wxFont *font) const
540 {
541 wxCoord widthTextMax = 0, widthLine,
542 heightTextTotal = 0, heightLineDefault = 0, heightLine = 0;
543
544 wxString curLine;
545 for ( wxString::const_iterator pc = text.begin(); ; ++pc )
546 {
547 if ( pc == text.end() || *pc == _T('\n') )
548 {
549 if ( curLine.empty() )
550 {
551 // we can't use GetTextExtent - it will return 0 for both width
552 // and height and an empty line should count in height
553 // calculation
554
555 // assume that this line has the same height as the previous
556 // one
557 if ( !heightLineDefault )
558 heightLineDefault = heightLine;
559
560 if ( !heightLineDefault )
561 {
562 // but we don't know it yet - choose something reasonable
563 DoGetTextExtent(_T("W"), NULL, &heightLineDefault,
564 NULL, NULL, font);
565 }
566
567 heightTextTotal += heightLineDefault;
568 }
569 else
570 {
571 DoGetTextExtent(curLine, &widthLine, &heightLine,
572 NULL, NULL, font);
573 if ( widthLine > widthTextMax )
574 widthTextMax = widthLine;
575 heightTextTotal += heightLine;
576 }
577
578 if ( pc == text.end() )
579 {
580 break;
581 }
582 else // '\n'
583 {
584 curLine.clear();
585 }
586 }
587 else
588 {
589 curLine += *pc;
590 }
591 }
592
593 if ( x )
594 *x = widthTextMax;
595 if ( y )
596 *y = heightTextTotal;
597 if ( h )
598 *h = heightLine;
599 }
600
601 void wxDCImpl::DoDrawCheckMark(wxCoord x1, wxCoord y1,
602 wxCoord width, wxCoord height)
603 {
604 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
605
606 wxCoord x2 = x1 + width,
607 y2 = y1 + height;
608
609 // the pen width is calibrated to give 3 for width == height == 10
610 wxDCPenChanger pen( *m_owner, wxPen(GetTextForeground(), (width + height + 1)/7));
611
612 // we're drawing a scaled version of wx/generic/tick.xpm here
613 wxCoord x3 = x1 + (4*width) / 10, // x of the tick bottom
614 y3 = y1 + height / 2; // y of the left tick branch
615 DoDrawLine(x1, y3, x3, y2);
616 DoDrawLine(x3, y2, x2, y1);
617
618 CalcBoundingBox(x1, y1);
619 CalcBoundingBox(x2, y2);
620 }
621
622 bool
623 wxDCImpl::DoStretchBlit(wxCoord xdest, wxCoord ydest,
624 wxCoord dstWidth, wxCoord dstHeight,
625 wxDC *source,
626 wxCoord xsrc, wxCoord ysrc,
627 wxCoord srcWidth, wxCoord srcHeight,
628 int rop,
629 bool useMask,
630 wxCoord xsrcMask,
631 wxCoord ysrcMask)
632 {
633 wxCHECK_MSG( srcWidth && srcHeight && dstWidth && dstHeight, false,
634 _T("invalid blit size") );
635
636 // emulate the stretching by modifying the DC scale
637 double xscale = (double)srcWidth/dstWidth,
638 yscale = (double)srcHeight/dstHeight;
639
640 double xscaleOld, yscaleOld;
641 GetUserScale(&xscaleOld, &yscaleOld);
642 SetUserScale(xscaleOld/xscale, yscaleOld/yscale);
643
644 bool rc = DoBlit(wxCoord(xdest*xscale), wxCoord(ydest*yscale),
645 wxCoord(dstWidth*xscale), wxCoord(dstHeight*yscale),
646 source,
647 xsrc, ysrc, rop, useMask, xsrcMask, ysrcMask);
648
649 SetUserScale(xscaleOld, yscaleOld);
650
651 return rc;
652 }
653
654 void wxDCImpl::DrawLines(const wxPointList *list, wxCoord xoffset, wxCoord yoffset)
655 {
656 int n = list->GetCount();
657 wxPoint *points = new wxPoint[n];
658
659 int i = 0;
660 for ( wxPointList::compatibility_iterator node = list->GetFirst(); node; node = node->GetNext(), i++ )
661 {
662 wxPoint *point = node->GetData();
663 points[i].x = point->x;
664 points[i].y = point->y;
665 }
666
667 DoDrawLines(n, points, xoffset, yoffset);
668
669 delete [] points;
670 }
671
672 void wxDCImpl::DrawPolygon(const wxPointList *list,
673 wxCoord xoffset, wxCoord yoffset,
674 int fillStyle)
675 {
676 int n = list->GetCount();
677 wxPoint *points = new wxPoint[n];
678
679 int i = 0;
680 for ( wxPointList::compatibility_iterator node = list->GetFirst(); node; node = node->GetNext(), i++ )
681 {
682 wxPoint *point = node->GetData();
683 points[i].x = point->x;
684 points[i].y = point->y;
685 }
686
687 DoDrawPolygon(n, points, xoffset, yoffset, fillStyle);
688
689 delete [] points;
690 }
691
692 void
693 wxDCImpl::DoDrawPolyPolygon(int n,
694 int count[],
695 wxPoint points[],
696 wxCoord xoffset, wxCoord yoffset,
697 int fillStyle)
698 {
699 if ( n == 1 )
700 {
701 DoDrawPolygon(count[0], points, xoffset, yoffset, fillStyle);
702 return;
703 }
704
705 int i, j, lastOfs;
706 wxPoint* pts;
707 wxPen pen;
708
709 for (i = j = lastOfs = 0; i < n; i++)
710 {
711 lastOfs = j;
712 j += count[i];
713 }
714 pts = new wxPoint[j+n-1];
715 for (i = 0; i < j; i++)
716 pts[i] = points[i];
717 for (i = 2; i <= n; i++)
718 {
719 lastOfs -= count[n-i];
720 pts[j++] = pts[lastOfs];
721 }
722
723 pen = GetPen();
724 SetPen(wxPen(*wxBLACK, 0, wxTRANSPARENT));
725 DoDrawPolygon(j, pts, xoffset, yoffset, fillStyle);
726 SetPen(pen);
727 for (i = j = 0; i < n; i++)
728 {
729 DoDrawLines(count[i], pts+j, xoffset, yoffset);
730 j += count[i];
731 }
732 delete[] pts;
733 }
734
735 #if wxUSE_SPLINES
736
737 void wxDCImpl::DoDrawSpline(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord x3, wxCoord y3)
738 {
739 wxPointList point_list;
740
741 wxPoint *point1 = new wxPoint;
742 point1->x = x1; point1->y = y1;
743 point_list.Append( point1 );
744
745 wxPoint *point2 = new wxPoint;
746 point2->x = x2; point2->y = y2;
747 point_list.Append( point2 );
748
749 wxPoint *point3 = new wxPoint;
750 point3->x = x3; point3->y = y3;
751 point_list.Append( point3 );
752
753 DoDrawSpline(&point_list);
754
755 for( wxPointList::compatibility_iterator node = point_list.GetFirst(); node; node = node->GetNext() )
756 {
757 wxPoint *p = node->GetData();
758 delete p;
759 }
760 }
761
762 void wxDCImpl::DoDrawSpline(int n, wxPoint points[])
763 {
764 wxPointList list;
765 for (int i =0; i < n; i++)
766 list.Append( &points[i] );
767
768 DoDrawSpline(&list);
769 }
770
771 // ----------------------------------- spline code ----------------------------------------
772
773 void wx_quadratic_spline(double a1, double b1, double a2, double b2,
774 double a3, double b3, double a4, double b4);
775 void wx_clear_stack();
776 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2, double *x3,
777 double *y3, double *x4, double *y4);
778 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3,
779 double x4, double y4);
780 static bool wx_spline_add_point(double x, double y);
781 static void wx_spline_draw_point_array(wxDC *dc);
782
783 wxPointList wx_spline_point_list;
784
785 #define half(z1, z2) ((z1+z2)/2.0)
786 #define THRESHOLD 5
787
788 /* iterative version */
789
790 void wx_quadratic_spline(double a1, double b1, double a2, double b2, double a3, double b3, double a4,
791 double b4)
792 {
793 register double xmid, ymid;
794 double x1, y1, x2, y2, x3, y3, x4, y4;
795
796 wx_clear_stack();
797 wx_spline_push(a1, b1, a2, b2, a3, b3, a4, b4);
798
799 while (wx_spline_pop(&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4)) {
800 xmid = (double)half(x2, x3);
801 ymid = (double)half(y2, y3);
802 if (fabs(x1 - xmid) < THRESHOLD && fabs(y1 - ymid) < THRESHOLD &&
803 fabs(xmid - x4) < THRESHOLD && fabs(ymid - y4) < THRESHOLD) {
804 wx_spline_add_point( x1, y1 );
805 wx_spline_add_point( xmid, ymid );
806 } else {
807 wx_spline_push(xmid, ymid, (double)half(xmid, x3), (double)half(ymid, y3),
808 (double)half(x3, x4), (double)half(y3, y4), x4, y4);
809 wx_spline_push(x1, y1, (double)half(x1, x2), (double)half(y1, y2),
810 (double)half(x2, xmid), (double)half(y2, ymid), xmid, ymid);
811 }
812 }
813 }
814
815 /* utilities used by spline drawing routines */
816
817 typedef struct wx_spline_stack_struct {
818 double x1, y1, x2, y2, x3, y3, x4, y4;
819 } Stack;
820
821 #define SPLINE_STACK_DEPTH 20
822 static Stack wx_spline_stack[SPLINE_STACK_DEPTH];
823 static Stack *wx_stack_top;
824 static int wx_stack_count;
825
826 void wx_clear_stack()
827 {
828 wx_stack_top = wx_spline_stack;
829 wx_stack_count = 0;
830 }
831
832 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
833 {
834 wx_stack_top->x1 = x1;
835 wx_stack_top->y1 = y1;
836 wx_stack_top->x2 = x2;
837 wx_stack_top->y2 = y2;
838 wx_stack_top->x3 = x3;
839 wx_stack_top->y3 = y3;
840 wx_stack_top->x4 = x4;
841 wx_stack_top->y4 = y4;
842 wx_stack_top++;
843 wx_stack_count++;
844 }
845
846 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2,
847 double *x3, double *y3, double *x4, double *y4)
848 {
849 if (wx_stack_count == 0)
850 return (0);
851 wx_stack_top--;
852 wx_stack_count--;
853 *x1 = wx_stack_top->x1;
854 *y1 = wx_stack_top->y1;
855 *x2 = wx_stack_top->x2;
856 *y2 = wx_stack_top->y2;
857 *x3 = wx_stack_top->x3;
858 *y3 = wx_stack_top->y3;
859 *x4 = wx_stack_top->x4;
860 *y4 = wx_stack_top->y4;
861 return (1);
862 }
863
864 static bool wx_spline_add_point(double x, double y)
865 {
866 wxPoint *point = new wxPoint( wxRound(x), wxRound(y) );
867 wx_spline_point_list.Append(point );
868 return true;
869 }
870
871 static void wx_spline_draw_point_array(wxDC *dc)
872 {
873 dc->DrawLines(&wx_spline_point_list, 0, 0 );
874 wxPointList::compatibility_iterator node = wx_spline_point_list.GetFirst();
875 while (node)
876 {
877 wxPoint *point = node->GetData();
878 delete point;
879 wx_spline_point_list.Erase(node);
880 node = wx_spline_point_list.GetFirst();
881 }
882 }
883
884 void wxDCImpl::DoDrawSpline( const wxPointList *points )
885 {
886 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
887
888 wxPoint *p;
889 double cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
890 double x1, y1, x2, y2;
891
892 wxPointList::compatibility_iterator node = points->GetFirst();
893 if (!node)
894 // empty list
895 return;
896
897 p = (wxPoint *)node->GetData();
898
899 x1 = p->x;
900 y1 = p->y;
901
902 node = node->GetNext();
903 p = node->GetData();
904
905 x2 = p->x;
906 y2 = p->y;
907 cx1 = (double)((x1 + x2) / 2);
908 cy1 = (double)((y1 + y2) / 2);
909 cx2 = (double)((cx1 + x2) / 2);
910 cy2 = (double)((cy1 + y2) / 2);
911
912 wx_spline_add_point(x1, y1);
913
914 while ((node = node->GetNext())
915 #if !wxUSE_STL
916 != NULL
917 #endif // !wxUSE_STL
918 )
919 {
920 p = node->GetData();
921 x1 = x2;
922 y1 = y2;
923 x2 = p->x;
924 y2 = p->y;
925 cx4 = (double)(x1 + x2) / 2;
926 cy4 = (double)(y1 + y2) / 2;
927 cx3 = (double)(x1 + cx4) / 2;
928 cy3 = (double)(y1 + cy4) / 2;
929
930 wx_quadratic_spline(cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4);
931
932 cx1 = cx4;
933 cy1 = cy4;
934 cx2 = (double)(cx1 + x2) / 2;
935 cy2 = (double)(cy1 + y2) / 2;
936 }
937
938 wx_spline_add_point( cx1, cy1 );
939 wx_spline_add_point( x2, y2 );
940
941 wx_spline_draw_point_array( m_owner );
942 }
943
944 #endif // wxUSE_SPLINES
945
946
947
948 void wxDCImpl::DoGradientFillLinear(const wxRect& rect,
949 const wxColour& initialColour,
950 const wxColour& destColour,
951 wxDirection nDirection)
952 {
953 // save old pen
954 wxPen oldPen = m_pen;
955 wxBrush oldBrush = m_brush;
956
957 wxUint8 nR1 = initialColour.Red();
958 wxUint8 nG1 = initialColour.Green();
959 wxUint8 nB1 = initialColour.Blue();
960 wxUint8 nR2 = destColour.Red();
961 wxUint8 nG2 = destColour.Green();
962 wxUint8 nB2 = destColour.Blue();
963 wxUint8 nR, nG, nB;
964
965 if ( nDirection == wxEAST || nDirection == wxWEST )
966 {
967 wxInt32 x = rect.GetWidth();
968 wxInt32 w = x; // width of area to shade
969 wxInt32 xDelta = w/256; // height of one shade bend
970 if (xDelta < 1)
971 xDelta = 1;
972
973 while (x >= xDelta)
974 {
975 x -= xDelta;
976 if (nR1 > nR2)
977 nR = nR1 - (nR1-nR2)*(w-x)/w;
978 else
979 nR = nR1 + (nR2-nR1)*(w-x)/w;
980
981 if (nG1 > nG2)
982 nG = nG1 - (nG1-nG2)*(w-x)/w;
983 else
984 nG = nG1 + (nG2-nG1)*(w-x)/w;
985
986 if (nB1 > nB2)
987 nB = nB1 - (nB1-nB2)*(w-x)/w;
988 else
989 nB = nB1 + (nB2-nB1)*(w-x)/w;
990
991 wxColour colour(nR,nG,nB);
992 SetPen(wxPen(colour, 1, wxSOLID));
993 SetBrush(wxBrush(colour));
994 if(nDirection == wxEAST)
995 DoDrawRectangle(rect.GetRight()-x-xDelta+1, rect.GetTop(),
996 xDelta, rect.GetHeight());
997 else //nDirection == wxWEST
998 DoDrawRectangle(rect.GetLeft()+x, rect.GetTop(),
999 xDelta, rect.GetHeight());
1000 }
1001 }
1002 else // nDirection == wxNORTH || nDirection == wxSOUTH
1003 {
1004 wxInt32 y = rect.GetHeight();
1005 wxInt32 w = y; // height of area to shade
1006 wxInt32 yDelta = w/255; // height of one shade bend
1007 if (yDelta < 1)
1008 yDelta = 1;
1009
1010 while (y > 0)
1011 {
1012 y -= yDelta;
1013 if (nR1 > nR2)
1014 nR = nR1 - (nR1-nR2)*(w-y)/w;
1015 else
1016 nR = nR1 + (nR2-nR1)*(w-y)/w;
1017
1018 if (nG1 > nG2)
1019 nG = nG1 - (nG1-nG2)*(w-y)/w;
1020 else
1021 nG = nG1 + (nG2-nG1)*(w-y)/w;
1022
1023 if (nB1 > nB2)
1024 nB = nB1 - (nB1-nB2)*(w-y)/w;
1025 else
1026 nB = nB1 + (nB2-nB1)*(w-y)/w;
1027
1028 wxColour colour(nR,nG,nB);
1029 SetPen(wxPen(colour, 1, wxSOLID));
1030 SetBrush(wxBrush(colour));
1031 if(nDirection == wxNORTH)
1032 DoDrawRectangle(rect.GetLeft(), rect.GetTop()+y,
1033 rect.GetWidth(), yDelta);
1034 else //nDirection == wxSOUTH
1035 DoDrawRectangle(rect.GetLeft(), rect.GetBottom()-y-yDelta+1,
1036 rect.GetWidth(), yDelta);
1037 }
1038 }
1039
1040 SetPen(oldPen);
1041 SetBrush(oldBrush);
1042 }
1043
1044 void wxDCImpl::DoGradientFillConcentric(const wxRect& rect,
1045 const wxColour& initialColour,
1046 const wxColour& destColour,
1047 const wxPoint& circleCenter)
1048 {
1049 //save the old pen color
1050 wxColour oldPenColour = m_pen.GetColour();
1051
1052 wxUint8 nR1 = destColour.Red();
1053 wxUint8 nG1 = destColour.Green();
1054 wxUint8 nB1 = destColour.Blue();
1055 wxUint8 nR2 = initialColour.Red();
1056 wxUint8 nG2 = initialColour.Green();
1057 wxUint8 nB2 = initialColour.Blue();
1058 wxUint8 nR, nG, nB;
1059
1060
1061 //Radius
1062 wxInt32 cx = rect.GetWidth() / 2;
1063 wxInt32 cy = rect.GetHeight() / 2;
1064 wxInt32 nRadius;
1065 if (cx < cy)
1066 nRadius = cx;
1067 else
1068 nRadius = cy;
1069
1070 //Offset of circle
1071 wxInt32 nCircleOffX = circleCenter.x - (rect.GetWidth() / 2);
1072 wxInt32 nCircleOffY = circleCenter.y - (rect.GetHeight() / 2);
1073
1074 for ( wxInt32 x = 0; x < rect.GetWidth(); x++ )
1075 {
1076 for ( wxInt32 y = 0; y < rect.GetHeight(); y++ )
1077 {
1078 //get color difference
1079 wxInt32 nGradient = ((nRadius -
1080 (wxInt32)sqrt(
1081 pow((double)(x - cx - nCircleOffX), 2) +
1082 pow((double)(y - cy - nCircleOffY), 2)
1083 )) * 100) / nRadius;
1084
1085 //normalize Gradient
1086 if (nGradient < 0 )
1087 nGradient = 0;
1088
1089 //get dest colors
1090 nR = (wxUint8)(nR1 + ((nR2 - nR1) * nGradient / 100));
1091 nG = (wxUint8)(nG1 + ((nG2 - nG1) * nGradient / 100));
1092 nB = (wxUint8)(nB1 + ((nB2 - nB1) * nGradient / 100));
1093
1094 //set the pixel
1095 m_pen.SetColour(wxColour(nR,nG,nB));
1096 DoDrawPoint(x + rect.GetLeft(), y + rect.GetTop());
1097 }
1098 }
1099 //return old pen color
1100 m_pen.SetColour(oldPenColour);
1101 }
1102
1103 //-----------------------------------------------------------------------------
1104 // wxDC
1105 //-----------------------------------------------------------------------------
1106
1107 IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
1108
1109 void wxDC::DrawLabel(const wxString& text,
1110 const wxBitmap& bitmap,
1111 const wxRect& rect,
1112 int alignment,
1113 int indexAccel,
1114 wxRect *rectBounding)
1115 {
1116 // find the text position
1117 wxCoord widthText, heightText, heightLine;
1118 GetMultiLineTextExtent(text, &widthText, &heightText, &heightLine);
1119
1120 wxCoord width, height;
1121 if ( bitmap.Ok() )
1122 {
1123 width = widthText + bitmap.GetWidth();
1124 height = bitmap.GetHeight();
1125 }
1126 else // no bitmap
1127 {
1128 width = widthText;
1129 height = heightText;
1130 }
1131
1132 wxCoord x, y;
1133 if ( alignment & wxALIGN_RIGHT )
1134 {
1135 x = rect.GetRight() - width;
1136 }
1137 else if ( alignment & wxALIGN_CENTRE_HORIZONTAL )
1138 {
1139 x = (rect.GetLeft() + rect.GetRight() + 1 - width) / 2;
1140 }
1141 else // alignment & wxALIGN_LEFT
1142 {
1143 x = rect.GetLeft();
1144 }
1145
1146 if ( alignment & wxALIGN_BOTTOM )
1147 {
1148 y = rect.GetBottom() - height;
1149 }
1150 else if ( alignment & wxALIGN_CENTRE_VERTICAL )
1151 {
1152 y = (rect.GetTop() + rect.GetBottom() + 1 - height) / 2;
1153 }
1154 else // alignment & wxALIGN_TOP
1155 {
1156 y = rect.GetTop();
1157 }
1158
1159 // draw the bitmap first
1160 wxCoord x0 = x,
1161 y0 = y,
1162 width0 = width;
1163 if ( bitmap.Ok() )
1164 {
1165 DrawBitmap(bitmap, x, y, true /* use mask */);
1166
1167 wxCoord offset = bitmap.GetWidth() + 4;
1168 x += offset;
1169 width -= offset;
1170
1171 y += (height - heightText) / 2;
1172 }
1173
1174 // we will draw the underscore under the accel char later
1175 wxCoord startUnderscore = 0,
1176 endUnderscore = 0,
1177 yUnderscore = 0;
1178
1179 // split the string into lines and draw each of them separately
1180 wxString curLine;
1181 for ( wxString::const_iterator pc = text.begin(); ; ++pc )
1182 {
1183 if ( *pc == _T('\n') || pc == text.end() )
1184 {
1185 int xRealStart = x; // init it here to avoid compielr warnings
1186
1187 if ( !curLine.empty() )
1188 {
1189 // NB: can't test for !(alignment & wxALIGN_LEFT) because
1190 // wxALIGN_LEFT is 0
1191 if ( alignment & (wxALIGN_RIGHT | wxALIGN_CENTRE_HORIZONTAL) )
1192 {
1193 wxCoord widthLine;
1194 GetTextExtent(curLine, &widthLine, NULL);
1195
1196 if ( alignment & wxALIGN_RIGHT )
1197 {
1198 xRealStart += width - widthLine;
1199 }
1200 else // if ( alignment & wxALIGN_CENTRE_HORIZONTAL )
1201 {
1202 xRealStart += (width - widthLine) / 2;
1203 }
1204 }
1205 //else: left aligned, nothing to do
1206
1207 DrawText(curLine, xRealStart, y);
1208 }
1209
1210 y += heightLine;
1211
1212 // do we have underscore in this line? we can check yUnderscore
1213 // because it is set below to just y + heightLine if we do
1214 if ( y == yUnderscore )
1215 {
1216 // adjust the horz positions to account for the shift
1217 startUnderscore += xRealStart;
1218 endUnderscore += xRealStart;
1219 }
1220
1221 if ( pc == text.end() )
1222 break;
1223
1224 curLine.clear();
1225 }
1226 else // not end of line
1227 {
1228 if ( pc - text.begin() == indexAccel )
1229 {
1230 // remeber to draw underscore here
1231 GetTextExtent(curLine, &startUnderscore, NULL);
1232 curLine += *pc;
1233 GetTextExtent(curLine, &endUnderscore, NULL);
1234
1235 yUnderscore = y + heightLine;
1236 }
1237 else
1238 {
1239 curLine += *pc;
1240 }
1241 }
1242 }
1243
1244 // draw the underscore if found
1245 if ( startUnderscore != endUnderscore )
1246 {
1247 // it should be of the same colour as text
1248 SetPen(wxPen(GetTextForeground(), 0, wxSOLID));
1249
1250 yUnderscore--;
1251
1252 DrawLine(startUnderscore, yUnderscore, endUnderscore, yUnderscore);
1253 }
1254
1255 // return bounding rect if requested
1256 if ( rectBounding )
1257 {
1258 *rectBounding = wxRect(x, y - heightText, widthText, heightText);
1259 }
1260
1261 CalcBoundingBox(x0, y0);
1262 CalcBoundingBox(x0 + width0, y0 + height);
1263 }
1264
1265 #if WXWIN_COMPATIBILITY_2_8
1266 // for compatibility with the old code when wxCoord was long everywhere
1267 void wxDC::GetTextExtent(const wxString& string,
1268 long *x, long *y,
1269 long *descent,
1270 long *externalLeading,
1271 const wxFont *theFont) const
1272 {
1273 wxCoord x2, y2, descent2, externalLeading2;
1274 m_pimpl->DoGetTextExtent(string, &x2, &y2,
1275 &descent2, &externalLeading2,
1276 theFont);
1277 if ( x )
1278 *x = x2;
1279 if ( y )
1280 *y = y2;
1281 if ( descent )
1282 *descent = descent2;
1283 if ( externalLeading )
1284 *externalLeading = externalLeading2;
1285 }
1286
1287 void wxDC::GetLogicalOrigin(long *x, long *y) const
1288 {
1289 wxCoord x2, y2;
1290 m_pimpl->DoGetLogicalOrigin(&x2, &y2);
1291 if ( x )
1292 *x = x2;
1293 if ( y )
1294 *y = y2;
1295 }
1296
1297 void wxDC::GetDeviceOrigin(long *x, long *y) const
1298 {
1299 wxCoord x2, y2;
1300 m_pimpl->DoGetDeviceOrigin(&x2, &y2);
1301 if ( x )
1302 *x = x2;
1303 if ( y )
1304 *y = y2;
1305 }
1306
1307 void wxDC::GetClippingBox(long *x, long *y, long *w, long *h) const
1308 {
1309 wxCoord xx,yy,ww,hh;
1310 m_pimpl->DoGetClippingBox(&xx, &yy, &ww, &hh);
1311 if (x) *x = xx;
1312 if (y) *y = yy;
1313 if (w) *w = ww;
1314 if (h) *h = hh;
1315 }
1316
1317 #endif // WXWIN_COMPATIBILITY_2_8
wxWidgets (Impactor)