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