]>
Commit | Line | Data |
---|---|---|
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 | |
f4515f98 | 33 | class WXDLLEXPORT wxDC; |
aec43716 KH |
34 | class WXDLLEXPORT wxDCBase; |
35 | ||
36 | class WXDLLEXPORT wxDrawObject | |
37 | { | |
38 | public: | |
39 | ||
40 | wxDrawObject() | |
68379eaf | 41 | : m_isBBoxValid(false) |
ba161d7e GD |
42 | , m_minX(0), m_minY(0), m_maxX(0), m_maxY(0) |
43 | { } | |
aec43716 KH |
44 | |
45 | virtual ~wxDrawObject() { } | |
46 | ||
33ac7e6f | 47 | virtual void Draw(wxDCBase&) const { } |
aec43716 KH |
48 | |
49 | virtual void CalcBoundingBox(wxCoord x, wxCoord y) | |
50 | { | |
51 | if ( m_isBBoxValid ) | |
52 | { | |
53 | if ( x < m_minX ) m_minX = x; | |
54 | if ( y < m_minY ) m_minY = y; | |
55 | if ( x > m_maxX ) m_maxX = x; | |
56 | if ( y > m_maxY ) m_maxY = y; | |
57 | } | |
58 | else | |
59 | { | |
68379eaf | 60 | m_isBBoxValid = true; |
aec43716 KH |
61 | |
62 | m_minX = x; | |
63 | m_minY = y; | |
64 | m_maxX = x; | |
65 | m_maxY = y; | |
66 | } | |
67 | } | |
68 | ||
69 | void ResetBoundingBox() | |
70 | { | |
68379eaf | 71 | m_isBBoxValid = false; |
aec43716 KH |
72 | |
73 | m_minX = m_maxX = m_minY = m_maxY = 0; | |
74 | } | |
75 | ||
76 | // Get the final bounding box of the PostScript or Metafile picture. | |
77 | ||
78 | wxCoord MinX() const { return m_minX; } | |
79 | wxCoord MaxX() const { return m_maxX; } | |
80 | wxCoord MinY() const { return m_minY; } | |
81 | wxCoord MaxY() const { return m_maxY; } | |
82 | ||
83 | //to define the type of object for derived objects | |
84 | virtual int GetType()=0; | |
85 | ||
86 | protected: | |
87 | //for boundingbox calculation | |
88 | bool m_isBBoxValid:1; | |
89 | //for boundingbox calculation | |
90 | wxCoord m_minX, m_minY, m_maxX, m_maxY; | |
91 | }; | |
92 | ||
a23fd0e1 VZ |
93 | // --------------------------------------------------------------------------- |
94 | // global variables | |
95 | // --------------------------------------------------------------------------- | |
96 | ||
a23fd0e1 VZ |
97 | // --------------------------------------------------------------------------- |
98 | // wxDC is the device context - object on which any drawing is done | |
99 | // --------------------------------------------------------------------------- | |
100 | ||
101 | class WXDLLEXPORT wxDCBase : public wxObject | |
102 | { | |
a23fd0e1 VZ |
103 | public: |
104 | wxDCBase() | |
ba161d7e | 105 | : m_colour(wxColourDisplay()) |
68379eaf WS |
106 | , m_ok(true) |
107 | , m_clipping(false) | |
ba161d7e | 108 | , m_isInteractive(0) |
68379eaf | 109 | , m_isBBoxValid(false) |
ba161d7e GD |
110 | , m_logicalOriginX(0), m_logicalOriginY(0) |
111 | , m_deviceOriginX(0), m_deviceOriginY(0) | |
112 | , m_logicalScaleX(1.0), m_logicalScaleY(1.0) | |
113 | , m_userScaleX(1.0), m_userScaleY(1.0) | |
114 | , m_scaleX(1.0), m_scaleY(1.0) | |
115 | , m_signX(1), m_signY(1) | |
116 | , m_minX(0), m_minY(0), m_maxX(0), m_maxY(0) | |
117 | , m_clipX1(0), m_clipY1(0), m_clipX2(0), m_clipY2(0) | |
118 | , m_logicalFunction(wxCOPY) | |
119 | , m_backgroundMode(wxTRANSPARENT) | |
120 | , m_mappingMode(wxMM_TEXT) | |
121 | , m_pen() | |
122 | , m_brush() | |
123 | , m_backgroundBrush(*wxTRANSPARENT_BRUSH) | |
124 | , m_textForegroundColour(*wxBLACK) | |
125 | , m_textBackgroundColour(*wxWHITE) | |
126 | , m_font() | |
127 | #if wxUSE_PALETTE | |
128 | , m_palette() | |
68379eaf | 129 | , m_hasCustomPalette(false) |
ba161d7e | 130 | #endif // wxUSE_PALETTE |
a23fd0e1 | 131 | { |
f6bcfd97 | 132 | ResetBoundingBox(); |
d16b634f | 133 | ResetClipping(); |
a23fd0e1 VZ |
134 | } |
135 | ||
d3c7fc99 | 136 | virtual ~wxDCBase() { } |
a23fd0e1 | 137 | |
a23fd0e1 VZ |
138 | // graphic primitives |
139 | // ------------------ | |
140 | ||
aec43716 KH |
141 | virtual void DrawObject(wxDrawObject* drawobject) |
142 | { | |
143 | drawobject->Draw(*this); | |
144 | CalcBoundingBox(drawobject->MinX(),drawobject->MinY()); | |
145 | CalcBoundingBox(drawobject->MaxX(),drawobject->MaxY()); | |
146 | } | |
147 | ||
387ebd3e | 148 | bool FloodFill(wxCoord x, wxCoord y, const wxColour& col, |
72cdf4c9 | 149 | int style = wxFLOOD_SURFACE) |
387ebd3e JS |
150 | { return DoFloodFill(x, y, col, style); } |
151 | bool FloodFill(const wxPoint& pt, const wxColour& col, | |
72cdf4c9 | 152 | int style = wxFLOOD_SURFACE) |
387ebd3e | 153 | { return DoFloodFill(pt.x, pt.y, col, style); } |
a23fd0e1 | 154 | |
213ad8e7 VZ |
155 | // fill the area specified by rect with a radial gradient, starting from |
156 | // initialColour in the centre of the cercle and fading to destColour. | |
157 | void GradientFillConcentric(const wxRect& rect, | |
4660e6ac | 158 | const wxColour& initialColour, |
213ad8e7 VZ |
159 | const wxColour& destColour) |
160 | { GradientFillConcentric(rect, initialColour, destColour, | |
161 | wxPoint(rect.GetWidth() / 2, | |
162 | rect.GetHeight() / 2)); } | |
163 | ||
164 | void GradientFillConcentric(const wxRect& rect, | |
4660e6ac | 165 | const wxColour& initialColour, |
213ad8e7 | 166 | const wxColour& destColour, |
fb63a242 SC |
167 | const wxPoint& circleCenter) |
168 | { DoGradientFillConcentric(rect, initialColour, destColour, circleCenter); } | |
213ad8e7 VZ |
169 | |
170 | // fill the area specified by rect with a linear gradient | |
171 | void GradientFillLinear(const wxRect& rect, | |
4660e6ac | 172 | const wxColour& initialColour, |
213ad8e7 VZ |
173 | const wxColour& destColour, |
174 | wxDirection nDirection = wxEAST) | |
175 | { DoGradientFillLinear(rect, initialColour, destColour, nDirection); } | |
176 | ||
72cdf4c9 | 177 | bool GetPixel(wxCoord x, wxCoord y, wxColour *col) const |
a23fd0e1 VZ |
178 | { return DoGetPixel(x, y, col); } |
179 | bool GetPixel(const wxPoint& pt, wxColour *col) const | |
180 | { return DoGetPixel(pt.x, pt.y, col); } | |
181 | ||
72cdf4c9 | 182 | void DrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2) |
a23fd0e1 VZ |
183 | { DoDrawLine(x1, y1, x2, y2); } |
184 | void DrawLine(const wxPoint& pt1, const wxPoint& pt2) | |
185 | { DoDrawLine(pt1.x, pt1.y, pt2.x, pt2.y); } | |
186 | ||
72cdf4c9 | 187 | void CrossHair(wxCoord x, wxCoord y) |
a23fd0e1 VZ |
188 | { DoCrossHair(x, y); } |
189 | void CrossHair(const wxPoint& pt) | |
190 | { DoCrossHair(pt.x, pt.y); } | |
191 | ||
72cdf4c9 VZ |
192 | void DrawArc(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, |
193 | wxCoord xc, wxCoord yc) | |
a23fd0e1 VZ |
194 | { DoDrawArc(x1, y1, x2, y2, xc, yc); } |
195 | void DrawArc(const wxPoint& pt1, const wxPoint& pt2, const wxPoint& centre) | |
196 | { DoDrawArc(pt1.x, pt1.y, pt2.x, pt2.y, centre.x, centre.y); } | |
197 | ||
cd9da200 VZ |
198 | void DrawCheckMark(wxCoord x, wxCoord y, |
199 | wxCoord width, wxCoord height) | |
200 | { DoDrawCheckMark(x, y, width, height); } | |
201 | void DrawCheckMark(const wxRect& rect) | |
202 | { DoDrawCheckMark(rect.x, rect.y, rect.width, rect.height); } | |
203 | ||
72cdf4c9 VZ |
204 | void DrawEllipticArc(wxCoord x, wxCoord y, wxCoord w, wxCoord h, |
205 | double sa, double ea) | |
7b90a8f2 | 206 | { DoDrawEllipticArc(x, y, w, h, sa, ea); } |
a23fd0e1 VZ |
207 | void DrawEllipticArc(const wxPoint& pt, const wxSize& sz, |
208 | double sa, double ea) | |
209 | { DoDrawEllipticArc(pt.x, pt.y, sz.x, sz.y, sa, ea); } | |
210 | ||
72cdf4c9 | 211 | void DrawPoint(wxCoord x, wxCoord y) |
a23fd0e1 VZ |
212 | { DoDrawPoint(x, y); } |
213 | void DrawPoint(const wxPoint& pt) | |
214 | { DoDrawPoint(pt.x, pt.y); } | |
215 | ||
72cdf4c9 VZ |
216 | void DrawLines(int n, wxPoint points[], |
217 | wxCoord xoffset = 0, wxCoord yoffset = 0) | |
a23fd0e1 | 218 | { DoDrawLines(n, points, xoffset, yoffset); } |
72cdf4c9 VZ |
219 | void DrawLines(const wxList *list, |
220 | wxCoord xoffset = 0, wxCoord yoffset = 0); | |
a23fd0e1 VZ |
221 | |
222 | void DrawPolygon(int n, wxPoint points[], | |
72cdf4c9 | 223 | wxCoord xoffset = 0, wxCoord yoffset = 0, |
a23fd0e1 VZ |
224 | int fillStyle = wxODDEVEN_RULE) |
225 | { DoDrawPolygon(n, points, xoffset, yoffset, fillStyle); } | |
226 | ||
227 | void DrawPolygon(const wxList *list, | |
72cdf4c9 | 228 | wxCoord xoffset = 0, wxCoord yoffset = 0, |
bd5dd957 | 229 | int fillStyle = wxODDEVEN_RULE); |
a23fd0e1 | 230 | |
793db755 | 231 | void DrawPolyPolygon(int n, int count[], wxPoint points[], |
6e76b35d VZ |
232 | wxCoord xoffset = 0, wxCoord yoffset = 0, |
233 | int fillStyle = wxODDEVEN_RULE) | |
793db755 | 234 | { DoDrawPolyPolygon(n, count, points, xoffset, yoffset, fillStyle); } |
6e76b35d | 235 | |
72cdf4c9 | 236 | void DrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height) |
a23fd0e1 VZ |
237 | { DoDrawRectangle(x, y, width, height); } |
238 | void DrawRectangle(const wxPoint& pt, const wxSize& sz) | |
239 | { DoDrawRectangle(pt.x, pt.y, sz.x, sz.y); } | |
240 | void DrawRectangle(const wxRect& rect) | |
241 | { DoDrawRectangle(rect.x, rect.y, rect.width, rect.height); } | |
242 | ||
72cdf4c9 | 243 | void DrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height, |
a23fd0e1 VZ |
244 | double radius) |
245 | { DoDrawRoundedRectangle(x, y, width, height, radius); } | |
246 | void DrawRoundedRectangle(const wxPoint& pt, const wxSize& sz, | |
247 | double radius) | |
248 | { DoDrawRoundedRectangle(pt.x, pt.y, sz.x, sz.y, radius); } | |
249 | void DrawRoundedRectangle(const wxRect& r, double radius) | |
250 | { DoDrawRoundedRectangle(r.x, r.y, r.width, r.height, radius); } | |
251 | ||
72cdf4c9 | 252 | void DrawCircle(wxCoord x, wxCoord y, wxCoord radius) |
220af862 | 253 | { DoDrawEllipse(x - radius, y - radius, 2*radius, 2*radius); } |
0371e9a8 | 254 | void DrawCircle(const wxPoint& pt, wxCoord radius) |
b95edd47 | 255 | { DrawCircle(pt.x, pt.y, radius); } |
0371e9a8 | 256 | |
72cdf4c9 | 257 | void DrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height) |
a23fd0e1 VZ |
258 | { DoDrawEllipse(x, y, width, height); } |
259 | void DrawEllipse(const wxPoint& pt, const wxSize& sz) | |
260 | { DoDrawEllipse(pt.x, pt.y, sz.x, sz.y); } | |
261 | void DrawEllipse(const wxRect& rect) | |
262 | { DoDrawEllipse(rect.x, rect.y, rect.width, rect.height); } | |
263 | ||
72cdf4c9 | 264 | void DrawIcon(const wxIcon& icon, wxCoord x, wxCoord y) |
a23fd0e1 VZ |
265 | { DoDrawIcon(icon, x, y); } |
266 | void DrawIcon(const wxIcon& icon, const wxPoint& pt) | |
267 | { DoDrawIcon(icon, pt.x, pt.y); } | |
268 | ||
72cdf4c9 | 269 | void DrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y, |
68379eaf | 270 | bool useMask = false) |
a23fd0e1 VZ |
271 | { DoDrawBitmap(bmp, x, y, useMask); } |
272 | void DrawBitmap(const wxBitmap &bmp, const wxPoint& pt, | |
68379eaf | 273 | bool useMask = false) |
a23fd0e1 VZ |
274 | { DoDrawBitmap(bmp, pt.x, pt.y, useMask); } |
275 | ||
72cdf4c9 | 276 | void DrawText(const wxString& text, wxCoord x, wxCoord y) |
a23fd0e1 VZ |
277 | { DoDrawText(text, x, y); } |
278 | void DrawText(const wxString& text, const wxPoint& pt) | |
279 | { DoDrawText(text, pt.x, pt.y); } | |
280 | ||
95724b1a VZ |
281 | void DrawRotatedText(const wxString& text, wxCoord x, wxCoord y, double angle) |
282 | { DoDrawRotatedText(text, x, y, angle); } | |
283 | void DrawRotatedText(const wxString& text, const wxPoint& pt, double angle) | |
284 | { DoDrawRotatedText(text, pt.x, pt.y, angle); } | |
285 | ||
1e6feb95 VZ |
286 | // this version puts both optional bitmap and the text into the given |
287 | // rectangle and aligns is as specified by alignment parameter; it also | |
288 | // will emphasize the character with the given index if it is != -1 and | |
289 | // return the bounding rectangle if required | |
290 | virtual void DrawLabel(const wxString& text, | |
291 | const wxBitmap& image, | |
292 | const wxRect& rect, | |
293 | int alignment = wxALIGN_LEFT | wxALIGN_TOP, | |
294 | int indexAccel = -1, | |
295 | wxRect *rectBounding = NULL); | |
296 | ||
297 | void DrawLabel(const wxString& text, const wxRect& rect, | |
298 | int alignment = wxALIGN_LEFT | wxALIGN_TOP, | |
299 | int indexAccel = -1) | |
300 | { DrawLabel(text, wxNullBitmap, rect, alignment, indexAccel); } | |
301 | ||
72cdf4c9 VZ |
302 | bool Blit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height, |
303 | wxDC *source, wxCoord xsrc, wxCoord ysrc, | |
68379eaf | 304 | int rop = wxCOPY, bool useMask = false, wxCoord xsrcMask = wxDefaultCoord, wxCoord ysrcMask = wxDefaultCoord) |
a23fd0e1 VZ |
305 | { |
306 | return DoBlit(xdest, ydest, width, height, | |
0cbff120 | 307 | source, xsrc, ysrc, rop, useMask, xsrcMask, ysrcMask); |
a23fd0e1 VZ |
308 | } |
309 | bool Blit(const wxPoint& destPt, const wxSize& sz, | |
310 | wxDC *source, const wxPoint& srcPt, | |
68379eaf | 311 | int rop = wxCOPY, bool useMask = false, const wxPoint& srcPtMask = wxDefaultPosition) |
a23fd0e1 VZ |
312 | { |
313 | return DoBlit(destPt.x, destPt.y, sz.x, sz.y, | |
0cbff120 | 314 | source, srcPt.x, srcPt.y, rop, useMask, srcPtMask.x, srcPtMask.y); |
a23fd0e1 | 315 | } |
c64c9cd3 | 316 | |
c59abe03 | 317 | wxBitmap GetAsBitmap(const wxRect *subrect = (const wxRect *) NULL) const |
c64c9cd3 | 318 | { |
c59abe03 | 319 | return DoGetAsBitmap(subrect); |
c64c9cd3 | 320 | } |
a23fd0e1 VZ |
321 | |
322 | #if wxUSE_SPLINES | |
72cdf4c9 VZ |
323 | // TODO: this API needs fixing (wxPointList, why (!const) "wxList *"?) |
324 | void DrawSpline(wxCoord x1, wxCoord y1, | |
325 | wxCoord x2, wxCoord y2, | |
326 | wxCoord x3, wxCoord y3); | |
bd5dd957 | 327 | void DrawSpline(int n, wxPoint points[]); |
a23fd0e1 VZ |
328 | |
329 | void DrawSpline(wxList *points) { DoDrawSpline(points); } | |
330 | #endif // wxUSE_SPLINES | |
331 | ||
12bdd77c JS |
332 | // Eventually we will have wxUSE_GENERIC_DRAWELLIPSE |
333 | #ifdef __WXWINCE__ | |
334 | //! Generic method to draw ellipses, circles and arcs with current pen and brush. | |
335 | /*! \param x Upper left corner of bounding box. | |
336 | * \param y Upper left corner of bounding box. | |
337 | * \param w Width of bounding box. | |
338 | * \param h Height of bounding box. | |
d16b634f | 339 | * \param sa Starting angle of arc |
12bdd77c JS |
340 | * (counterclockwise, start at 3 o'clock, 360 is full circle). |
341 | * \param ea Ending angle of arc. | |
d16b634f | 342 | * \param angle Rotation angle, the Arc will be rotated after |
12bdd77c JS |
343 | * calculating begin and end. |
344 | */ | |
d16b634f VZ |
345 | void DrawEllipticArcRot( wxCoord x, wxCoord y, |
346 | wxCoord width, wxCoord height, | |
12bdd77c JS |
347 | double sa = 0, double ea = 0, double angle = 0 ) |
348 | { DoDrawEllipticArcRot( x, y, width, height, sa, ea, angle ); } | |
d16b634f VZ |
349 | |
350 | void DrawEllipticArcRot( const wxPoint& pt, | |
12bdd77c JS |
351 | const wxSize& sz, |
352 | double sa = 0, double ea = 0, double angle = 0 ) | |
353 | { DoDrawEllipticArcRot( pt.x, pt.y, sz.x, sz.y, sa, ea, angle ); } | |
354 | ||
355 | void DrawEllipticArcRot( const wxRect& rect, | |
356 | double sa = 0, double ea = 0, double angle = 0 ) | |
357 | { DoDrawEllipticArcRot( rect.x, rect.y, rect.width, rect.height, sa, ea, angle ); } | |
358 | ||
d16b634f VZ |
359 | virtual void DoDrawEllipticArcRot( wxCoord x, wxCoord y, |
360 | wxCoord w, wxCoord h, | |
12bdd77c | 361 | double sa = 0, double ea = 0, double angle = 0 ); |
d16b634f | 362 | |
12bdd77c JS |
363 | //! Rotates points around center. |
364 | /*! This is a quite straight method, it calculates in pixels | |
365 | * and so it produces rounding errors. | |
366 | * \param points The points inside will be rotated. | |
367 | * \param angle Rotating angle (counterclockwise, start at 3 o'clock, 360 is full circle). | |
368 | * \param center Center of rotation. | |
d16b634f | 369 | */ |
c47addef | 370 | void Rotate( wxList* points, double angle, wxPoint center = wxPoint(0,0) ); |
12bdd77c JS |
371 | |
372 | // used by DrawEllipticArcRot | |
373 | // Careful: wxList gets filled with points you have to delete later. | |
d16b634f VZ |
374 | void CalculateEllipticPoints( wxList* points, |
375 | wxCoord xStart, wxCoord yStart, | |
376 | wxCoord w, wxCoord h, | |
12bdd77c JS |
377 | double sa, double ea ); |
378 | #endif | |
d16b634f | 379 | |
a23fd0e1 VZ |
380 | // global DC operations |
381 | // -------------------- | |
382 | ||
383 | virtual void Clear() = 0; | |
384 | ||
68379eaf | 385 | virtual bool StartDoc(const wxString& WXUNUSED(message)) { return true; } |
af0bb3b1 | 386 | virtual void EndDoc() { } |
a23fd0e1 | 387 | |
af0bb3b1 VZ |
388 | virtual void StartPage() { } |
389 | virtual void EndPage() { } | |
a23fd0e1 | 390 | |
2e992e06 VZ |
391 | #if WXWIN_COMPATIBILITY_2_6 |
392 | wxDEPRECATED( void BeginDrawing() ); | |
393 | wxDEPRECATED( void EndDrawing() ); | |
394 | #endif // WXWIN_COMPATIBILITY_2_6 | |
395 | ||
396 | ||
a23fd0e1 VZ |
397 | // set objects to use for drawing |
398 | // ------------------------------ | |
399 | ||
400 | virtual void SetFont(const wxFont& font) = 0; | |
401 | virtual void SetPen(const wxPen& pen) = 0; | |
402 | virtual void SetBrush(const wxBrush& brush) = 0; | |
403 | virtual void SetBackground(const wxBrush& brush) = 0; | |
404 | virtual void SetBackgroundMode(int mode) = 0; | |
d275c7eb | 405 | #if wxUSE_PALETTE |
a23fd0e1 | 406 | virtual void SetPalette(const wxPalette& palette) = 0; |
d275c7eb | 407 | #endif // wxUSE_PALETTE |
a23fd0e1 VZ |
408 | |
409 | // clipping region | |
410 | // --------------- | |
411 | ||
72cdf4c9 | 412 | void SetClippingRegion(wxCoord x, wxCoord y, wxCoord width, wxCoord height) |
a23fd0e1 VZ |
413 | { DoSetClippingRegion(x, y, width, height); } |
414 | void SetClippingRegion(const wxPoint& pt, const wxSize& sz) | |
415 | { DoSetClippingRegion(pt.x, pt.y, sz.x, sz.y); } | |
416 | void SetClippingRegion(const wxRect& rect) | |
417 | { DoSetClippingRegion(rect.x, rect.y, rect.width, rect.height); } | |
418 | void SetClippingRegion(const wxRegion& region) | |
419 | { DoSetClippingRegionAsRegion(region); } | |
420 | ||
d16b634f | 421 | virtual void DestroyClippingRegion() { ResetClipping(); } |
a23fd0e1 | 422 | |
72cdf4c9 | 423 | void GetClippingBox(wxCoord *x, wxCoord *y, wxCoord *w, wxCoord *h) const |
a23fd0e1 VZ |
424 | { DoGetClippingBox(x, y, w, h); } |
425 | void GetClippingBox(wxRect& rect) const | |
8fb3a512 | 426 | { |
ae500232 | 427 | DoGetClippingBox(&rect.x, &rect.y, &rect.width, &rect.height); |
8fb3a512 | 428 | } |
a23fd0e1 VZ |
429 | |
430 | // text extent | |
431 | // ----------- | |
432 | ||
72cdf4c9 VZ |
433 | virtual wxCoord GetCharHeight() const = 0; |
434 | virtual wxCoord GetCharWidth() const = 0; | |
cd9da200 | 435 | |
1e6feb95 | 436 | // only works for single line strings |
72cdf4c9 VZ |
437 | void GetTextExtent(const wxString& string, |
438 | wxCoord *x, wxCoord *y, | |
439 | wxCoord *descent = NULL, | |
440 | wxCoord *externalLeading = NULL, | |
441 | wxFont *theFont = NULL) const | |
442 | { DoGetTextExtent(string, x, y, descent, externalLeading, theFont); } | |
a23fd0e1 | 443 | |
cc4f194e VZ |
444 | wxSize GetTextExtent(const wxString& string) const |
445 | { | |
446 | wxCoord w, h; | |
447 | DoGetTextExtent(string, &w, &h); | |
448 | return wxSize(w, h); | |
449 | } | |
450 | ||
1e6feb95 | 451 | // works for single as well as multi-line strings |
cc4f194e | 452 | virtual void GetMultiLineTextExtent(const wxString& string, |
1e6feb95 VZ |
453 | wxCoord *width, |
454 | wxCoord *height, | |
455 | wxCoord *heightLine = NULL, | |
169147c8 | 456 | wxFont *font = NULL) const; |
1e6feb95 | 457 | |
cc4f194e VZ |
458 | wxSize GetMultiLineTextExtent(const wxString& string) const |
459 | { | |
460 | wxCoord w, h; | |
461 | GetMultiLineTextExtent(string, &w, &h); | |
462 | return wxSize(w, h); | |
463 | } | |
464 | ||
0919e93e RD |
465 | // Measure cumulative width of text after each character |
466 | bool GetPartialTextExtents(const wxString& text, wxArrayInt& widths) const | |
467 | { return DoGetPartialTextExtents(text, widths); } | |
468 | ||
d16b634f | 469 | |
a23fd0e1 VZ |
470 | // size and resolution |
471 | // ------------------- | |
472 | ||
473 | // in device units | |
474 | void GetSize(int *width, int *height) const | |
475 | { DoGetSize(width, height); } | |
476 | wxSize GetSize() const | |
477 | { | |
478 | int w, h; | |
479 | DoGetSize(&w, &h); | |
480 | ||
481 | return wxSize(w, h); | |
482 | } | |
483 | ||
484 | // in mm | |
485 | void GetSizeMM(int* width, int* height) const | |
486 | { DoGetSizeMM(width, height); } | |
487 | wxSize GetSizeMM() const | |
488 | { | |
489 | int w, h; | |
490 | DoGetSizeMM(&w, &h); | |
491 | ||
492 | return wxSize(w, h); | |
493 | } | |
494 | ||
495 | // coordinates conversions | |
496 | // ----------------------- | |
497 | ||
498 | // This group of functions does actual conversion of the input, as you'd | |
499 | // expect. | |
72cdf4c9 VZ |
500 | wxCoord DeviceToLogicalX(wxCoord x) const; |
501 | wxCoord DeviceToLogicalY(wxCoord y) const; | |
502 | wxCoord DeviceToLogicalXRel(wxCoord x) const; | |
503 | wxCoord DeviceToLogicalYRel(wxCoord y) const; | |
504 | wxCoord LogicalToDeviceX(wxCoord x) const; | |
505 | wxCoord LogicalToDeviceY(wxCoord y) const; | |
506 | wxCoord LogicalToDeviceXRel(wxCoord x) const; | |
507 | wxCoord LogicalToDeviceYRel(wxCoord y) const; | |
a23fd0e1 VZ |
508 | |
509 | // query DC capabilities | |
510 | // --------------------- | |
511 | ||
512 | virtual bool CanDrawBitmap() const = 0; | |
513 | virtual bool CanGetTextExtent() const = 0; | |
514 | ||
515 | // colour depth | |
516 | virtual int GetDepth() const = 0; | |
517 | ||
518 | // Resolution in Pixels per inch | |
519 | virtual wxSize GetPPI() const = 0; | |
520 | ||
b7cacb43 VZ |
521 | virtual bool Ok() const { return IsOk(); } |
522 | virtual bool IsOk() const { return m_ok; } | |
a23fd0e1 | 523 | |
2439f37a VZ |
524 | // accessors and setters |
525 | // --------------------- | |
a23fd0e1 | 526 | |
2e992e06 VZ |
527 | virtual int GetBackgroundMode() const { return m_backgroundMode; } |
528 | virtual const wxBrush& GetBackground() const { return m_backgroundBrush; } | |
529 | virtual const wxBrush& GetBrush() const { return m_brush; } | |
530 | virtual const wxFont& GetFont() const { return m_font; } | |
531 | virtual const wxPen& GetPen() const { return m_pen; } | |
a23fd0e1 | 532 | |
2e992e06 VZ |
533 | virtual const wxColour& GetTextForeground() const { return m_textForegroundColour; } |
534 | virtual const wxColour& GetTextBackground() const { return m_textBackgroundColour; } | |
a23fd0e1 VZ |
535 | virtual void SetTextForeground(const wxColour& colour) |
536 | { m_textForegroundColour = colour; } | |
537 | virtual void SetTextBackground(const wxColour& colour) | |
538 | { m_textBackgroundColour = colour; } | |
539 | ||
2e992e06 | 540 | virtual int GetMapMode() const { return m_mappingMode; } |
a23fd0e1 VZ |
541 | virtual void SetMapMode(int mode) = 0; |
542 | ||
543 | virtual void GetUserScale(double *x, double *y) const | |
544 | { | |
545 | if ( x ) *x = m_userScaleX; | |
546 | if ( y ) *y = m_userScaleY; | |
547 | } | |
548 | virtual void SetUserScale(double x, double y) = 0; | |
549 | ||
a23fd0e1 VZ |
550 | virtual void GetLogicalScale(double *x, double *y) |
551 | { | |
552 | if ( x ) *x = m_logicalScaleX; | |
553 | if ( y ) *y = m_logicalScaleY; | |
554 | } | |
555 | virtual void SetLogicalScale(double x, double y) | |
556 | { | |
557 | m_logicalScaleX = x; | |
558 | m_logicalScaleY = y; | |
559 | } | |
560 | ||
72cdf4c9 | 561 | void GetLogicalOrigin(wxCoord *x, wxCoord *y) const |
a23fd0e1 VZ |
562 | { DoGetLogicalOrigin(x, y); } |
563 | wxPoint GetLogicalOrigin() const | |
72cdf4c9 VZ |
564 | { wxCoord x, y; DoGetLogicalOrigin(&x, &y); return wxPoint(x, y); } |
565 | virtual void SetLogicalOrigin(wxCoord x, wxCoord y) = 0; | |
a23fd0e1 | 566 | |
72cdf4c9 | 567 | void GetDeviceOrigin(wxCoord *x, wxCoord *y) const |
a23fd0e1 VZ |
568 | { DoGetDeviceOrigin(x, y); } |
569 | wxPoint GetDeviceOrigin() const | |
72cdf4c9 VZ |
570 | { wxCoord x, y; DoGetDeviceOrigin(&x, &y); return wxPoint(x, y); } |
571 | virtual void SetDeviceOrigin(wxCoord x, wxCoord y) = 0; | |
a23fd0e1 | 572 | |
b1263dcf WS |
573 | virtual void ComputeScaleAndOrigin() {} |
574 | ||
a23fd0e1 VZ |
575 | virtual void SetAxisOrientation(bool xLeftRight, bool yBottomUp) = 0; |
576 | ||
2e992e06 | 577 | virtual int GetLogicalFunction() const { return m_logicalFunction; } |
a23fd0e1 VZ |
578 | virtual void SetLogicalFunction(int function) = 0; |
579 | ||
a23fd0e1 VZ |
580 | // bounding box |
581 | // ------------ | |
582 | ||
72cdf4c9 | 583 | virtual void CalcBoundingBox(wxCoord x, wxCoord y) |
a23fd0e1 | 584 | { |
f6bcfd97 BP |
585 | if ( m_isBBoxValid ) |
586 | { | |
587 | if ( x < m_minX ) m_minX = x; | |
588 | if ( y < m_minY ) m_minY = y; | |
589 | if ( x > m_maxX ) m_maxX = x; | |
590 | if ( y > m_maxY ) m_maxY = y; | |
591 | } | |
592 | else | |
593 | { | |
68379eaf | 594 | m_isBBoxValid = true; |
f6bcfd97 BP |
595 | |
596 | m_minX = x; | |
597 | m_minY = y; | |
598 | m_maxX = x; | |
599 | m_maxY = y; | |
600 | } | |
601 | } | |
602 | ||
603 | void ResetBoundingBox() | |
604 | { | |
68379eaf | 605 | m_isBBoxValid = false; |
f6bcfd97 BP |
606 | |
607 | m_minX = m_maxX = m_minY = m_maxY = 0; | |
a23fd0e1 VZ |
608 | } |
609 | ||
610 | // Get the final bounding box of the PostScript or Metafile picture. | |
72cdf4c9 VZ |
611 | wxCoord MinX() const { return m_minX; } |
612 | wxCoord MaxX() const { return m_maxX; } | |
613 | wxCoord MinY() const { return m_minY; } | |
614 | wxCoord MaxY() const { return m_maxY; } | |
a23fd0e1 VZ |
615 | |
616 | // misc old functions | |
617 | // ------------------ | |
618 | ||
72cdf4c9 | 619 | // for compatibility with the old code when wxCoord was long everywhere |
72cdf4c9 VZ |
620 | void GetTextExtent(const wxString& string, |
621 | long *x, long *y, | |
622 | long *descent = NULL, | |
623 | long *externalLeading = NULL, | |
624 | wxFont *theFont = NULL) const | |
625 | { | |
626 | wxCoord x2, y2, descent2, externalLeading2; | |
627 | DoGetTextExtent(string, &x2, &y2, | |
628 | &descent2, &externalLeading2, | |
629 | theFont); | |
630 | if ( x ) | |
631 | *x = x2; | |
632 | if ( y ) | |
633 | *y = y2; | |
634 | if ( descent ) | |
635 | *descent = descent2; | |
636 | if ( externalLeading ) | |
637 | *externalLeading = externalLeading2; | |
638 | } | |
639 | ||
640 | void GetLogicalOrigin(long *x, long *y) const | |
641 | { | |
642 | wxCoord x2, y2; | |
643 | DoGetLogicalOrigin(&x2, &y2); | |
644 | if ( x ) | |
645 | *x = x2; | |
646 | if ( y ) | |
647 | *y = y2; | |
648 | } | |
649 | ||
650 | void GetDeviceOrigin(long *x, long *y) const | |
651 | { | |
652 | wxCoord x2, y2; | |
653 | DoGetDeviceOrigin(&x2, &y2); | |
654 | if ( x ) | |
655 | *x = x2; | |
656 | if ( y ) | |
657 | *y = y2; | |
658 | } | |
1dd989e1 | 659 | void GetClippingBox(long *x, long *y, long *w, long *h) const |
cd9da200 VZ |
660 | { |
661 | wxCoord xx,yy,ww,hh; | |
662 | DoGetClippingBox(&xx, &yy, &ww, &hh); | |
663 | if (x) *x = xx; | |
664 | if (y) *y = yy; | |
665 | if (w) *w = ww; | |
666 | if (h) *h = hh; | |
1dd989e1 | 667 | } |
72cdf4c9 | 668 | |
6ae7410f VZ |
669 | // RTL related functions |
670 | // --------------------- | |
671 | ||
672 | // get or change the layout direction (LTR or RTL) for this dc, | |
673 | // wxLayout_Default is returned if layout direction is not supported | |
674 | virtual wxLayoutDirection GetLayoutDirection() const | |
675 | { return wxLayout_Default; } | |
676 | virtual void SetLayoutDirection(wxLayoutDirection WXUNUSED(dir)) | |
677 | { } | |
678 | ||
a23fd0e1 VZ |
679 | protected: |
680 | // the pure virtual functions which should be implemented by wxDC | |
387ebd3e | 681 | virtual bool DoFloodFill(wxCoord x, wxCoord y, const wxColour& col, |
a23fd0e1 VZ |
682 | int style = wxFLOOD_SURFACE) = 0; |
683 | ||
213ad8e7 VZ |
684 | virtual void DoGradientFillLinear(const wxRect& rect, |
685 | const wxColour& initialColour, | |
686 | const wxColour& destColour, | |
687 | wxDirection nDirection = wxEAST); | |
4660e6ac | 688 | |
fb63a242 SC |
689 | virtual void DoGradientFillConcentric(const wxRect& rect, |
690 | const wxColour& initialColour, | |
691 | const wxColour& destColour, | |
692 | const wxPoint& circleCenter); | |
693 | ||
72cdf4c9 | 694 | virtual bool DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const = 0; |
a23fd0e1 | 695 | |
72cdf4c9 VZ |
696 | virtual void DoDrawPoint(wxCoord x, wxCoord y) = 0; |
697 | virtual void DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2) = 0; | |
a23fd0e1 | 698 | |
72cdf4c9 VZ |
699 | virtual void DoDrawArc(wxCoord x1, wxCoord y1, |
700 | wxCoord x2, wxCoord y2, | |
701 | wxCoord xc, wxCoord yc) = 0; | |
cd9da200 VZ |
702 | virtual void DoDrawCheckMark(wxCoord x, wxCoord y, |
703 | wxCoord width, wxCoord height); | |
72cdf4c9 | 704 | virtual void DoDrawEllipticArc(wxCoord x, wxCoord y, wxCoord w, wxCoord h, |
a23fd0e1 VZ |
705 | double sa, double ea) = 0; |
706 | ||
72cdf4c9 VZ |
707 | virtual void DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height) = 0; |
708 | virtual void DoDrawRoundedRectangle(wxCoord x, wxCoord y, | |
709 | wxCoord width, wxCoord height, | |
a23fd0e1 | 710 | double radius) = 0; |
72cdf4c9 VZ |
711 | virtual void DoDrawEllipse(wxCoord x, wxCoord y, |
712 | wxCoord width, wxCoord height) = 0; | |
a23fd0e1 | 713 | |
72cdf4c9 | 714 | virtual void DoCrossHair(wxCoord x, wxCoord y) = 0; |
a23fd0e1 | 715 | |
72cdf4c9 VZ |
716 | virtual void DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y) = 0; |
717 | virtual void DoDrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y, | |
68379eaf | 718 | bool useMask = false) = 0; |
a23fd0e1 | 719 | |
72cdf4c9 | 720 | virtual void DoDrawText(const wxString& text, wxCoord x, wxCoord y) = 0; |
95724b1a VZ |
721 | virtual void DoDrawRotatedText(const wxString& text, |
722 | wxCoord x, wxCoord y, double angle) = 0; | |
a23fd0e1 | 723 | |
72cdf4c9 VZ |
724 | virtual bool DoBlit(wxCoord xdest, wxCoord ydest, |
725 | wxCoord width, wxCoord height, | |
726 | wxDC *source, wxCoord xsrc, wxCoord ysrc, | |
68379eaf | 727 | int rop = wxCOPY, bool useMask = false, wxCoord xsrcMask = wxDefaultCoord, wxCoord ysrcMask = wxDefaultCoord) = 0; |
a23fd0e1 | 728 | |
c59abe03 | 729 | virtual wxBitmap DoGetAsBitmap(const wxRect *WXUNUSED(subrect)) const { return wxNullBitmap; } |
c64c9cd3 | 730 | |
a23fd0e1 VZ |
731 | virtual void DoGetSize(int *width, int *height) const = 0; |
732 | virtual void DoGetSizeMM(int* width, int* height) const = 0; | |
733 | ||
734 | virtual void DoDrawLines(int n, wxPoint points[], | |
72cdf4c9 | 735 | wxCoord xoffset, wxCoord yoffset) = 0; |
a23fd0e1 | 736 | virtual void DoDrawPolygon(int n, wxPoint points[], |
72cdf4c9 | 737 | wxCoord xoffset, wxCoord yoffset, |
a23fd0e1 | 738 | int fillStyle = wxODDEVEN_RULE) = 0; |
793db755 | 739 | virtual void DoDrawPolyPolygon(int n, int count[], wxPoint points[], |
6e76b35d VZ |
740 | wxCoord xoffset, wxCoord yoffset, |
741 | int fillStyle); | |
a23fd0e1 VZ |
742 | |
743 | virtual void DoSetClippingRegionAsRegion(const wxRegion& region) = 0; | |
72cdf4c9 VZ |
744 | virtual void DoSetClippingRegion(wxCoord x, wxCoord y, |
745 | wxCoord width, wxCoord height) = 0; | |
b0e0d661 | 746 | |
72cdf4c9 VZ |
747 | virtual void DoGetClippingBox(wxCoord *x, wxCoord *y, |
748 | wxCoord *w, wxCoord *h) const | |
a23fd0e1 | 749 | { |
d16b634f VZ |
750 | if ( x ) |
751 | *x = m_clipX1; | |
752 | if ( y ) | |
753 | *y = m_clipY1; | |
754 | if ( w ) | |
755 | *w = m_clipX2 - m_clipX1; | |
756 | if ( h ) | |
757 | *h = m_clipY2 - m_clipY1; | |
a23fd0e1 VZ |
758 | } |
759 | ||
72cdf4c9 | 760 | virtual void DoGetLogicalOrigin(wxCoord *x, wxCoord *y) const |
a23fd0e1 VZ |
761 | { |
762 | if ( x ) *x = m_logicalOriginX; | |
763 | if ( y ) *y = m_logicalOriginY; | |
764 | } | |
765 | ||
72cdf4c9 | 766 | virtual void DoGetDeviceOrigin(wxCoord *x, wxCoord *y) const |
a23fd0e1 VZ |
767 | { |
768 | if ( x ) *x = m_deviceOriginX; | |
769 | if ( y ) *y = m_deviceOriginY; | |
770 | } | |
771 | ||
72cdf4c9 VZ |
772 | virtual void DoGetTextExtent(const wxString& string, |
773 | wxCoord *x, wxCoord *y, | |
774 | wxCoord *descent = NULL, | |
775 | wxCoord *externalLeading = NULL, | |
776 | wxFont *theFont = NULL) const = 0; | |
d16b634f | 777 | |
0919e93e | 778 | virtual bool DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const; |
d16b634f | 779 | |
64698f9a | 780 | #if wxUSE_SPLINES |
fe2e4366 | 781 | virtual void DoDrawSpline(wxList *points); |
64698f9a | 782 | #endif |
a23fd0e1 VZ |
783 | |
784 | protected: | |
d16b634f VZ |
785 | // unset clipping variables (after clipping region was destroyed) |
786 | void ResetClipping() | |
787 | { | |
788 | m_clipping = false; | |
789 | ||
790 | m_clipX1 = m_clipX2 = m_clipY1 = m_clipY2 = 0; | |
791 | } | |
792 | ||
a23fd0e1 VZ |
793 | // flags |
794 | bool m_colour:1; | |
795 | bool m_ok:1; | |
796 | bool m_clipping:1; | |
797 | bool m_isInteractive:1; | |
f6bcfd97 | 798 | bool m_isBBoxValid:1; |
a23fd0e1 VZ |
799 | |
800 | // coordinate system variables | |
801 | ||
802 | // TODO short descriptions of what exactly they are would be nice... | |
803 | ||
72cdf4c9 VZ |
804 | wxCoord m_logicalOriginX, m_logicalOriginY; |
805 | wxCoord m_deviceOriginX, m_deviceOriginY; | |
a23fd0e1 VZ |
806 | |
807 | double m_logicalScaleX, m_logicalScaleY; | |
808 | double m_userScaleX, m_userScaleY; | |
809 | double m_scaleX, m_scaleY; | |
810 | ||
811 | // Used by SetAxisOrientation() to invert the axes | |
812 | int m_signX, m_signY; | |
813 | ||
814 | // bounding and clipping boxes | |
72cdf4c9 VZ |
815 | wxCoord m_minX, m_minY, m_maxX, m_maxY; |
816 | wxCoord m_clipX1, m_clipY1, m_clipX2, m_clipY2; | |
a23fd0e1 VZ |
817 | |
818 | int m_logicalFunction; | |
819 | int m_backgroundMode; | |
820 | int m_mappingMode; | |
821 | ||
822 | // GDI objects | |
823 | wxPen m_pen; | |
824 | wxBrush m_brush; | |
825 | wxBrush m_backgroundBrush; | |
826 | wxColour m_textForegroundColour; | |
827 | wxColour m_textBackgroundColour; | |
828 | wxFont m_font; | |
d275c7eb VZ |
829 | |
830 | #if wxUSE_PALETTE | |
a23fd0e1 | 831 | wxPalette m_palette; |
b95edd47 | 832 | bool m_hasCustomPalette; |
d275c7eb | 833 | #endif // wxUSE_PALETTE |
a23fd0e1 VZ |
834 | |
835 | private: | |
ac84e37d | 836 | DECLARE_NO_COPY_CLASS(wxDCBase) |
cd9da200 | 837 | DECLARE_ABSTRACT_CLASS(wxDCBase) |
a23fd0e1 VZ |
838 | }; |
839 | ||
840 | // ---------------------------------------------------------------------------- | |
841 | // now include the declaration of wxDC class | |
842 | // ---------------------------------------------------------------------------- | |
843 | ||
4055ed82 | 844 | #if defined(__WXPALMOS__) |
ffecfa5a JS |
845 | #include "wx/palmos/dc.h" |
846 | #elif defined(__WXMSW__) | |
a23fd0e1 | 847 | #include "wx/msw/dc.h" |
2049ba38 | 848 | #elif defined(__WXMOTIF__) |
a23fd0e1 | 849 | #include "wx/motif/dc.h" |
1be7a35c | 850 | #elif defined(__WXGTK20__) |
a23fd0e1 | 851 | #include "wx/gtk/dc.h" |
1be7a35c MR |
852 | #elif defined(__WXGTK__) |
853 | #include "wx/gtk1/dc.h" | |
83df96d6 JS |
854 | #elif defined(__WXX11__) |
855 | #include "wx/x11/dc.h" | |
1e6feb95 VZ |
856 | #elif defined(__WXMGL__) |
857 | #include "wx/mgl/dc.h" | |
b3c86150 VS |
858 | #elif defined(__WXDFB__) |
859 | #include "wx/dfb/dc.h" | |
34138703 | 860 | #elif defined(__WXMAC__) |
a23fd0e1 | 861 | #include "wx/mac/dc.h" |
f4515f98 DE |
862 | #elif defined(__WXCOCOA__) |
863 | #include "wx/cocoa/dc.h" | |
1777b9bb DW |
864 | #elif defined(__WXPM__) |
865 | #include "wx/os2/dc.h" | |
c801d85f KB |
866 | #endif |
867 | ||
8acd14d1 SC |
868 | #if wxUSE_GRAPHICS_CONTEXT |
869 | #include "wx/dcgraph.h" | |
870 | #endif | |
871 | ||
1e6feb95 VZ |
872 | // ---------------------------------------------------------------------------- |
873 | // helper class: you can use it to temporarily change the DC text colour and | |
874 | // restore it automatically when the object goes out of scope | |
875 | // ---------------------------------------------------------------------------- | |
876 | ||
877 | class WXDLLEXPORT wxDCTextColourChanger | |
878 | { | |
879 | public: | |
ba161d7e | 880 | wxDCTextColourChanger(wxDC& dc) : m_dc(dc), m_colFgOld() { } |
1e6feb95 | 881 | |
1b97b23d VS |
882 | wxDCTextColourChanger(wxDC& dc, const wxColour& col) : m_dc(dc) |
883 | { | |
884 | Set(col); | |
885 | } | |
886 | ||
1e6feb95 VZ |
887 | ~wxDCTextColourChanger() |
888 | { | |
889 | if ( m_colFgOld.Ok() ) | |
890 | m_dc.SetTextForeground(m_colFgOld); | |
891 | } | |
892 | ||
893 | void Set(const wxColour& col) | |
894 | { | |
895 | if ( !m_colFgOld.Ok() ) | |
896 | m_colFgOld = m_dc.GetTextForeground(); | |
897 | m_dc.SetTextForeground(col); | |
898 | } | |
899 | ||
900 | private: | |
901 | wxDC& m_dc; | |
902 | ||
903 | wxColour m_colFgOld; | |
fc7a2a60 VZ |
904 | |
905 | DECLARE_NO_COPY_CLASS(wxDCTextColourChanger) | |
1e6feb95 VZ |
906 | }; |
907 | ||
4660e6ac WS |
908 | // ---------------------------------------------------------------------------- |
909 | // helper class: you can use it to temporarily change the DC pen and | |
910 | // restore it automatically when the object goes out of scope | |
911 | // ---------------------------------------------------------------------------- | |
912 | ||
913 | class WXDLLEXPORT wxDCPenChanger | |
914 | { | |
915 | public: | |
0164f8eb WS |
916 | wxDCPenChanger(wxDC& dc, const wxPen& pen) : m_dc(dc), m_penOld(dc.GetPen()) |
917 | { | |
918 | m_dc.SetPen(pen); | |
919 | } | |
4660e6ac WS |
920 | |
921 | ~wxDCPenChanger() | |
922 | { | |
923 | if ( m_penOld.Ok() ) | |
924 | m_dc.SetPen(m_penOld); | |
925 | } | |
926 | ||
4660e6ac WS |
927 | private: |
928 | wxDC& m_dc; | |
929 | ||
930 | wxPen m_penOld; | |
931 | ||
932 | DECLARE_NO_COPY_CLASS(wxDCPenChanger) | |
933 | }; | |
934 | ||
935 | // ---------------------------------------------------------------------------- | |
936 | // helper class: you can use it to temporarily change the DC brush and | |
937 | // restore it automatically when the object goes out of scope | |
938 | // ---------------------------------------------------------------------------- | |
939 | ||
940 | class WXDLLEXPORT wxDCBrushChanger | |
941 | { | |
942 | public: | |
0164f8eb WS |
943 | wxDCBrushChanger(wxDC& dc, const wxBrush& brush) : m_dc(dc), m_brushOld(dc.GetBrush()) |
944 | { | |
945 | m_dc.SetBrush(brush); | |
946 | } | |
4660e6ac WS |
947 | |
948 | ~wxDCBrushChanger() | |
949 | { | |
950 | if ( m_brushOld.Ok() ) | |
951 | m_dc.SetBrush(m_brushOld); | |
952 | } | |
953 | ||
4660e6ac WS |
954 | private: |
955 | wxDC& m_dc; | |
956 | ||
957 | wxBrush m_brushOld; | |
958 | ||
959 | DECLARE_NO_COPY_CLASS(wxDCBrushChanger) | |
960 | }; | |
961 | ||
e26be42b VZ |
962 | // ---------------------------------------------------------------------------- |
963 | // another small helper class: sets the clipping region in its ctor and | |
964 | // destroys it in the dtor | |
965 | // ---------------------------------------------------------------------------- | |
966 | ||
967 | class WXDLLEXPORT wxDCClipper | |
968 | { | |
969 | public: | |
fc298ea7 VZ |
970 | wxDCClipper(wxDC& dc, const wxRegion& r) : m_dc(dc) |
971 | { dc.SetClippingRegion(r); } | |
e26be42b VZ |
972 | wxDCClipper(wxDC& dc, const wxRect& r) : m_dc(dc) |
973 | { dc.SetClippingRegion(r.x, r.y, r.width, r.height); } | |
974 | wxDCClipper(wxDC& dc, wxCoord x, wxCoord y, wxCoord w, wxCoord h) : m_dc(dc) | |
975 | { dc.SetClippingRegion(x, y, w, h); } | |
976 | ||
977 | ~wxDCClipper() { m_dc.DestroyClippingRegion(); } | |
978 | ||
979 | private: | |
980 | wxDC& m_dc; | |
fc7a2a60 VZ |
981 | |
982 | DECLARE_NO_COPY_CLASS(wxDCClipper) | |
e26be42b VZ |
983 | }; |
984 | ||
8b56b16a | 985 | #endif // _WX_DC_H_BASE_ |