]> git.saurik.com Git - wxWidgets.git/blame_incremental - include/wx/dc.h
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
compilation fix for wxUSE_STL==1 build
[wxWidgets.git] / include / wx / dc.h
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: wx/dc.h
3// Purpose: 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#ifndef _WX_DC_H_BASE_
13#define _WX_DC_H_BASE_
14
15// ----------------------------------------------------------------------------
16// headers which we must include here
17// ----------------------------------------------------------------------------
18
19#include "wx/object.h" // the base class
20
21#include "wx/intl.h" // for wxLayoutDirection
22#include "wx/cursor.h" // we have member variables of these classes
23#include "wx/font.h" // so we can't do without them
24#include "wx/colour.h"
25#include "wx/bitmap.h" // for wxNullBitmap
26#include "wx/brush.h"
27#include "wx/pen.h"
28#include "wx/palette.h"
29#include "wx/list.h" // we use wxList in inline functions
30#include "wx/dynarray.h"
31#include "wx/math.h"
32#include "wx/image.h"
33
34 // 1 if using the reorganized DC code
35#define wxUSE_NEW_DC 0
36
37
38#if wxUSE_NEW_DC
39class WXDLLIMPEXP_FWD_CORE wxDC;
40class WXDLLIMPEXP_FWD_CORE wxClientDC;
41class WXDLLIMPEXP_FWD_CORE wxPaintDC;
42class WXDLLIMPEXP_FWD_CORE wxWindowDC;
43class WXDLLIMPEXP_FWD_CORE wxScreenDC;
44class WXDLLIMPEXP_FWD_CORE wxMemoryDC;
45#else
46class WXDLLIMPEXP_FWD_CORE wxDCBase;
47#endif
48
49class WXDLLEXPORT wxDrawObject
50{
51public:
52
53 wxDrawObject()
54 : m_isBBoxValid(false)
55 , m_minX(0), m_minY(0), m_maxX(0), m_maxY(0)
56 { }
57
58 virtual ~wxDrawObject() { }
59
60#if wxUSE_NEW_DC
61 virtual void Draw(wxDC&) const { }
62#else
63 virtual void Draw(wxDCBase&) const { }
64#endif
65
66 virtual void CalcBoundingBox(wxCoord x, wxCoord y)
67 {
68 if ( m_isBBoxValid )
69 {
70 if ( x < m_minX ) m_minX = x;
71 if ( y < m_minY ) m_minY = y;
72 if ( x > m_maxX ) m_maxX = x;
73 if ( y > m_maxY ) m_maxY = y;
74 }
75 else
76 {
77 m_isBBoxValid = true;
78
79 m_minX = x;
80 m_minY = y;
81 m_maxX = x;
82 m_maxY = y;
83 }
84 }
85
86 void ResetBoundingBox()
87 {
88 m_isBBoxValid = false;
89
90 m_minX = m_maxX = m_minY = m_maxY = 0;
91 }
92
93 // Get the final bounding box of the PostScript or Metafile picture.
94
95 wxCoord MinX() const { return m_minX; }
96 wxCoord MaxX() const { return m_maxX; }
97 wxCoord MinY() const { return m_minY; }
98 wxCoord MaxY() const { return m_maxY; }
99
100 //to define the type of object for derived objects
101 virtual int GetType()=0;
102
103protected:
104 //for boundingbox calculation
105 bool m_isBBoxValid:1;
106 //for boundingbox calculation
107 wxCoord m_minX, m_minY, m_maxX, m_maxY;
108};
109
110
111#if wxUSE_NEW_DC
112
113//-----------------------------------------------------------------------------
114// wxDCFactory
115//-----------------------------------------------------------------------------
116
117class WXDLLIMPEXP_FWD_CORE wxImplDC;
118
119class WXDLLIMPEXP_CORE wxDCFactory
120{
121public:
122 wxDCFactory() {}
123 virtual ~wxDCFactory() {}
124
125 virtual wxImplDC* CreateWindowDC( wxWindowDC *owner ) = 0;
126 virtual wxImplDC* CreateWindowDC( wxWindowDC *owner, wxWindow *window ) = 0;
127 virtual wxImplDC* CreateClientDC( wxClientDC *owner ) = 0;
128 virtual wxImplDC* CreateClientDC( wxClientDC *owner, wxWindow *window ) = 0;
129 virtual wxImplDC* CreatePaintDC( wxPaintDC *owner ) = 0;
130 virtual wxImplDC* CreatePaintDC( wxPaintDC *owner, wxWindow *window ) = 0;
131 virtual wxImplDC* CreateMemoryDC( wxMemoryDC *owner ) = 0;
132 virtual wxImplDC* CreateMemoryDC( wxMemoryDC *owner, wxBitmap &bitmap ) = 0;
133 virtual wxImplDC* CreateMemoryDC( wxMemoryDC *owner, wxDC *dc ) = 0;
134 virtual wxImplDC* CreateScreenDC( wxScreenDC *owner ) = 0;
135
136 static void SetDCFactory( wxDCFactory *factory );
137 static wxDCFactory *GetFactory();
138private:
139 static wxDCFactory *m_factory;
140};
141
142//-----------------------------------------------------------------------------
143// wxNativeDCFactory
144//-----------------------------------------------------------------------------
145
146class WXDLLIMPEXP_CORE wxNativeDCFactory: public wxDCFactory
147{
148public:
149 wxNativeDCFactory() {}
150
151 virtual wxImplDC* CreateWindowDC( wxWindowDC *owner );
152 virtual wxImplDC* CreateWindowDC( wxWindowDC *owner, wxWindow *window );
153 virtual wxImplDC* CreateClientDC( wxClientDC *owner );
154 virtual wxImplDC* CreateClientDC( wxClientDC *owner, wxWindow *window );
155 virtual wxImplDC* CreatePaintDC( wxPaintDC *owner );
156 virtual wxImplDC* CreatePaintDC( wxPaintDC *owner, wxWindow *window );
157 virtual wxImplDC* CreateMemoryDC( wxMemoryDC *owner );
158 virtual wxImplDC* CreateMemoryDC( wxMemoryDC *owner, wxBitmap &bitmap );
159 virtual wxImplDC* CreateMemoryDC( wxMemoryDC *owner, wxDC *dc );
160 virtual wxImplDC* CreateScreenDC( wxScreenDC *owner );
161};
162
163//-----------------------------------------------------------------------------
164// wxImplDC
165//-----------------------------------------------------------------------------
166
167class WXDLLIMPEXP_CORE wxImplDC: public wxObject
168{
169public:
170 wxImplDC( wxDC *owner );
171 ~wxImplDC();
172
173 wxDC *GetOwner() const { return m_owner; }
174
175 virtual bool IsOk() const { return m_ok; }
176
177 // query capabilities
178
179 virtual bool CanDrawBitmap() const = 0;
180 virtual bool CanGetTextExtent() const = 0;
181
182 // query dimension, colour deps, resolution
183
184 virtual void DoGetSize(int *width, int *height) const = 0;
185 virtual void DoGetSizeMM(int* width, int* height) const = 0;
186
187 virtual int GetDepth() const = 0;
188 virtual wxSize GetPPI() const = 0;
189
190 // Right-To-Left (RTL) modes
191
192 virtual void SetLayoutDirection(wxLayoutDirection WXUNUSED(dir)) { }
193 virtual wxLayoutDirection GetLayoutDirection() const { return wxLayout_Default; }
194
195 // page and document
196
197 virtual bool StartDoc(const wxString& WXUNUSED(message)) { return true; }
198 virtual void EndDoc() { }
199
200 virtual void StartPage() { }
201 virtual void EndPage() { }
202
203 // bounding box
204
205 virtual void CalcBoundingBox(wxCoord x, wxCoord y)
206 {
207 if ( m_isBBoxValid )
208 {
209 if ( x < m_minX ) m_minX = x;
210 if ( y < m_minY ) m_minY = y;
211 if ( x > m_maxX ) m_maxX = x;
212 if ( y > m_maxY ) m_maxY = y;
213 }
214 else
215 {
216 m_isBBoxValid = true;
217
218 m_minX = x;
219 m_minY = y;
220 m_maxX = x;
221 m_maxY = y;
222 }
223 }
224 void ResetBoundingBox()
225 {
226 m_isBBoxValid = false;
227
228 m_minX = m_maxX = m_minY = m_maxY = 0;
229 }
230
231 wxCoord MinX() const { return m_minX; }
232 wxCoord MaxX() const { return m_maxX; }
233 wxCoord MinY() const { return m_minY; }
234 wxCoord MaxY() const { return m_maxY; }
235
236 // setters and getters
237
238 virtual void SetFont(const wxFont& font) = 0;
239 virtual const wxFont& GetFont() const { return m_font; }
240
241 virtual void SetPen(const wxPen& pen) = 0;
242 virtual const wxPen& GetPen() const { return m_pen; }
243
244 virtual void SetBrush(const wxBrush& brush) = 0;
245 virtual const wxBrush& GetBrush() const { return m_brush; }
246
247 virtual void SetBackground(const wxBrush& brush) = 0;
248 virtual const wxBrush& GetBackground() const { return m_backgroundBrush; }
249
250 virtual void SetBackgroundMode(int mode) = 0;
251 virtual int GetBackgroundMode() const { return m_backgroundMode; }
252
253 virtual void SetTextForeground(const wxColour& colour)
254 { m_textForegroundColour = colour; }
255 virtual const wxColour& GetTextForeground() const { return m_textForegroundColour; }
256
257 virtual void SetTextBackground(const wxColour& colour)
258 { m_textBackgroundColour = colour; }
259 virtual const wxColour& GetTextBackground() const { return m_textBackgroundColour; }
260
261#if wxUSE_PALETTE
262 virtual void SetPalette(const wxPalette& palette) = 0;
263#endif // wxUSE_PALETTE
264
265 // logical functions
266
267 virtual void SetLogicalFunction(int function) = 0;
268 virtual int GetLogicalFunction() const { return m_logicalFunction; }
269
270 // text measurement
271
272 virtual wxCoord GetCharHeight() const = 0;
273 virtual wxCoord GetCharWidth() const = 0;
274 virtual void DoGetTextExtent(const wxString& string,
275 wxCoord *x, wxCoord *y,
276 wxCoord *descent = NULL,
277 wxCoord *externalLeading = NULL,
278 const wxFont *theFont = NULL) const = 0;
279 virtual void GetMultiLineTextExtent(const wxString& string,
280 wxCoord *width,
281 wxCoord *height,
282 wxCoord *heightLine = NULL,
283 const wxFont *font = NULL) const;
284 virtual bool DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const;
285
286 // clearing
287
288 virtual void Clear() = 0;
289
290 // clipping
291
292 virtual void DoSetClippingRegion(wxCoord x, wxCoord y,
293 wxCoord width, wxCoord height) = 0;
294 virtual void DoSetClippingRegionAsRegion(const wxRegion& region) = 0;
295
296 virtual void DoGetClippingBox(wxCoord *x, wxCoord *y,
297 wxCoord *w, wxCoord *h) const
298 {
299 if ( x )
300 *x = m_clipX1;
301 if ( y )
302 *y = m_clipY1;
303 if ( w )
304 *w = m_clipX2 - m_clipX1;
305 if ( h )
306 *h = m_clipY2 - m_clipY1;
307 }
308
309 virtual void DestroyClippingRegion() { ResetClipping(); }
310
311
312 // coordinates conversions and transforms
313
314 virtual wxCoord DeviceToLogicalX(wxCoord x) const;
315 virtual wxCoord DeviceToLogicalY(wxCoord y) const;
316 virtual wxCoord DeviceToLogicalXRel(wxCoord x) const;
317 virtual wxCoord DeviceToLogicalYRel(wxCoord y) const;
318 virtual wxCoord LogicalToDeviceX(wxCoord x) const;
319 virtual wxCoord LogicalToDeviceY(wxCoord y) const;
320 virtual wxCoord LogicalToDeviceXRel(wxCoord x) const;
321 virtual wxCoord LogicalToDeviceYRel(wxCoord y) const;
322
323 virtual void SetMapMode(int mode);
324 virtual int GetMapMode() const { return m_mappingMode; }
325
326 virtual void SetUserScale(double x, double y);
327 virtual void GetUserScale(double *x, double *y) const
328 {
329 if ( x ) *x = m_userScaleX;
330 if ( y ) *y = m_userScaleY;
331 }
332
333 virtual void SetLogicalScale(double x, double y);
334 virtual void GetLogicalScale(double *x, double *y)
335 {
336 if ( x ) *x = m_logicalScaleX;
337 if ( y ) *y = m_logicalScaleY;
338 }
339
340 virtual void SetLogicalOrigin(wxCoord x, wxCoord y);
341 virtual void DoGetLogicalOrigin(wxCoord *x, wxCoord *y) const
342 {
343 if ( x ) *x = m_logicalOriginX;
344 if ( y ) *y = m_logicalOriginY;
345 }
346
347 virtual void SetDeviceOrigin(wxCoord x, wxCoord y);
348 virtual void DoGetDeviceOrigin(wxCoord *x, wxCoord *y) const
349 {
350 if ( x ) *x = m_deviceOriginX;
351 if ( y ) *y = m_deviceOriginY;
352 }
353
354 virtual void SetDeviceLocalOrigin( wxCoord x, wxCoord y );
355
356 virtual void ComputeScaleAndOrigin();
357
358 // this needs to overidden if the axis is inverted
359 virtual void SetAxisOrientation(bool xLeftRight, bool yBottomUp);
360
361 // ---------------------------------------------------------
362 // the actual drawing API
363
364 virtual bool DoFloodFill(wxCoord x, wxCoord y, const wxColour& col,
365 int style = wxFLOOD_SURFACE) = 0;
366
367 virtual void DoGradientFillLinear(const wxRect& rect,
368 const wxColour& initialColour,
369 const wxColour& destColour,
370 wxDirection nDirection = wxEAST);
371
372 virtual void DoGradientFillConcentric(const wxRect& rect,
373 const wxColour& initialColour,
374 const wxColour& destColour,
375 const wxPoint& circleCenter);
376
377 virtual bool DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const = 0;
378
379 virtual void DoDrawPoint(wxCoord x, wxCoord y) = 0;
380 virtual void DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2) = 0;
381
382 virtual void DoDrawArc(wxCoord x1, wxCoord y1,
383 wxCoord x2, wxCoord y2,
384 wxCoord xc, wxCoord yc) = 0;
385 virtual void DoDrawCheckMark(wxCoord x, wxCoord y,
386 wxCoord width, wxCoord height);
387 virtual void DoDrawEllipticArc(wxCoord x, wxCoord y, wxCoord w, wxCoord h,
388 double sa, double ea) = 0;
389
390 virtual void DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height) = 0;
391 virtual void DoDrawRoundedRectangle(wxCoord x, wxCoord y,
392 wxCoord width, wxCoord height,
393 double radius) = 0;
394 virtual void DoDrawEllipse(wxCoord x, wxCoord y,
395 wxCoord width, wxCoord height) = 0;
396
397 virtual void DoCrossHair(wxCoord x, wxCoord y) = 0;
398
399 virtual void DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y) = 0;
400 virtual void DoDrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y,
401 bool useMask = false) = 0;
402
403 virtual void DoDrawText(const wxString& text, wxCoord x, wxCoord y) = 0;
404 virtual void DoDrawRotatedText(const wxString& text,
405 wxCoord x, wxCoord y, double angle) = 0;
406
407 virtual bool DoBlit(wxCoord xdest, wxCoord ydest,
408 wxCoord width, wxCoord height,
409 wxDC *source,
410 wxCoord xsrc, wxCoord ysrc,
411 int rop = wxCOPY,
412 bool useMask = false,
413 wxCoord xsrcMask = wxDefaultCoord,
414 wxCoord ysrcMask = wxDefaultCoord) = 0;
415
416 virtual bool DoStretchBlit(wxCoord xdest, wxCoord ydest,
417 wxCoord dstWidth, wxCoord dstHeight,
418 wxDC *source,
419 wxCoord xsrc, wxCoord ysrc,
420 wxCoord srcWidth, wxCoord srcHeight,
421 int rop = wxCOPY,
422 bool useMask = false,
423 wxCoord xsrcMask = wxDefaultCoord,
424 wxCoord ysrcMask = wxDefaultCoord);
425
426 virtual wxBitmap DoGetAsBitmap(const wxRect *WXUNUSED(subrect)) const
427 { return wxNullBitmap; }
428
429
430 virtual void DoDrawLines(int n, wxPoint points[],
431 wxCoord xoffset, wxCoord yoffset) = 0;
432 virtual void DoDrawPolygon(int n, wxPoint points[],
433 wxCoord xoffset, wxCoord yoffset,
434 int fillStyle = wxODDEVEN_RULE) = 0;
435 virtual void DoDrawPolyPolygon(int n, int count[], wxPoint points[],
436 wxCoord xoffset, wxCoord yoffset,
437 int fillStyle);
438
439
440
441#if wxUSE_SPLINES
442 virtual void DoDrawSpline(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord x3, wxCoord y3);
443 virtual void DoDrawSpline(int n, wxPoint points[]);
444 virtual void DoDrawSpline(wxList *points);
445#endif
446
447private:
448 wxDC *m_owner;
449
450protected:
451 // unset clipping variables (after clipping region was destroyed)
452 void ResetClipping()
453 {
454 m_clipping = false;
455
456 m_clipX1 = m_clipX2 = m_clipY1 = m_clipY2 = 0;
457 }
458
459 // flags
460 bool m_colour:1;
461 bool m_ok:1;
462 bool m_clipping:1;
463 bool m_isInteractive:1;
464 bool m_isBBoxValid:1;
465
466 // coordinate system variables
467
468 wxCoord m_logicalOriginX, m_logicalOriginY;
469 wxCoord m_deviceOriginX, m_deviceOriginY; // Usually 0,0, can be change by user
470
471 wxCoord m_deviceLocalOriginX, m_deviceLocalOriginY; // non-zero if native top-left corner
472 // is not at 0,0. This was the case under
473 // Mac's GrafPorts (coordinate system
474 // used toplevel window's origin) and
475 // e.g. for Postscript, where the native
476 // origin in the bottom left corner.
477 double m_logicalScaleX, m_logicalScaleY;
478 double m_userScaleX, m_userScaleY;
479 double m_scaleX, m_scaleY; // calculated from logical scale and user scale
480
481 int m_signX, m_signY; // Used by SetAxisOrientation() to invert the axes
482
483 // what is a mm on a screen you don't know the size of?
484 double m_mm_to_pix_x,
485 m_mm_to_pix_y;
486
487 // bounding and clipping boxes
488 wxCoord m_minX, m_minY, m_maxX, m_maxY;
489 wxCoord m_clipX1, m_clipY1, m_clipX2, m_clipY2;
490
491 int m_logicalFunction;
492 int m_backgroundMode;
493 int m_mappingMode;
494
495 wxPen m_pen;
496 wxBrush m_brush;
497 wxBrush m_backgroundBrush;
498 wxColour m_textForegroundColour;
499 wxColour m_textBackgroundColour;
500 wxFont m_font;
501
502#if wxUSE_PALETTE
503 wxPalette m_palette;
504 bool m_hasCustomPalette;
505#endif // wxUSE_PALETTE
506
507private:
508 DECLARE_ABSTRACT_CLASS(wxImplDC)
509};
510
511
512class wxDC: public wxObject
513{
514public:
515 wxDC() { m_pimpl = NULL; }
516
517 wxImplDC *GetImpl()
518 { return m_pimpl; }
519
520 bool IsOk() const
521 { return m_pimpl && m_pimpl->IsOk(); }
522
523 // query capabilities
524
525 bool CanDrawBitmap() const
526 { return m_pimpl->CanDrawBitmap(); }
527 bool CanGetTextExtent() const
528 { return m_pimpl->CanGetTextExtent(); }
529
530 // query dimension, colour deps, resolution
531
532 void GetSize(int *width, int *height) const
533 { m_pimpl->DoGetSize(width, height); }
534
535 wxSize GetSize() const
536 {
537 int w, h;
538 m_pimpl->DoGetSize(&w, &h);
539 return wxSize(w, h);
540 }
541
542 void GetSizeMM(int* width, int* height) const
543 { m_pimpl->DoGetSizeMM(width, height); }
544 wxSize GetSizeMM() const
545 {
546 int w, h;
547 m_pimpl->DoGetSizeMM(&w, &h);
548 return wxSize(w, h);
549 }
550
551 int GetDepth() const
552 { return m_pimpl->GetDepth(); }
553 wxSize GetPPI() const
554 { return m_pimpl->GetPPI(); }
555
556 // Right-To-Left (RTL) modes
557
558 void SetLayoutDirection(wxLayoutDirection dir)
559 { m_pimpl->SetLayoutDirection( dir ); }
560 wxLayoutDirection GetLayoutDirection() const
561 { return m_pimpl->GetLayoutDirection(); }
562
563 // page and document
564
565 bool StartDoc(const wxString& message)
566 { return m_pimpl->StartDoc(message); }
567 void EndDoc()
568 { m_pimpl->EndDoc(); }
569
570 void StartPage()
571 { m_pimpl->StartPage(); }
572 void EndPage()
573 { m_pimpl->EndPage(); }
574
575 // bounding box
576
577 void CalcBoundingBox(wxCoord x, wxCoord y)
578 { m_pimpl->CalcBoundingBox(x,y); }
579 void ResetBoundingBox()
580 { m_pimpl->ResetBoundingBox(); }
581
582 wxCoord MinX() const
583 { return m_pimpl->MinX(); }
584 wxCoord MaxX() const
585 { return m_pimpl->MaxX(); }
586 wxCoord MinY() const
587 { return m_pimpl->MinY(); }
588 wxCoord MaxY() const
589 { return m_pimpl->MaxY(); }
590
591 // setters and getters
592
593 void SetFont(const wxFont& font)
594 { m_pimpl->SetFont( font ); }
595 const wxFont& GetFont() const
596 { return m_pimpl->GetFont(); }
597
598 void SetPen(const wxPen& pen)
599 { m_pimpl->SetPen( pen ); }
600 const wxPen& GetPen() const
601 { return m_pimpl->GetPen(); }
602
603 void SetBrush(const wxBrush& brush)
604 { m_pimpl->SetBrush( brush ); }
605 const wxBrush& GetBrush() const
606 { return m_pimpl->GetBrush(); }
607
608 void SetBackground(const wxBrush& brush)
609 { m_pimpl->SetBackground( brush ); }
610 const wxBrush& GetBackground() const
611 { return m_pimpl->GetBackground(); }
612
613 void SetBackgroundMode(int mode)
614 { m_pimpl->SetBackgroundMode( mode ); }
615 int GetBackgroundMode() const
616 { return m_pimpl->GetBackgroundMode(); }
617
618 void SetTextForeground(const wxColour& colour)
619 { m_pimpl->SetTextForeground(colour); }
620 const wxColour& GetTextForeground() const
621 { return m_pimpl->GetTextForeground(); }
622
623 void SetTextBackground(const wxColour& colour)
624 { m_pimpl->SetTextBackground(colour); }
625 const wxColour& GetTextBackground() const
626 { return m_pimpl->GetTextBackground(); }
627
628#if wxUSE_PALETTE
629 void SetPalette(const wxPalette& palette)
630 { m_pimpl->SetPalette(palette); }
631#endif // wxUSE_PALETTE
632
633 // logical functions
634
635 void SetLogicalFunction(int function)
636 { m_pimpl->SetLogicalFunction(function); }
637 int GetLogicalFunction() const
638 { return m_pimpl->GetLogicalFunction(); }
639
640 // text measurement
641
642 wxCoord GetCharHeight() const
643 { return m_pimpl->GetCharHeight(); }
644 wxCoord GetCharWidth() const
645 { return m_pimpl->GetCharWidth(); }
646
647 void GetTextExtent(const wxString& string,
648 wxCoord *x, wxCoord *y,
649 wxCoord *descent = NULL,
650 wxCoord *externalLeading = NULL,
651 const wxFont *theFont = NULL) const
652 { m_pimpl->DoGetTextExtent(string, x, y, descent, externalLeading, theFont); }
653
654 wxSize GetTextExtent(const wxString& string) const
655 {
656 wxCoord w, h;
657 m_pimpl->DoGetTextExtent(string, &w, &h);
658 return wxSize(w, h);
659 }
660
661 void GetMultiLineTextExtent(const wxString& string,
662 wxCoord *width,
663 wxCoord *height,
664 wxCoord *heightLine = NULL,
665 const wxFont *font = NULL) const
666 { m_pimpl->GetMultiLineTextExtent( string, width, height, heightLine, font ); }
667
668 wxSize GetMultiLineTextExtent(const wxString& string) const
669 {
670 wxCoord w, h;
671 m_pimpl->GetMultiLineTextExtent(string, &w, &h);
672 return wxSize(w, h);
673 }
674
675 bool GetPartialTextExtents(const wxString& text, wxArrayInt& widths) const
676 { return m_pimpl->DoGetPartialTextExtents(text, widths); }
677
678 // clearing
679
680 void Clear()
681 { m_pimpl->Clear(); }
682
683 // clipping
684
685 void SetClippingRegion(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
686 { m_pimpl->DoSetClippingRegion(x, y, width, height); }
687 void SetClippingRegion(const wxPoint& pt, const wxSize& sz)
688 { m_pimpl->DoSetClippingRegion(pt.x, pt.y, sz.x, sz.y); }
689 void SetClippingRegion(const wxRect& rect)
690 { m_pimpl->DoSetClippingRegion(rect.x, rect.y, rect.width, rect.height); }
691 void SetClippingRegion(const wxRegion& region)
692 { m_pimpl->DoSetClippingRegionAsRegion(region); }
693
694 void DestroyClippingRegion()
695 { m_pimpl->DestroyClippingRegion(); }
696
697 void GetClippingBox(wxCoord *x, wxCoord *y, wxCoord *w, wxCoord *h) const
698 { m_pimpl->DoGetClippingBox(x, y, w, h); }
699 void GetClippingBox(wxRect& rect) const
700 { m_pimpl->DoGetClippingBox(&rect.x, &rect.y, &rect.width, &rect.height); }
701
702 // coordinates conversions and transforms
703
704 wxCoord DeviceToLogicalX(wxCoord x) const
705 { return m_pimpl->DeviceToLogicalX(x); }
706 wxCoord DeviceToLogicalY(wxCoord y) const
707 { return m_pimpl->DeviceToLogicalY(y); }
708 wxCoord DeviceToLogicalXRel(wxCoord x) const
709 { return m_pimpl->DeviceToLogicalXRel(x); }
710 wxCoord DeviceToLogicalYRel(wxCoord y) const
711 { return m_pimpl->DeviceToLogicalYRel(y); }
712 wxCoord LogicalToDeviceX(wxCoord x) const
713 { return m_pimpl->LogicalToDeviceX(x); }
714 wxCoord LogicalToDeviceY(wxCoord y) const
715 { return m_pimpl->LogicalToDeviceY(y); }
716 wxCoord LogicalToDeviceXRel(wxCoord x) const
717 { return m_pimpl->LogicalToDeviceXRel(x); }
718 wxCoord LogicalToDeviceYRel(wxCoord y) const
719 { return m_pimpl->LogicalToDeviceYRel(y); }
720
721 void SetMapMode(int mode)
722 { m_pimpl->SetMapMode(mode); }
723 int GetMapMode() const
724 { return m_pimpl->GetMapMode(); }
725
726 void SetUserScale(double x, double y)
727 { m_pimpl->SetUserScale(x,y); }
728 void GetUserScale(double *x, double *y) const
729 { m_pimpl->GetUserScale( x, y ); }
730
731 void SetLogicalScale(double x, double y)
732 { m_pimpl->SetLogicalScale( x, y ); }
733 void GetLogicalScale(double *x, double *y)
734 { m_pimpl->GetLogicalScale( x, y ); }
735
736 void SetLogicalOrigin(wxCoord x, wxCoord y)
737 { m_pimpl->SetLogicalOrigin(x,y); }
738 void GetLogicalOrigin(wxCoord *x, wxCoord *y) const
739 { m_pimpl->DoGetLogicalOrigin(x, y); }
740 wxPoint GetLogicalOrigin() const
741 { wxCoord x, y; m_pimpl->DoGetLogicalOrigin(&x, &y); return wxPoint(x, y); }
742
743 void SetDeviceOrigin(wxCoord x, wxCoord y)
744 { m_pimpl->SetDeviceOrigin( x, y); }
745 void GetDeviceOrigin(wxCoord *x, wxCoord *y) const
746 { m_pimpl->DoGetDeviceOrigin(x, y); }
747 wxPoint GetDeviceOrigin() const
748 { wxCoord x, y; m_pimpl->DoGetDeviceOrigin(&x, &y); return wxPoint(x, y); }
749
750 void SetAxisOrientation(bool xLeftRight, bool yBottomUp)
751 { m_pimpl->SetAxisOrientation(xLeftRight, yBottomUp); }
752
753 // mostly internal
754 void SetDeviceLocalOrigin( wxCoord x, wxCoord y )
755 { m_pimpl->SetDeviceLocalOrigin( x, y ); }
756
757
758 // draw generic object
759
760 void DrawObject(wxDrawObject* drawobject)
761 {
762 drawobject->Draw(*this);
763 CalcBoundingBox(drawobject->MinX(),drawobject->MinY());
764 CalcBoundingBox(drawobject->MaxX(),drawobject->MaxY());
765 }
766
767 // -----------------------------------------------
768 // the actual drawing API
769
770 bool FloodFill(wxCoord x, wxCoord y, const wxColour& col,
771 int style = wxFLOOD_SURFACE)
772 { return m_pimpl->DoFloodFill(x, y, col, style); }
773 bool FloodFill(const wxPoint& pt, const wxColour& col,
774 int style = wxFLOOD_SURFACE)
775 { return m_pimpl->DoFloodFill(pt.x, pt.y, col, style); }
776
777 // fill the area specified by rect with a radial gradient, starting from
778 // initialColour in the centre of the cercle and fading to destColour.
779 void GradientFillConcentric(const wxRect& rect,
780 const wxColour& initialColour,
781 const wxColour& destColour)
782 { m_pimpl->DoGradientFillConcentric( rect, initialColour, destColour,
783 wxPoint(rect.GetWidth() / 2,
784 rect.GetHeight() / 2)); }
785
786 void GradientFillConcentric(const wxRect& rect,
787 const wxColour& initialColour,
788 const wxColour& destColour,
789 const wxPoint& circleCenter)
790 { m_pimpl->DoGradientFillConcentric(rect, initialColour, destColour, circleCenter); }
791
792 // fill the area specified by rect with a linear gradient
793 void GradientFillLinear(const wxRect& rect,
794 const wxColour& initialColour,
795 const wxColour& destColour,
796 wxDirection nDirection = wxEAST)
797 { m_pimpl->DoGradientFillLinear(rect, initialColour, destColour, nDirection); }
798
799 bool GetPixel(wxCoord x, wxCoord y, wxColour *col) const
800 { return m_pimpl->DoGetPixel(x, y, col); }
801 bool GetPixel(const wxPoint& pt, wxColour *col) const
802 { return m_pimpl->DoGetPixel(pt.x, pt.y, col); }
803
804 void DrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
805 { m_pimpl->DoDrawLine(x1, y1, x2, y2); }
806 void DrawLine(const wxPoint& pt1, const wxPoint& pt2)
807 { m_pimpl->DoDrawLine(pt1.x, pt1.y, pt2.x, pt2.y); }
808
809 void CrossHair(wxCoord x, wxCoord y)
810 { m_pimpl->DoCrossHair(x, y); }
811 void CrossHair(const wxPoint& pt)
812 { m_pimpl->DoCrossHair(pt.x, pt.y); }
813
814 void DrawArc(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2,
815 wxCoord xc, wxCoord yc)
816 { m_pimpl->DoDrawArc(x1, y1, x2, y2, xc, yc); }
817 void DrawArc(const wxPoint& pt1, const wxPoint& pt2, const wxPoint& centre)
818 { m_pimpl->DoDrawArc(pt1.x, pt1.y, pt2.x, pt2.y, centre.x, centre.y); }
819
820 void DrawCheckMark(wxCoord x, wxCoord y,
821 wxCoord width, wxCoord height)
822 { m_pimpl->DoDrawCheckMark(x, y, width, height); }
823 void DrawCheckMark(const wxRect& rect)
824 { m_pimpl->DoDrawCheckMark(rect.x, rect.y, rect.width, rect.height); }
825
826 void DrawEllipticArc(wxCoord x, wxCoord y, wxCoord w, wxCoord h,
827 double sa, double ea)
828 { m_pimpl->DoDrawEllipticArc(x, y, w, h, sa, ea); }
829 void DrawEllipticArc(const wxPoint& pt, const wxSize& sz,
830 double sa, double ea)
831 { m_pimpl->DoDrawEllipticArc(pt.x, pt.y, sz.x, sz.y, sa, ea); }
832
833 void DrawPoint(wxCoord x, wxCoord y)
834 { m_pimpl->DoDrawPoint(x, y); }
835 void DrawPoint(const wxPoint& pt)
836 { m_pimpl->DoDrawPoint(pt.x, pt.y); }
837
838 void DrawLines(int n, wxPoint points[],
839 wxCoord xoffset = 0, wxCoord yoffset = 0)
840 { m_pimpl->DoDrawLines(n, points, xoffset, yoffset); }
841
842#if 0
843 // needs to be removed
844 void DrawLines(const wxList *list,
845 wxCoord xoffset = 0, wxCoord yoffset = 0)
846#endif
847
848 void DrawPolygon(int n, wxPoint points[],
849 wxCoord xoffset = 0, wxCoord yoffset = 0,
850 int fillStyle = wxODDEVEN_RULE)
851 { m_pimpl->DoDrawPolygon(n, points, xoffset, yoffset, fillStyle); }
852
853#if 0
854 // needs to be removed
855 void DrawPolygon(const wxList *list,
856 wxCoord xoffset = 0, wxCoord yoffset = 0,
857 int fillStyle = wxODDEVEN_RULE)
858 { m_pimpl->DrawPolygon( list, xoffset, yoffset, fillStyle ); }
859#endif
860
861 void DrawPolyPolygon(int n, int count[], wxPoint points[],
862 wxCoord xoffset = 0, wxCoord yoffset = 0,
863 int fillStyle = wxODDEVEN_RULE)
864 { m_pimpl->DoDrawPolyPolygon(n, count, points, xoffset, yoffset, fillStyle); }
865
866 void DrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
867 { m_pimpl->DoDrawRectangle(x, y, width, height); }
868 void DrawRectangle(const wxPoint& pt, const wxSize& sz)
869 { m_pimpl->DoDrawRectangle(pt.x, pt.y, sz.x, sz.y); }
870 void DrawRectangle(const wxRect& rect)
871 { m_pimpl->DoDrawRectangle(rect.x, rect.y, rect.width, rect.height); }
872
873 void DrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height,
874 double radius)
875 { m_pimpl->DoDrawRoundedRectangle(x, y, width, height, radius); }
876 void DrawRoundedRectangle(const wxPoint& pt, const wxSize& sz,
877 double radius)
878 { m_pimpl->DoDrawRoundedRectangle(pt.x, pt.y, sz.x, sz.y, radius); }
879 void DrawRoundedRectangle(const wxRect& r, double radius)
880 { m_pimpl->DoDrawRoundedRectangle(r.x, r.y, r.width, r.height, radius); }
881
882 void DrawCircle(wxCoord x, wxCoord y, wxCoord radius)
883 { m_pimpl->DoDrawEllipse(x - radius, y - radius, 2*radius, 2*radius); }
884 void DrawCircle(const wxPoint& pt, wxCoord radius)
885 { m_pimpl->DoDrawEllipse(pt.x - radius, pt.y - radius, 2*radius, 2*radius); }
886
887 void DrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
888 { m_pimpl->DoDrawEllipse(x, y, width, height); }
889 void DrawEllipse(const wxPoint& pt, const wxSize& sz)
890 { m_pimpl->DoDrawEllipse(pt.x, pt.y, sz.x, sz.y); }
891 void DrawEllipse(const wxRect& rect)
892 { m_pimpl->DoDrawEllipse(rect.x, rect.y, rect.width, rect.height); }
893
894 void DrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
895 { m_pimpl->DoDrawIcon(icon, x, y); }
896 void DrawIcon(const wxIcon& icon, const wxPoint& pt)
897 { m_pimpl->DoDrawIcon(icon, pt.x, pt.y); }
898
899 void DrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y,
900 bool useMask = false)
901 { m_pimpl->DoDrawBitmap(bmp, x, y, useMask); }
902 void DrawBitmap(const wxBitmap &bmp, const wxPoint& pt,
903 bool useMask = false)
904 { m_pimpl->DoDrawBitmap(bmp, pt.x, pt.y, useMask); }
905
906 void DrawText(const wxString& text, wxCoord x, wxCoord y)
907 { m_pimpl->DoDrawText(text, x, y); }
908 void DrawText(const wxString& text, const wxPoint& pt)
909 { m_pimpl->DoDrawText(text, pt.x, pt.y); }
910
911 void DrawRotatedText(const wxString& text, wxCoord x, wxCoord y, double angle)
912 { m_pimpl->DoDrawRotatedText(text, x, y, angle); }
913 void DrawRotatedText(const wxString& text, const wxPoint& pt, double angle)
914 { m_pimpl->DoDrawRotatedText(text, pt.x, pt.y, angle); }
915
916 // this version puts both optional bitmap and the text into the given
917 // rectangle and aligns is as specified by alignment parameter; it also
918 // will emphasize the character with the given index if it is != -1 and
919 // return the bounding rectangle if required
920 void DrawLabel(const wxString& text,
921 const wxBitmap& image,
922 const wxRect& rect,
923 int alignment = wxALIGN_LEFT | wxALIGN_TOP,
924 int indexAccel = -1,
925 wxRect *rectBounding = NULL);
926
927 void DrawLabel(const wxString& text, const wxRect& rect,
928 int alignment = wxALIGN_LEFT | wxALIGN_TOP,
929 int indexAccel = -1)
930 { DrawLabel(text, wxNullBitmap, rect, alignment, indexAccel); }
931
932 bool Blit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
933 wxDC *source, wxCoord xsrc, wxCoord ysrc,
934 int rop = wxCOPY, bool useMask = false, wxCoord xsrcMask = wxDefaultCoord, wxCoord ysrcMask = wxDefaultCoord)
935 {
936 return m_pimpl->DoBlit(xdest, ydest, width, height,
937 source, xsrc, ysrc, rop, useMask, xsrcMask, ysrcMask);
938 }
939 bool Blit(const wxPoint& destPt, const wxSize& sz,
940 wxDC *source, const wxPoint& srcPt,
941 int rop = wxCOPY, bool useMask = false, const wxPoint& srcPtMask = wxDefaultPosition)
942 {
943 return m_pimpl->DoBlit(destPt.x, destPt.y, sz.x, sz.y,
944 source, srcPt.x, srcPt.y, rop, useMask, srcPtMask.x, srcPtMask.y);
945 }
946
947 bool StretchBlit(wxCoord dstX, wxCoord dstY,
948 wxCoord dstWidth, wxCoord dstHeight,
949 wxDC *source,
950 wxCoord srcX, wxCoord srcY,
951 wxCoord srcWidth, wxCoord srcHeight,
952 int rop = wxCOPY, bool useMask = false,
953 wxCoord srcMaskX = wxDefaultCoord, wxCoord srcMaskY = wxDefaultCoord)
954 {
955 return m_pimpl->DoStretchBlit(dstX, dstY, dstWidth, dstHeight,
956 source, srcX, srcY, srcWidth, srcHeight, rop, useMask, srcMaskX, srcMaskY);
957 }
958 bool StretchBlit(const wxPoint& dstPt, const wxSize& dstSize,
959 wxDC *source, const wxPoint& srcPt, const wxSize& srcSize,
960 int rop = wxCOPY, bool useMask = false, const wxPoint& srcMaskPt = wxDefaultPosition)
961 {
962 return m_pimpl->DoStretchBlit(dstPt.x, dstPt.y, dstSize.x, dstSize.y,
963 source, srcPt.x, srcPt.y, srcSize.x, srcSize.y, rop, useMask, srcMaskPt.x, srcMaskPt.y);
964 }
965
966 wxBitmap GetAsBitmap(const wxRect *subrect = (const wxRect *) NULL) const
967 {
968 return m_pimpl->DoGetAsBitmap(subrect);
969 }
970
971#if wxUSE_SPLINES
972 void DrawSpline(wxCoord x1, wxCoord y1,
973 wxCoord x2, wxCoord y2,
974 wxCoord x3, wxCoord y3)
975 { m_pimpl->DoDrawSpline(x1,y1,x2,y2,x3,y3); }
976 void DrawSpline(int n, wxPoint points[])
977 { m_pimpl->DoDrawSpline(n,points); }
978
979#if 0
980 // needs to be removed
981 void DrawSpline(wxList *points)
982 { m_pimpl->DoDrawSpline(points); }
983#endif
984#endif // wxUSE_SPLINES
985
986
987#if WXWIN_COMPATIBILITY_2_8
988 // for compatibility with the old code when wxCoord was long everywhere
989 wxDEPRECATED( void GetTextExtent(const wxString& string,
990 long *x, long *y,
991 long *descent = NULL,
992 long *externalLeading = NULL,
993 const wxFont *theFont = NULL) const );
994 wxDEPRECATED( void GetLogicalOrigin(long *x, long *y) const );
995 wxDEPRECATED( void GetDeviceOrigin(long *x, long *y) const );
996 wxDEPRECATED( void GetClippingBox(long *x, long *y, long *w, long *h) const );
997#endif // WXWIN_COMPATIBILITY_2_8
998
999
1000protected:
1001 wxImplDC *m_pimpl;
1002
1003private:
1004 DECLARE_ABSTRACT_CLASS(wxImplDC)
1005};
1006
1007
1008//-----------------------------------------------------------------------------
1009// wxWindowDC
1010//-----------------------------------------------------------------------------
1011
1012class WXDLLIMPEXP_CORE wxWindowDC : public wxDC
1013{
1014public:
1015 wxWindowDC();
1016 wxWindowDC( wxWindow *win );
1017
1018private:
1019 DECLARE_DYNAMIC_CLASS(wxWindowDC)
1020};
1021
1022//-----------------------------------------------------------------------------
1023// wxClientDC
1024//-----------------------------------------------------------------------------
1025
1026class WXDLLIMPEXP_CORE wxClientDC : public wxDC
1027{
1028public:
1029 wxClientDC();
1030 wxClientDC( wxWindow *win );
1031
1032private:
1033 DECLARE_DYNAMIC_CLASS(wxClientDC)
1034};
1035
1036//-----------------------------------------------------------------------------
1037// wxPaintDC
1038//-----------------------------------------------------------------------------
1039
1040class WXDLLIMPEXP_CORE wxPaintDC : public wxDC
1041{
1042public:
1043 wxPaintDC();
1044 wxPaintDC( wxWindow *win );
1045
1046private:
1047 DECLARE_DYNAMIC_CLASS(wxPaintDC)
1048};
1049
1050#else // wxUSE_NEW_DC
1051
1052
1053class WXDLLIMPEXP_FWD_CORE wxDC;
1054
1055// ---------------------------------------------------------------------------
1056// global variables
1057// ---------------------------------------------------------------------------
1058
1059// ---------------------------------------------------------------------------
1060// wxDC is the device context - object on which any drawing is done
1061// ---------------------------------------------------------------------------
1062
1063class WXDLLEXPORT wxDCBase : public wxObject
1064{
1065public:
1066 wxDCBase();
1067 virtual ~wxDCBase();
1068
1069 // graphic primitives
1070 // ------------------
1071
1072 virtual void DrawObject(wxDrawObject* drawobject)
1073 {
1074 drawobject->Draw(*this);
1075 CalcBoundingBox(drawobject->MinX(),drawobject->MinY());
1076 CalcBoundingBox(drawobject->MaxX(),drawobject->MaxY());
1077 }
1078
1079 wxDC *GetOwner() const { return (wxDC*) this; }
1080
1081 bool FloodFill(wxCoord x, wxCoord y, const wxColour& col,
1082 int style = wxFLOOD_SURFACE)
1083 { return DoFloodFill(x, y, col, style); }
1084 bool FloodFill(const wxPoint& pt, const wxColour& col,
1085 int style = wxFLOOD_SURFACE)
1086 { return DoFloodFill(pt.x, pt.y, col, style); }
1087
1088 // fill the area specified by rect with a radial gradient, starting from
1089 // initialColour in the centre of the cercle and fading to destColour.
1090 void GradientFillConcentric(const wxRect& rect,
1091 const wxColour& initialColour,
1092 const wxColour& destColour)
1093 { GradientFillConcentric(rect, initialColour, destColour,
1094 wxPoint(rect.GetWidth() / 2,
1095 rect.GetHeight() / 2)); }
1096
1097 void GradientFillConcentric(const wxRect& rect,
1098 const wxColour& initialColour,
1099 const wxColour& destColour,
1100 const wxPoint& circleCenter)
1101 { DoGradientFillConcentric(rect, initialColour, destColour, circleCenter); }
1102
1103 // fill the area specified by rect with a linear gradient
1104 void GradientFillLinear(const wxRect& rect,
1105 const wxColour& initialColour,
1106 const wxColour& destColour,
1107 wxDirection nDirection = wxEAST)
1108 { DoGradientFillLinear(rect, initialColour, destColour, nDirection); }
1109
1110 bool GetPixel(wxCoord x, wxCoord y, wxColour *col) const
1111 { return DoGetPixel(x, y, col); }
1112 bool GetPixel(const wxPoint& pt, wxColour *col) const
1113 { return DoGetPixel(pt.x, pt.y, col); }
1114
1115 void DrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
1116 { DoDrawLine(x1, y1, x2, y2); }
1117 void DrawLine(const wxPoint& pt1, const wxPoint& pt2)
1118 { DoDrawLine(pt1.x, pt1.y, pt2.x, pt2.y); }
1119
1120 void CrossHair(wxCoord x, wxCoord y)
1121 { DoCrossHair(x, y); }
1122 void CrossHair(const wxPoint& pt)
1123 { DoCrossHair(pt.x, pt.y); }
1124
1125 void DrawArc(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2,
1126 wxCoord xc, wxCoord yc)
1127 { DoDrawArc(x1, y1, x2, y2, xc, yc); }
1128 void DrawArc(const wxPoint& pt1, const wxPoint& pt2, const wxPoint& centre)
1129 { DoDrawArc(pt1.x, pt1.y, pt2.x, pt2.y, centre.x, centre.y); }
1130
1131 void DrawCheckMark(wxCoord x, wxCoord y,
1132 wxCoord width, wxCoord height)
1133 { DoDrawCheckMark(x, y, width, height); }
1134 void DrawCheckMark(const wxRect& rect)
1135 { DoDrawCheckMark(rect.x, rect.y, rect.width, rect.height); }
1136
1137 void DrawEllipticArc(wxCoord x, wxCoord y, wxCoord w, wxCoord h,
1138 double sa, double ea)
1139 { DoDrawEllipticArc(x, y, w, h, sa, ea); }
1140 void DrawEllipticArc(const wxPoint& pt, const wxSize& sz,
1141 double sa, double ea)
1142 { DoDrawEllipticArc(pt.x, pt.y, sz.x, sz.y, sa, ea); }
1143
1144 void DrawPoint(wxCoord x, wxCoord y)
1145 { DoDrawPoint(x, y); }
1146 void DrawPoint(const wxPoint& pt)
1147 { DoDrawPoint(pt.x, pt.y); }
1148
1149 void DrawLines(int n, wxPoint points[],
1150 wxCoord xoffset = 0, wxCoord yoffset = 0)
1151 { DoDrawLines(n, points, xoffset, yoffset); }
1152 void DrawLines(const wxList *list,
1153 wxCoord xoffset = 0, wxCoord yoffset = 0);
1154
1155 void DrawPolygon(int n, wxPoint points[],
1156 wxCoord xoffset = 0, wxCoord yoffset = 0,
1157 int fillStyle = wxODDEVEN_RULE)
1158 { DoDrawPolygon(n, points, xoffset, yoffset, fillStyle); }
1159
1160 void DrawPolygon(const wxList *list,
1161 wxCoord xoffset = 0, wxCoord yoffset = 0,
1162 int fillStyle = wxODDEVEN_RULE);
1163
1164 void DrawPolyPolygon(int n, int count[], wxPoint points[],
1165 wxCoord xoffset = 0, wxCoord yoffset = 0,
1166 int fillStyle = wxODDEVEN_RULE)
1167 { DoDrawPolyPolygon(n, count, points, xoffset, yoffset, fillStyle); }
1168
1169 void DrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
1170 { DoDrawRectangle(x, y, width, height); }
1171 void DrawRectangle(const wxPoint& pt, const wxSize& sz)
1172 { DoDrawRectangle(pt.x, pt.y, sz.x, sz.y); }
1173 void DrawRectangle(const wxRect& rect)
1174 { DoDrawRectangle(rect.x, rect.y, rect.width, rect.height); }
1175
1176 void DrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height,
1177 double radius)
1178 { DoDrawRoundedRectangle(x, y, width, height, radius); }
1179 void DrawRoundedRectangle(const wxPoint& pt, const wxSize& sz,
1180 double radius)
1181 { DoDrawRoundedRectangle(pt.x, pt.y, sz.x, sz.y, radius); }
1182 void DrawRoundedRectangle(const wxRect& r, double radius)
1183 { DoDrawRoundedRectangle(r.x, r.y, r.width, r.height, radius); }
1184
1185 void DrawCircle(wxCoord x, wxCoord y, wxCoord radius)
1186 { DoDrawEllipse(x - radius, y - radius, 2*radius, 2*radius); }
1187 void DrawCircle(const wxPoint& pt, wxCoord radius)
1188 { DrawCircle(pt.x, pt.y, radius); }
1189
1190 void DrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
1191 { DoDrawEllipse(x, y, width, height); }
1192 void DrawEllipse(const wxPoint& pt, const wxSize& sz)
1193 { DoDrawEllipse(pt.x, pt.y, sz.x, sz.y); }
1194 void DrawEllipse(const wxRect& rect)
1195 { DoDrawEllipse(rect.x, rect.y, rect.width, rect.height); }
1196
1197 void DrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
1198 { DoDrawIcon(icon, x, y); }
1199 void DrawIcon(const wxIcon& icon, const wxPoint& pt)
1200 { DoDrawIcon(icon, pt.x, pt.y); }
1201
1202 void DrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y,
1203 bool useMask = false)
1204 { DoDrawBitmap(bmp, x, y, useMask); }
1205 void DrawBitmap(const wxBitmap &bmp, const wxPoint& pt,
1206 bool useMask = false)
1207 { DoDrawBitmap(bmp, pt.x, pt.y, useMask); }
1208
1209 void DrawText(const wxString& text, wxCoord x, wxCoord y)
1210 { DoDrawText(text, x, y); }
1211 void DrawText(const wxString& text, const wxPoint& pt)
1212 { DoDrawText(text, pt.x, pt.y); }
1213
1214 void DrawRotatedText(const wxString& text, wxCoord x, wxCoord y, double angle)
1215 { DoDrawRotatedText(text, x, y, angle); }
1216 void DrawRotatedText(const wxString& text, const wxPoint& pt, double angle)
1217 { DoDrawRotatedText(text, pt.x, pt.y, angle); }
1218
1219 // this version puts both optional bitmap and the text into the given
1220 // rectangle and aligns is as specified by alignment parameter; it also
1221 // will emphasize the character with the given index if it is != -1 and
1222 // return the bounding rectangle if required
1223 virtual void DrawLabel(const wxString& text,
1224 const wxBitmap& image,
1225 const wxRect& rect,
1226 int alignment = wxALIGN_LEFT | wxALIGN_TOP,
1227 int indexAccel = -1,
1228 wxRect *rectBounding = NULL);
1229
1230 void DrawLabel(const wxString& text, const wxRect& rect,
1231 int alignment = wxALIGN_LEFT | wxALIGN_TOP,
1232 int indexAccel = -1)
1233 { DrawLabel(text, wxNullBitmap, rect, alignment, indexAccel); }
1234
1235 bool Blit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
1236 wxDC *source, wxCoord xsrc, wxCoord ysrc,
1237 int rop = wxCOPY, bool useMask = false, wxCoord xsrcMask = wxDefaultCoord, wxCoord ysrcMask = wxDefaultCoord)
1238 {
1239 return DoBlit(xdest, ydest, width, height,
1240 source, xsrc, ysrc, rop, useMask, xsrcMask, ysrcMask);
1241 }
1242 bool Blit(const wxPoint& destPt, const wxSize& sz,
1243 wxDC *source, const wxPoint& srcPt,
1244 int rop = wxCOPY, bool useMask = false, const wxPoint& srcPtMask = wxDefaultPosition)
1245 {
1246 return DoBlit(destPt.x, destPt.y, sz.x, sz.y,
1247 source, srcPt.x, srcPt.y, rop, useMask, srcPtMask.x, srcPtMask.y);
1248 }
1249
1250 bool StretchBlit(wxCoord dstX, wxCoord dstY,
1251 wxCoord dstWidth, wxCoord dstHeight,
1252 wxDC *source,
1253 wxCoord srcX, wxCoord srcY,
1254 wxCoord srcWidth, wxCoord srcHeight,
1255 int rop = wxCOPY, bool useMask = false,
1256 wxCoord srcMaskX = wxDefaultCoord, wxCoord srcMaskY = wxDefaultCoord)
1257 {
1258 return DoStretchBlit(dstX, dstY, dstWidth, dstHeight,
1259 source, srcX, srcY, srcWidth, srcHeight, rop, useMask, srcMaskX, srcMaskY);
1260 }
1261 bool StretchBlit(const wxPoint& dstPt, const wxSize& dstSize,
1262 wxDC *source, const wxPoint& srcPt, const wxSize& srcSize,
1263 int rop = wxCOPY, bool useMask = false, const wxPoint& srcMaskPt = wxDefaultPosition)
1264 {
1265 return DoStretchBlit(dstPt.x, dstPt.y, dstSize.x, dstSize.y,
1266 source, srcPt.x, srcPt.y, srcSize.x, srcSize.y, rop, useMask, srcMaskPt.x, srcMaskPt.y);
1267 }
1268
1269 wxBitmap GetAsBitmap(const wxRect *subrect = (const wxRect *) NULL) const
1270 {
1271 return DoGetAsBitmap(subrect);
1272 }
1273
1274#if wxUSE_SPLINES
1275 // TODO: this API needs fixing (wxPointList, why (!const) "wxList *"?)
1276 void DrawSpline(wxCoord x1, wxCoord y1,
1277 wxCoord x2, wxCoord y2,
1278 wxCoord x3, wxCoord y3);
1279 void DrawSpline(int n, wxPoint points[]);
1280
1281 void DrawSpline(wxList *points) { DoDrawSpline(points); }
1282#endif // wxUSE_SPLINES
1283
1284 // Eventually we will have wxUSE_GENERIC_DRAWELLIPSE
1285#ifdef __WXWINCE__
1286 //! Generic method to draw ellipses, circles and arcs with current pen and brush.
1287 /*! \param x Upper left corner of bounding box.
1288 * \param y Upper left corner of bounding box.
1289 * \param w Width of bounding box.
1290 * \param h Height of bounding box.
1291 * \param sa Starting angle of arc
1292 * (counterclockwise, start at 3 o'clock, 360 is full circle).
1293 * \param ea Ending angle of arc.
1294 * \param angle Rotation angle, the Arc will be rotated after
1295 * calculating begin and end.
1296 */
1297 void DrawEllipticArcRot( wxCoord x, wxCoord y,
1298 wxCoord width, wxCoord height,
1299 double sa = 0, double ea = 0, double angle = 0 )
1300 { DoDrawEllipticArcRot( x, y, width, height, sa, ea, angle ); }
1301
1302 void DrawEllipticArcRot( const wxPoint& pt,
1303 const wxSize& sz,
1304 double sa = 0, double ea = 0, double angle = 0 )
1305 { DoDrawEllipticArcRot( pt.x, pt.y, sz.x, sz.y, sa, ea, angle ); }
1306
1307 void DrawEllipticArcRot( const wxRect& rect,
1308 double sa = 0, double ea = 0, double angle = 0 )
1309 { DoDrawEllipticArcRot( rect.x, rect.y, rect.width, rect.height, sa, ea, angle ); }
1310
1311 virtual void DoDrawEllipticArcRot( wxCoord x, wxCoord y,
1312 wxCoord w, wxCoord h,
1313 double sa = 0, double ea = 0, double angle = 0 );
1314
1315 //! Rotates points around center.
1316 /*! This is a quite straight method, it calculates in pixels
1317 * and so it produces rounding errors.
1318 * \param points The points inside will be rotated.
1319 * \param angle Rotating angle (counterclockwise, start at 3 o'clock, 360 is full circle).
1320 * \param center Center of rotation.
1321 */
1322 void Rotate( wxList* points, double angle, wxPoint center = wxPoint(0,0) );
1323
1324 // used by DrawEllipticArcRot
1325 // Careful: wxList gets filled with points you have to delete later.
1326 void CalculateEllipticPoints( wxList* points,
1327 wxCoord xStart, wxCoord yStart,
1328 wxCoord w, wxCoord h,
1329 double sa, double ea );
1330#endif
1331
1332 // global DC operations
1333 // --------------------
1334
1335 virtual void Clear() = 0;
1336
1337 virtual bool StartDoc(const wxString& WXUNUSED(message)) { return true; }
1338 virtual void EndDoc() { }
1339
1340 virtual void StartPage() { }
1341 virtual void EndPage() { }
1342
1343#if WXWIN_COMPATIBILITY_2_6
1344 wxDEPRECATED( void BeginDrawing() );
1345 wxDEPRECATED( void EndDrawing() );
1346#endif // WXWIN_COMPATIBILITY_2_6
1347
1348
1349 // set objects to use for drawing
1350 // ------------------------------
1351
1352 virtual void SetFont(const wxFont& font) = 0;
1353 virtual void SetPen(const wxPen& pen) = 0;
1354 virtual void SetBrush(const wxBrush& brush) = 0;
1355 virtual void SetBackground(const wxBrush& brush) = 0;
1356 virtual void SetBackgroundMode(int mode) = 0;
1357#if wxUSE_PALETTE
1358 virtual void SetPalette(const wxPalette& palette) = 0;
1359#endif // wxUSE_PALETTE
1360
1361 // clipping region
1362 // ---------------
1363
1364 void SetClippingRegion(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
1365 { DoSetClippingRegion(x, y, width, height); }
1366 void SetClippingRegion(const wxPoint& pt, const wxSize& sz)
1367 { DoSetClippingRegion(pt.x, pt.y, sz.x, sz.y); }
1368 void SetClippingRegion(const wxRect& rect)
1369 { DoSetClippingRegion(rect.x, rect.y, rect.width, rect.height); }
1370 void SetClippingRegion(const wxRegion& region)
1371 { DoSetClippingRegionAsRegion(region); }
1372
1373 virtual void DestroyClippingRegion() { ResetClipping(); }
1374
1375 void GetClippingBox(wxCoord *x, wxCoord *y, wxCoord *w, wxCoord *h) const
1376 { DoGetClippingBox(x, y, w, h); }
1377 void GetClippingBox(wxRect& rect) const
1378 {
1379 DoGetClippingBox(&rect.x, &rect.y, &rect.width, &rect.height);
1380 }
1381
1382 // text extent
1383 // -----------
1384
1385 virtual wxCoord GetCharHeight() const = 0;
1386 virtual wxCoord GetCharWidth() const = 0;
1387
1388 // only works for single line strings
1389 void GetTextExtent(const wxString& string,
1390 wxCoord *x, wxCoord *y,
1391 wxCoord *descent = NULL,
1392 wxCoord *externalLeading = NULL,
1393 const wxFont *theFont = NULL) const
1394 { DoGetTextExtent(string, x, y, descent, externalLeading, theFont); }
1395
1396 wxSize GetTextExtent(const wxString& string) const
1397 {
1398 wxCoord w, h;
1399 DoGetTextExtent(string, &w, &h);
1400 return wxSize(w, h);
1401 }
1402
1403 // works for single as well as multi-line strings
1404 virtual void GetMultiLineTextExtent(const wxString& string,
1405 wxCoord *width,
1406 wxCoord *height,
1407 wxCoord *heightLine = NULL,
1408 const wxFont *font = NULL) const;
1409
1410 wxSize GetMultiLineTextExtent(const wxString& string) const
1411 {
1412 wxCoord w, h;
1413 GetMultiLineTextExtent(string, &w, &h);
1414 return wxSize(w, h);
1415 }
1416
1417 // Measure cumulative width of text after each character
1418 bool GetPartialTextExtents(const wxString& text, wxArrayInt& widths) const
1419 { return DoGetPartialTextExtents(text, widths); }
1420
1421
1422 // size and resolution
1423 // -------------------
1424
1425 // in device units
1426 void GetSize(int *width, int *height) const
1427 { DoGetSize(width, height); }
1428 wxSize GetSize() const
1429 {
1430 int w, h;
1431 DoGetSize(&w, &h);
1432
1433 return wxSize(w, h);
1434 }
1435
1436 // in mm
1437 void GetSizeMM(int* width, int* height) const
1438 { DoGetSizeMM(width, height); }
1439 wxSize GetSizeMM() const
1440 {
1441 int w, h;
1442 DoGetSizeMM(&w, &h);
1443
1444 return wxSize(w, h);
1445 }
1446
1447 // query DC capabilities
1448 // ---------------------
1449
1450 virtual bool CanDrawBitmap() const = 0;
1451 virtual bool CanGetTextExtent() const = 0;
1452
1453 // colour depth
1454 virtual int GetDepth() const = 0;
1455
1456 // Resolution in Pixels per inch
1457 virtual wxSize GetPPI() const = 0;
1458
1459 virtual bool Ok() const { return IsOk(); }
1460 virtual bool IsOk() const { return m_ok; }
1461
1462 // accessors and setters
1463 // ---------------------
1464
1465 virtual int GetBackgroundMode() const { return m_backgroundMode; }
1466 virtual const wxBrush& GetBackground() const { return m_backgroundBrush; }
1467 virtual const wxBrush& GetBrush() const { return m_brush; }
1468 virtual const wxFont& GetFont() const { return m_font; }
1469 virtual const wxPen& GetPen() const { return m_pen; }
1470
1471 virtual const wxColour& GetTextForeground() const { return m_textForegroundColour; }
1472 virtual const wxColour& GetTextBackground() const { return m_textBackgroundColour; }
1473 virtual void SetTextForeground(const wxColour& colour)
1474 { m_textForegroundColour = colour; }
1475 virtual void SetTextBackground(const wxColour& colour)
1476 { m_textBackgroundColour = colour; }
1477
1478
1479 // coordinates conversions and transforms
1480 // --------------------------------------
1481
1482 virtual wxCoord DeviceToLogicalX(wxCoord x) const;
1483 virtual wxCoord DeviceToLogicalY(wxCoord y) const;
1484 virtual wxCoord DeviceToLogicalXRel(wxCoord x) const;
1485 virtual wxCoord DeviceToLogicalYRel(wxCoord y) const;
1486 virtual wxCoord LogicalToDeviceX(wxCoord x) const;
1487 virtual wxCoord LogicalToDeviceY(wxCoord y) const;
1488 virtual wxCoord LogicalToDeviceXRel(wxCoord x) const;
1489 virtual wxCoord LogicalToDeviceYRel(wxCoord y) const;
1490
1491 virtual void SetMapMode(int mode);
1492 virtual int GetMapMode() const { return m_mappingMode; }
1493
1494 virtual void SetUserScale(double x, double y);
1495 virtual void GetUserScale(double *x, double *y) const
1496 {
1497 if ( x ) *x = m_userScaleX;
1498 if ( y ) *y = m_userScaleY;
1499 }
1500
1501 virtual void SetLogicalScale(double x, double y);
1502 virtual void GetLogicalScale(double *x, double *y)
1503 {
1504 if ( x ) *x = m_logicalScaleX;
1505 if ( y ) *y = m_logicalScaleY;
1506 }
1507
1508 virtual void SetLogicalOrigin(wxCoord x, wxCoord y);
1509 void GetLogicalOrigin(wxCoord *x, wxCoord *y) const
1510 { DoGetLogicalOrigin(x, y); }
1511 wxPoint GetLogicalOrigin() const
1512 { wxCoord x, y; DoGetLogicalOrigin(&x, &y); return wxPoint(x, y); }
1513
1514 virtual void SetDeviceOrigin(wxCoord x, wxCoord y);
1515 void GetDeviceOrigin(wxCoord *x, wxCoord *y) const
1516 { DoGetDeviceOrigin(x, y); }
1517 wxPoint GetDeviceOrigin() const
1518 { wxCoord x, y; DoGetDeviceOrigin(&x, &y); return wxPoint(x, y); }
1519
1520 virtual void SetDeviceLocalOrigin( wxCoord x, wxCoord y );
1521
1522 virtual void ComputeScaleAndOrigin();
1523
1524 // this needs to overidden if the axis is inverted (such
1525 // as when using Postscript, where 0,0 is the lower left
1526 // corner, not the upper left).
1527 virtual void SetAxisOrientation(bool xLeftRight, bool yBottomUp);
1528
1529 // logical functions
1530 // ---------------------------
1531
1532 virtual int GetLogicalFunction() const { return m_logicalFunction; }
1533 virtual void SetLogicalFunction(int function) = 0;
1534
1535 // bounding box
1536 // ------------
1537
1538 virtual void CalcBoundingBox(wxCoord x, wxCoord y)
1539 {
1540 if ( m_isBBoxValid )
1541 {
1542 if ( x < m_minX ) m_minX = x;
1543 if ( y < m_minY ) m_minY = y;
1544 if ( x > m_maxX ) m_maxX = x;
1545 if ( y > m_maxY ) m_maxY = y;
1546 }
1547 else
1548 {
1549 m_isBBoxValid = true;
1550
1551 m_minX = x;
1552 m_minY = y;
1553 m_maxX = x;
1554 m_maxY = y;
1555 }
1556 }
1557
1558 void ResetBoundingBox()
1559 {
1560 m_isBBoxValid = false;
1561
1562 m_minX = m_maxX = m_minY = m_maxY = 0;
1563 }
1564
1565 // Get the final bounding box of the PostScript or Metafile picture.
1566 wxCoord MinX() const { return m_minX; }
1567 wxCoord MaxX() const { return m_maxX; }
1568 wxCoord MinY() const { return m_minY; }
1569 wxCoord MaxY() const { return m_maxY; }
1570
1571 // misc old functions
1572 // ------------------
1573
1574#if WXWIN_COMPATIBILITY_2_8
1575 // for compatibility with the old code when wxCoord was long everywhere
1576 wxDEPRECATED( void GetTextExtent(const wxString& string,
1577 long *x, long *y,
1578 long *descent = NULL,
1579 long *externalLeading = NULL,
1580 const wxFont *theFont = NULL) const );
1581 wxDEPRECATED( void GetLogicalOrigin(long *x, long *y) const );
1582 wxDEPRECATED( void GetDeviceOrigin(long *x, long *y) const );
1583 wxDEPRECATED( void GetClippingBox(long *x, long *y, long *w, long *h) const );
1584#endif // WXWIN_COMPATIBILITY_2_8
1585
1586 // RTL related functions
1587 // ---------------------
1588
1589 // get or change the layout direction (LTR or RTL) for this dc,
1590 // wxLayout_Default is returned if layout direction is not supported
1591 virtual wxLayoutDirection GetLayoutDirection() const
1592 { return wxLayout_Default; }
1593 virtual void SetLayoutDirection(wxLayoutDirection WXUNUSED(dir))
1594 { }
1595
1596protected:
1597 // the pure virtual functions which should be implemented by wxDC
1598 virtual bool DoFloodFill(wxCoord x, wxCoord y, const wxColour& col,
1599 int style = wxFLOOD_SURFACE) = 0;
1600
1601 virtual void DoGradientFillLinear(const wxRect& rect,
1602 const wxColour& initialColour,
1603 const wxColour& destColour,
1604 wxDirection nDirection = wxEAST);
1605
1606 virtual void DoGradientFillConcentric(const wxRect& rect,
1607 const wxColour& initialColour,
1608 const wxColour& destColour,
1609 const wxPoint& circleCenter);
1610
1611 virtual bool DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const = 0;
1612
1613 virtual void DoDrawPoint(wxCoord x, wxCoord y) = 0;
1614 virtual void DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2) = 0;
1615
1616 virtual void DoDrawArc(wxCoord x1, wxCoord y1,
1617 wxCoord x2, wxCoord y2,
1618 wxCoord xc, wxCoord yc) = 0;
1619 virtual void DoDrawCheckMark(wxCoord x, wxCoord y,
1620 wxCoord width, wxCoord height);
1621 virtual void DoDrawEllipticArc(wxCoord x, wxCoord y, wxCoord w, wxCoord h,
1622 double sa, double ea) = 0;
1623
1624 virtual void DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height) = 0;
1625 virtual void DoDrawRoundedRectangle(wxCoord x, wxCoord y,
1626 wxCoord width, wxCoord height,
1627 double radius) = 0;
1628 virtual void DoDrawEllipse(wxCoord x, wxCoord y,
1629 wxCoord width, wxCoord height) = 0;
1630
1631 virtual void DoCrossHair(wxCoord x, wxCoord y) = 0;
1632
1633 virtual void DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y) = 0;
1634 virtual void DoDrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y,
1635 bool useMask = false) = 0;
1636
1637 virtual void DoDrawText(const wxString& text, wxCoord x, wxCoord y) = 0;
1638 virtual void DoDrawRotatedText(const wxString& text,
1639 wxCoord x, wxCoord y, double angle) = 0;
1640
1641 virtual bool DoBlit(wxCoord xdest, wxCoord ydest,
1642 wxCoord width, wxCoord height,
1643 wxDC *source,
1644 wxCoord xsrc, wxCoord ysrc,
1645 int rop = wxCOPY,
1646 bool useMask = false,
1647 wxCoord xsrcMask = wxDefaultCoord,
1648 wxCoord ysrcMask = wxDefaultCoord) = 0;
1649
1650 virtual bool DoStretchBlit(wxCoord xdest, wxCoord ydest,
1651 wxCoord dstWidth, wxCoord dstHeight,
1652 wxDC *source,
1653 wxCoord xsrc, wxCoord ysrc,
1654 wxCoord srcWidth, wxCoord srcHeight,
1655 int rop = wxCOPY,
1656 bool useMask = false,
1657 wxCoord xsrcMask = wxDefaultCoord,
1658 wxCoord ysrcMask = wxDefaultCoord);
1659
1660 virtual wxBitmap DoGetAsBitmap(const wxRect *WXUNUSED(subrect)) const
1661 { return wxNullBitmap; }
1662
1663 virtual void DoGetSize(int *width, int *height) const = 0;
1664 virtual void DoGetSizeMM(int* width, int* height) const = 0;
1665
1666 virtual void DoDrawLines(int n, wxPoint points[],
1667 wxCoord xoffset, wxCoord yoffset) = 0;
1668 virtual void DoDrawPolygon(int n, wxPoint points[],
1669 wxCoord xoffset, wxCoord yoffset,
1670 int fillStyle = wxODDEVEN_RULE) = 0;
1671 virtual void DoDrawPolyPolygon(int n, int count[], wxPoint points[],
1672 wxCoord xoffset, wxCoord yoffset,
1673 int fillStyle);
1674
1675 virtual void DoSetClippingRegionAsRegion(const wxRegion& region) = 0;
1676 virtual void DoSetClippingRegion(wxCoord x, wxCoord y,
1677 wxCoord width, wxCoord height) = 0;
1678
1679 virtual void DoGetClippingBox(wxCoord *x, wxCoord *y,
1680 wxCoord *w, wxCoord *h) const
1681 {
1682 if ( x )
1683 *x = m_clipX1;
1684 if ( y )
1685 *y = m_clipY1;
1686 if ( w )
1687 *w = m_clipX2 - m_clipX1;
1688 if ( h )
1689 *h = m_clipY2 - m_clipY1;
1690 }
1691
1692 virtual void DoGetLogicalOrigin(wxCoord *x, wxCoord *y) const
1693 {
1694 if ( x ) *x = m_logicalOriginX;
1695 if ( y ) *y = m_logicalOriginY;
1696 }
1697
1698 virtual void DoGetDeviceOrigin(wxCoord *x, wxCoord *y) const
1699 {
1700 if ( x ) *x = m_deviceOriginX;
1701 if ( y ) *y = m_deviceOriginY;
1702 }
1703
1704 virtual void DoGetTextExtent(const wxString& string,
1705 wxCoord *x, wxCoord *y,
1706 wxCoord *descent = NULL,
1707 wxCoord *externalLeading = NULL,
1708 const wxFont *theFont = NULL) const = 0;
1709
1710 virtual bool DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const;
1711
1712#if wxUSE_SPLINES
1713 virtual void DoDrawSpline(wxList *points);
1714#endif
1715
1716protected:
1717 // unset clipping variables (after clipping region was destroyed)
1718 void ResetClipping()
1719 {
1720 m_clipping = false;
1721
1722 m_clipX1 = m_clipX2 = m_clipY1 = m_clipY2 = 0;
1723 }
1724
1725 // flags
1726 bool m_colour:1;
1727 bool m_ok:1;
1728 bool m_clipping:1;
1729 bool m_isInteractive:1;
1730 bool m_isBBoxValid:1;
1731
1732 // coordinate system variables
1733
1734 // TODO short descriptions of what exactly they are would be nice...
1735
1736 wxCoord m_logicalOriginX, m_logicalOriginY;
1737 wxCoord m_deviceOriginX, m_deviceOriginY; // Usually 0,0, can be change by user
1738
1739 wxCoord m_deviceLocalOriginX, m_deviceLocalOriginY; // non-zero if native top-left corner
1740 // is not at 0,0. This was the case under
1741 // Mac's GrafPorts (coordinate system
1742 // used toplevel window's origin) and
1743 // e.g. for Postscript, where the native
1744 // origin in the bottom left corner.
1745 double m_logicalScaleX, m_logicalScaleY;
1746 double m_userScaleX, m_userScaleY;
1747 double m_scaleX, m_scaleY; // calculated from logical scale and user scale
1748
1749 // Used by SetAxisOrientation() to invert the axes
1750 int m_signX, m_signY;
1751
1752 // what is a mm on a screen you don't know the size of?
1753 double m_mm_to_pix_x,
1754 m_mm_to_pix_y;
1755
1756 // bounding and clipping boxes
1757 wxCoord m_minX, m_minY, m_maxX, m_maxY;
1758 wxCoord m_clipX1, m_clipY1, m_clipX2, m_clipY2;
1759
1760 int m_logicalFunction;
1761 int m_backgroundMode;
1762 int m_mappingMode;
1763
1764 // GDI objects
1765 wxPen m_pen;
1766 wxBrush m_brush;
1767 wxBrush m_backgroundBrush;
1768 wxColour m_textForegroundColour;
1769 wxColour m_textBackgroundColour;
1770 wxFont m_font;
1771
1772#if wxUSE_PALETTE
1773 wxPalette m_palette;
1774 bool m_hasCustomPalette;
1775#endif // wxUSE_PALETTE
1776
1777private:
1778 DECLARE_NO_COPY_CLASS(wxDCBase)
1779 DECLARE_ABSTRACT_CLASS(wxDCBase)
1780};
1781
1782#endif // wxUSE_NEW_DC
1783
1784// ----------------------------------------------------------------------------
1785// now include the declaration of wxDC class
1786// ----------------------------------------------------------------------------
1787
1788#if defined(__WXPALMOS__)
1789 #include "wx/palmos/dc.h"
1790#elif defined(__WXMSW__)
1791 #include "wx/msw/dc.h"
1792#elif defined(__WXMOTIF__)
1793 #include "wx/motif/dc.h"
1794#elif defined(__WXGTK20__)
1795 #include "wx/gtk/dc.h"
1796#elif defined(__WXGTK__)
1797 #include "wx/gtk1/dc.h"
1798#elif defined(__WXX11__)
1799 #include "wx/x11/dc.h"
1800#elif defined(__WXMGL__)
1801 #include "wx/mgl/dc.h"
1802#elif defined(__WXDFB__)
1803 #include "wx/dfb/dc.h"
1804#elif defined(__WXMAC__)
1805 #include "wx/mac/dc.h"
1806#elif defined(__WXCOCOA__)
1807 #include "wx/cocoa/dc.h"
1808#elif defined(__WXPM__)
1809 #include "wx/os2/dc.h"
1810#endif
1811
1812#if wxUSE_GRAPHICS_CONTEXT
1813 #include "wx/dcgraph.h"
1814#endif
1815
1816// ----------------------------------------------------------------------------
1817// helper class: you can use it to temporarily change the DC text colour and
1818// restore it automatically when the object goes out of scope
1819// ----------------------------------------------------------------------------
1820
1821class WXDLLEXPORT wxDCTextColourChanger
1822{
1823public:
1824 wxDCTextColourChanger(wxDC& dc) : m_dc(dc), m_colFgOld() { }
1825
1826 wxDCTextColourChanger(wxDC& dc, const wxColour& col) : m_dc(dc)
1827 {
1828 Set(col);
1829 }
1830
1831 ~wxDCTextColourChanger()
1832 {
1833 if ( m_colFgOld.Ok() )
1834 m_dc.SetTextForeground(m_colFgOld);
1835 }
1836
1837 void Set(const wxColour& col)
1838 {
1839 if ( !m_colFgOld.Ok() )
1840 m_colFgOld = m_dc.GetTextForeground();
1841 m_dc.SetTextForeground(col);
1842 }
1843
1844private:
1845 wxDC& m_dc;
1846
1847 wxColour m_colFgOld;
1848
1849 DECLARE_NO_COPY_CLASS(wxDCTextColourChanger)
1850};
1851
1852// ----------------------------------------------------------------------------
1853// helper class: you can use it to temporarily change the DC pen and
1854// restore it automatically when the object goes out of scope
1855// ----------------------------------------------------------------------------
1856
1857class WXDLLEXPORT wxDCPenChanger
1858{
1859public:
1860 wxDCPenChanger(wxDC& dc, const wxPen& pen) : m_dc(dc), m_penOld(dc.GetPen())
1861 {
1862 m_dc.SetPen(pen);
1863 }
1864
1865 ~wxDCPenChanger()
1866 {
1867 if ( m_penOld.Ok() )
1868 m_dc.SetPen(m_penOld);
1869 }
1870
1871private:
1872 wxDC& m_dc;
1873
1874 wxPen m_penOld;
1875
1876 DECLARE_NO_COPY_CLASS(wxDCPenChanger)
1877};
1878
1879// ----------------------------------------------------------------------------
1880// helper class: you can use it to temporarily change the DC brush and
1881// restore it automatically when the object goes out of scope
1882// ----------------------------------------------------------------------------
1883
1884class WXDLLEXPORT wxDCBrushChanger
1885{
1886public:
1887 wxDCBrushChanger(wxDC& dc, const wxBrush& brush) : m_dc(dc), m_brushOld(dc.GetBrush())
1888 {
1889 m_dc.SetBrush(brush);
1890 }
1891
1892 ~wxDCBrushChanger()
1893 {
1894 if ( m_brushOld.Ok() )
1895 m_dc.SetBrush(m_brushOld);
1896 }
1897
1898private:
1899 wxDC& m_dc;
1900
1901 wxBrush m_brushOld;
1902
1903 DECLARE_NO_COPY_CLASS(wxDCBrushChanger)
1904};
1905
1906// ----------------------------------------------------------------------------
1907// another small helper class: sets the clipping region in its ctor and
1908// destroys it in the dtor
1909// ----------------------------------------------------------------------------
1910
1911class WXDLLEXPORT wxDCClipper
1912{
1913public:
1914 wxDCClipper(wxDC& dc, const wxRegion& r) : m_dc(dc)
1915 { dc.SetClippingRegion(r); }
1916 wxDCClipper(wxDC& dc, const wxRect& r) : m_dc(dc)
1917 { dc.SetClippingRegion(r.x, r.y, r.width, r.height); }
1918 wxDCClipper(wxDC& dc, wxCoord x, wxCoord y, wxCoord w, wxCoord h) : m_dc(dc)
1919 { dc.SetClippingRegion(x, y, w, h); }
1920
1921 ~wxDCClipper() { m_dc.DestroyClippingRegion(); }
1922
1923private:
1924 wxDC& m_dc;
1925
1926 DECLARE_NO_COPY_CLASS(wxDCClipper)
1927};
1928
1929#endif // _WX_DC_H_BASE_
wxWidgets (Impactor)