]>
Commit | Line | Data |
---|---|---|
006162a9 VZ |
1 | ///////////////////////////////////////////////////////////////////////////// |
2 | // Name: dc.h | |
3 | // Purpose: wxDC class | |
4 | // Author: Vadim Zeitlin | |
5 | // Modified by: | |
6 | // Created: 05/25/99 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) wxWindows team | |
9 | // Licence: wxWindows licence | |
10 | ///////////////////////////////////////////////////////////////////////////// | |
11 | ||
34138703 JS |
12 | #ifndef _WX_DC_H_BASE_ |
13 | #define _WX_DC_H_BASE_ | |
c801d85f | 14 | |
12028905 | 15 | #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) |
a23fd0e1 VZ |
16 | #pragma interface "dcbase.h" |
17 | #endif | |
18 | ||
19 | // ---------------------------------------------------------------------------- | |
20 | // headers which we must include here | |
21 | // ---------------------------------------------------------------------------- | |
22 | ||
23 | #include "wx/object.h" // the base class | |
24 | ||
25 | #include "wx/cursor.h" // we have member variables of these classes | |
26 | #include "wx/font.h" // so we can't do without them | |
27 | #include "wx/colour.h" | |
28 | #include "wx/brush.h" | |
29 | #include "wx/pen.h" | |
30 | #include "wx/palette.h" | |
a23fd0e1 VZ |
31 | #include "wx/list.h" // we use wxList in inline functions |
32 | ||
f4515f98 | 33 | class WXDLLEXPORT wxDC; |
aec43716 KH |
34 | class WXDLLEXPORT wxDCBase; |
35 | ||
36 | class WXDLLEXPORT wxDrawObject | |
37 | { | |
38 | public: | |
39 | ||
40 | wxDrawObject() | |
ba161d7e GD |
41 | : m_isBBoxValid(FALSE) |
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 | { | |
60 | m_isBBoxValid = TRUE; | |
61 | ||
62 | m_minX = x; | |
63 | m_minY = y; | |
64 | m_maxX = x; | |
65 | m_maxY = y; | |
66 | } | |
67 | } | |
68 | ||
69 | void ResetBoundingBox() | |
70 | { | |
71 | m_isBBoxValid = FALSE; | |
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 | ||
97 | WXDLLEXPORT_DATA(extern int) wxPageNumber; | |
98 | ||
99 | // --------------------------------------------------------------------------- | |
100 | // wxDC is the device context - object on which any drawing is done | |
101 | // --------------------------------------------------------------------------- | |
102 | ||
103 | class WXDLLEXPORT wxDCBase : public wxObject | |
104 | { | |
a23fd0e1 VZ |
105 | public: |
106 | wxDCBase() | |
ba161d7e GD |
107 | : m_colour(wxColourDisplay()) |
108 | , m_ok(TRUE) | |
109 | , m_clipping(FALSE) | |
110 | , m_isInteractive(0) | |
111 | , m_isBBoxValid(FALSE) | |
112 | , m_logicalOriginX(0), m_logicalOriginY(0) | |
113 | , m_deviceOriginX(0), m_deviceOriginY(0) | |
114 | , m_logicalScaleX(1.0), m_logicalScaleY(1.0) | |
115 | , m_userScaleX(1.0), m_userScaleY(1.0) | |
116 | , m_scaleX(1.0), m_scaleY(1.0) | |
117 | , m_signX(1), m_signY(1) | |
118 | , m_minX(0), m_minY(0), m_maxX(0), m_maxY(0) | |
119 | , m_clipX1(0), m_clipY1(0), m_clipX2(0), m_clipY2(0) | |
120 | , m_logicalFunction(wxCOPY) | |
121 | , m_backgroundMode(wxTRANSPARENT) | |
122 | , m_mappingMode(wxMM_TEXT) | |
123 | , m_pen() | |
124 | , m_brush() | |
125 | , m_backgroundBrush(*wxTRANSPARENT_BRUSH) | |
126 | , m_textForegroundColour(*wxBLACK) | |
127 | , m_textBackgroundColour(*wxWHITE) | |
128 | , m_font() | |
129 | #if wxUSE_PALETTE | |
130 | , m_palette() | |
131 | , m_hasCustomPalette(FALSE) | |
132 | #endif // wxUSE_PALETTE | |
a23fd0e1 | 133 | { |
f6bcfd97 | 134 | ResetBoundingBox(); |
a23fd0e1 VZ |
135 | } |
136 | ||
137 | ~wxDCBase() { } | |
138 | ||
139 | virtual void BeginDrawing() { } | |
140 | virtual void EndDrawing() { } | |
141 | ||
142 | // graphic primitives | |
143 | // ------------------ | |
144 | ||
aec43716 KH |
145 | virtual void DrawObject(wxDrawObject* drawobject) |
146 | { | |
147 | drawobject->Draw(*this); | |
148 | CalcBoundingBox(drawobject->MinX(),drawobject->MinY()); | |
149 | CalcBoundingBox(drawobject->MaxX(),drawobject->MaxY()); | |
150 | } | |
151 | ||
387ebd3e | 152 | bool FloodFill(wxCoord x, wxCoord y, const wxColour& col, |
72cdf4c9 | 153 | int style = wxFLOOD_SURFACE) |
387ebd3e JS |
154 | { return DoFloodFill(x, y, col, style); } |
155 | bool FloodFill(const wxPoint& pt, const wxColour& col, | |
72cdf4c9 | 156 | int style = wxFLOOD_SURFACE) |
387ebd3e | 157 | { return DoFloodFill(pt.x, pt.y, col, style); } |
a23fd0e1 | 158 | |
72cdf4c9 | 159 | bool GetPixel(wxCoord x, wxCoord y, wxColour *col) const |
a23fd0e1 VZ |
160 | { return DoGetPixel(x, y, col); } |
161 | bool GetPixel(const wxPoint& pt, wxColour *col) const | |
162 | { return DoGetPixel(pt.x, pt.y, col); } | |
163 | ||
72cdf4c9 | 164 | void DrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2) |
a23fd0e1 VZ |
165 | { DoDrawLine(x1, y1, x2, y2); } |
166 | void DrawLine(const wxPoint& pt1, const wxPoint& pt2) | |
167 | { DoDrawLine(pt1.x, pt1.y, pt2.x, pt2.y); } | |
168 | ||
72cdf4c9 | 169 | void CrossHair(wxCoord x, wxCoord y) |
a23fd0e1 VZ |
170 | { DoCrossHair(x, y); } |
171 | void CrossHair(const wxPoint& pt) | |
172 | { DoCrossHair(pt.x, pt.y); } | |
173 | ||
72cdf4c9 VZ |
174 | void DrawArc(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, |
175 | wxCoord xc, wxCoord yc) | |
a23fd0e1 VZ |
176 | { DoDrawArc(x1, y1, x2, y2, xc, yc); } |
177 | void DrawArc(const wxPoint& pt1, const wxPoint& pt2, const wxPoint& centre) | |
178 | { DoDrawArc(pt1.x, pt1.y, pt2.x, pt2.y, centre.x, centre.y); } | |
179 | ||
cd9da200 VZ |
180 | void DrawCheckMark(wxCoord x, wxCoord y, |
181 | wxCoord width, wxCoord height) | |
182 | { DoDrawCheckMark(x, y, width, height); } | |
183 | void DrawCheckMark(const wxRect& rect) | |
184 | { DoDrawCheckMark(rect.x, rect.y, rect.width, rect.height); } | |
185 | ||
72cdf4c9 VZ |
186 | void DrawEllipticArc(wxCoord x, wxCoord y, wxCoord w, wxCoord h, |
187 | double sa, double ea) | |
7b90a8f2 | 188 | { DoDrawEllipticArc(x, y, w, h, sa, ea); } |
a23fd0e1 VZ |
189 | void DrawEllipticArc(const wxPoint& pt, const wxSize& sz, |
190 | double sa, double ea) | |
191 | { DoDrawEllipticArc(pt.x, pt.y, sz.x, sz.y, sa, ea); } | |
192 | ||
72cdf4c9 | 193 | void DrawPoint(wxCoord x, wxCoord y) |
a23fd0e1 VZ |
194 | { DoDrawPoint(x, y); } |
195 | void DrawPoint(const wxPoint& pt) | |
196 | { DoDrawPoint(pt.x, pt.y); } | |
197 | ||
72cdf4c9 VZ |
198 | void DrawLines(int n, wxPoint points[], |
199 | wxCoord xoffset = 0, wxCoord yoffset = 0) | |
a23fd0e1 | 200 | { DoDrawLines(n, points, xoffset, yoffset); } |
72cdf4c9 VZ |
201 | void DrawLines(const wxList *list, |
202 | wxCoord xoffset = 0, wxCoord yoffset = 0); | |
a23fd0e1 VZ |
203 | |
204 | void DrawPolygon(int n, wxPoint points[], | |
72cdf4c9 | 205 | wxCoord xoffset = 0, wxCoord yoffset = 0, |
a23fd0e1 VZ |
206 | int fillStyle = wxODDEVEN_RULE) |
207 | { DoDrawPolygon(n, points, xoffset, yoffset, fillStyle); } | |
208 | ||
209 | void DrawPolygon(const wxList *list, | |
72cdf4c9 | 210 | wxCoord xoffset = 0, wxCoord yoffset = 0, |
bd5dd957 | 211 | int fillStyle = wxODDEVEN_RULE); |
a23fd0e1 | 212 | |
72cdf4c9 | 213 | void DrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height) |
a23fd0e1 VZ |
214 | { DoDrawRectangle(x, y, width, height); } |
215 | void DrawRectangle(const wxPoint& pt, const wxSize& sz) | |
216 | { DoDrawRectangle(pt.x, pt.y, sz.x, sz.y); } | |
217 | void DrawRectangle(const wxRect& rect) | |
218 | { DoDrawRectangle(rect.x, rect.y, rect.width, rect.height); } | |
219 | ||
72cdf4c9 | 220 | void DrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height, |
a23fd0e1 VZ |
221 | double radius) |
222 | { DoDrawRoundedRectangle(x, y, width, height, radius); } | |
223 | void DrawRoundedRectangle(const wxPoint& pt, const wxSize& sz, | |
224 | double radius) | |
225 | { DoDrawRoundedRectangle(pt.x, pt.y, sz.x, sz.y, radius); } | |
226 | void DrawRoundedRectangle(const wxRect& r, double radius) | |
227 | { DoDrawRoundedRectangle(r.x, r.y, r.width, r.height, radius); } | |
228 | ||
72cdf4c9 | 229 | void DrawCircle(wxCoord x, wxCoord y, wxCoord radius) |
220af862 | 230 | { DoDrawEllipse(x - radius, y - radius, 2*radius, 2*radius); } |
0371e9a8 | 231 | void DrawCircle(const wxPoint& pt, wxCoord radius) |
b95edd47 | 232 | { DrawCircle(pt.x, pt.y, radius); } |
0371e9a8 | 233 | |
72cdf4c9 | 234 | void DrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height) |
a23fd0e1 VZ |
235 | { DoDrawEllipse(x, y, width, height); } |
236 | void DrawEllipse(const wxPoint& pt, const wxSize& sz) | |
237 | { DoDrawEllipse(pt.x, pt.y, sz.x, sz.y); } | |
238 | void DrawEllipse(const wxRect& rect) | |
239 | { DoDrawEllipse(rect.x, rect.y, rect.width, rect.height); } | |
240 | ||
72cdf4c9 | 241 | void DrawIcon(const wxIcon& icon, wxCoord x, wxCoord y) |
a23fd0e1 VZ |
242 | { DoDrawIcon(icon, x, y); } |
243 | void DrawIcon(const wxIcon& icon, const wxPoint& pt) | |
244 | { DoDrawIcon(icon, pt.x, pt.y); } | |
245 | ||
72cdf4c9 VZ |
246 | void DrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y, |
247 | bool useMask = FALSE) | |
a23fd0e1 VZ |
248 | { DoDrawBitmap(bmp, x, y, useMask); } |
249 | void DrawBitmap(const wxBitmap &bmp, const wxPoint& pt, | |
250 | bool useMask = FALSE) | |
251 | { DoDrawBitmap(bmp, pt.x, pt.y, useMask); } | |
252 | ||
72cdf4c9 | 253 | void DrawText(const wxString& text, wxCoord x, wxCoord y) |
a23fd0e1 VZ |
254 | { DoDrawText(text, x, y); } |
255 | void DrawText(const wxString& text, const wxPoint& pt) | |
256 | { DoDrawText(text, pt.x, pt.y); } | |
257 | ||
95724b1a VZ |
258 | void DrawRotatedText(const wxString& text, wxCoord x, wxCoord y, double angle) |
259 | { DoDrawRotatedText(text, x, y, angle); } | |
260 | void DrawRotatedText(const wxString& text, const wxPoint& pt, double angle) | |
261 | { DoDrawRotatedText(text, pt.x, pt.y, angle); } | |
262 | ||
1e6feb95 VZ |
263 | // this version puts both optional bitmap and the text into the given |
264 | // rectangle and aligns is as specified by alignment parameter; it also | |
265 | // will emphasize the character with the given index if it is != -1 and | |
266 | // return the bounding rectangle if required | |
267 | virtual void DrawLabel(const wxString& text, | |
268 | const wxBitmap& image, | |
269 | const wxRect& rect, | |
270 | int alignment = wxALIGN_LEFT | wxALIGN_TOP, | |
271 | int indexAccel = -1, | |
272 | wxRect *rectBounding = NULL); | |
273 | ||
274 | void DrawLabel(const wxString& text, const wxRect& rect, | |
275 | int alignment = wxALIGN_LEFT | wxALIGN_TOP, | |
276 | int indexAccel = -1) | |
277 | { DrawLabel(text, wxNullBitmap, rect, alignment, indexAccel); } | |
278 | ||
72cdf4c9 VZ |
279 | bool Blit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height, |
280 | wxDC *source, wxCoord xsrc, wxCoord ysrc, | |
0cbff120 | 281 | int rop = wxCOPY, bool useMask = FALSE, wxCoord xsrcMask = -1, wxCoord ysrcMask = -1) |
a23fd0e1 VZ |
282 | { |
283 | return DoBlit(xdest, ydest, width, height, | |
0cbff120 | 284 | source, xsrc, ysrc, rop, useMask, xsrcMask, ysrcMask); |
a23fd0e1 VZ |
285 | } |
286 | bool Blit(const wxPoint& destPt, const wxSize& sz, | |
287 | wxDC *source, const wxPoint& srcPt, | |
0cbff120 | 288 | int rop = wxCOPY, bool useMask = FALSE, const wxPoint& srcPtMask = wxPoint(-1, -1)) |
a23fd0e1 VZ |
289 | { |
290 | return DoBlit(destPt.x, destPt.y, sz.x, sz.y, | |
0cbff120 | 291 | source, srcPt.x, srcPt.y, rop, useMask, srcPtMask.x, srcPtMask.y); |
a23fd0e1 VZ |
292 | } |
293 | ||
294 | #if wxUSE_SPLINES | |
72cdf4c9 VZ |
295 | // TODO: this API needs fixing (wxPointList, why (!const) "wxList *"?) |
296 | void DrawSpline(wxCoord x1, wxCoord y1, | |
297 | wxCoord x2, wxCoord y2, | |
298 | wxCoord x3, wxCoord y3); | |
bd5dd957 | 299 | void DrawSpline(int n, wxPoint points[]); |
a23fd0e1 VZ |
300 | |
301 | void DrawSpline(wxList *points) { DoDrawSpline(points); } | |
302 | #endif // wxUSE_SPLINES | |
303 | ||
12bdd77c JS |
304 | // Eventually we will have wxUSE_GENERIC_DRAWELLIPSE |
305 | #ifdef __WXWINCE__ | |
306 | //! Generic method to draw ellipses, circles and arcs with current pen and brush. | |
307 | /*! \param x Upper left corner of bounding box. | |
308 | * \param y Upper left corner of bounding box. | |
309 | * \param w Width of bounding box. | |
310 | * \param h Height of bounding box. | |
311 | * \param sa Starting angle of arc | |
312 | * (counterclockwise, start at 3 o'clock, 360 is full circle). | |
313 | * \param ea Ending angle of arc. | |
314 | * \param angle Rotation angle, the Arc will be rotated after | |
315 | * calculating begin and end. | |
316 | */ | |
317 | void DrawEllipticArcRot( wxCoord x, wxCoord y, | |
318 | wxCoord width, wxCoord height, | |
319 | double sa = 0, double ea = 0, double angle = 0 ) | |
320 | { DoDrawEllipticArcRot( x, y, width, height, sa, ea, angle ); } | |
321 | ||
322 | void DrawEllipticArcRot( const wxPoint& pt, | |
323 | const wxSize& sz, | |
324 | double sa = 0, double ea = 0, double angle = 0 ) | |
325 | { DoDrawEllipticArcRot( pt.x, pt.y, sz.x, sz.y, sa, ea, angle ); } | |
326 | ||
327 | void DrawEllipticArcRot( const wxRect& rect, | |
328 | double sa = 0, double ea = 0, double angle = 0 ) | |
329 | { DoDrawEllipticArcRot( rect.x, rect.y, rect.width, rect.height, sa, ea, angle ); } | |
330 | ||
331 | virtual void DoDrawEllipticArcRot( wxCoord x, wxCoord y, | |
332 | wxCoord w, wxCoord h, | |
333 | double sa = 0, double ea = 0, double angle = 0 ); | |
334 | ||
335 | //! Rotates points around center. | |
336 | /*! This is a quite straight method, it calculates in pixels | |
337 | * and so it produces rounding errors. | |
338 | * \param points The points inside will be rotated. | |
339 | * \param angle Rotating angle (counterclockwise, start at 3 o'clock, 360 is full circle). | |
340 | * \param center Center of rotation. | |
341 | */ | |
342 | void Rotate( wxList* points, double angle, wxPoint center = wxPoint() ); | |
343 | ||
344 | // used by DrawEllipticArcRot | |
345 | // Careful: wxList gets filled with points you have to delete later. | |
346 | void CalculateEllipticPoints( wxList* points, | |
347 | wxCoord xStart, wxCoord yStart, | |
348 | wxCoord w, wxCoord h, | |
349 | double sa, double ea ); | |
350 | #endif | |
351 | ||
a23fd0e1 VZ |
352 | // global DC operations |
353 | // -------------------- | |
354 | ||
355 | virtual void Clear() = 0; | |
356 | ||
af0bb3b1 VZ |
357 | virtual bool StartDoc(const wxString& WXUNUSED(message)) { return TRUE; } |
358 | virtual void EndDoc() { } | |
a23fd0e1 | 359 | |
af0bb3b1 VZ |
360 | virtual void StartPage() { } |
361 | virtual void EndPage() { } | |
a23fd0e1 VZ |
362 | |
363 | // set objects to use for drawing | |
364 | // ------------------------------ | |
365 | ||
366 | virtual void SetFont(const wxFont& font) = 0; | |
367 | virtual void SetPen(const wxPen& pen) = 0; | |
368 | virtual void SetBrush(const wxBrush& brush) = 0; | |
369 | virtual void SetBackground(const wxBrush& brush) = 0; | |
370 | virtual void SetBackgroundMode(int mode) = 0; | |
d275c7eb | 371 | #if wxUSE_PALETTE |
a23fd0e1 | 372 | virtual void SetPalette(const wxPalette& palette) = 0; |
d275c7eb | 373 | #endif // wxUSE_PALETTE |
a23fd0e1 VZ |
374 | |
375 | // clipping region | |
376 | // --------------- | |
377 | ||
72cdf4c9 | 378 | void SetClippingRegion(wxCoord x, wxCoord y, wxCoord width, wxCoord height) |
a23fd0e1 VZ |
379 | { DoSetClippingRegion(x, y, width, height); } |
380 | void SetClippingRegion(const wxPoint& pt, const wxSize& sz) | |
381 | { DoSetClippingRegion(pt.x, pt.y, sz.x, sz.y); } | |
382 | void SetClippingRegion(const wxRect& rect) | |
383 | { DoSetClippingRegion(rect.x, rect.y, rect.width, rect.height); } | |
384 | void SetClippingRegion(const wxRegion& region) | |
385 | { DoSetClippingRegionAsRegion(region); } | |
386 | ||
387 | virtual void DestroyClippingRegion() = 0; | |
388 | ||
72cdf4c9 | 389 | void GetClippingBox(wxCoord *x, wxCoord *y, wxCoord *w, wxCoord *h) const |
a23fd0e1 VZ |
390 | { DoGetClippingBox(x, y, w, h); } |
391 | void GetClippingBox(wxRect& rect) const | |
8fb3a512 | 392 | { |
ae500232 JS |
393 | #if 1 |
394 | DoGetClippingBox(&rect.x, &rect.y, &rect.width, &rect.height); | |
395 | #else | |
8fb3a512 | 396 | // Necessary to use intermediate variables for 16-bit compilation |
ae500232 | 397 | // REMOVE ME if the above is OK for all current platforms |
8fb3a512 JS |
398 | wxCoord x, y, w, h; |
399 | DoGetClippingBox(&x, &y, &w, &h); | |
400 | rect.x = x; rect.y = y; rect.width = w; rect.height = h; | |
ae500232 | 401 | #endif |
8fb3a512 | 402 | } |
a23fd0e1 VZ |
403 | |
404 | // text extent | |
405 | // ----------- | |
406 | ||
72cdf4c9 VZ |
407 | virtual wxCoord GetCharHeight() const = 0; |
408 | virtual wxCoord GetCharWidth() const = 0; | |
cd9da200 | 409 | |
1e6feb95 | 410 | // only works for single line strings |
72cdf4c9 VZ |
411 | void GetTextExtent(const wxString& string, |
412 | wxCoord *x, wxCoord *y, | |
413 | wxCoord *descent = NULL, | |
414 | wxCoord *externalLeading = NULL, | |
415 | wxFont *theFont = NULL) const | |
416 | { DoGetTextExtent(string, x, y, descent, externalLeading, theFont); } | |
a23fd0e1 | 417 | |
1e6feb95 VZ |
418 | // works for single as well as multi-line strings |
419 | virtual void GetMultiLineTextExtent(const wxString& text, | |
420 | wxCoord *width, | |
421 | wxCoord *height, | |
422 | wxCoord *heightLine = NULL, | |
423 | wxFont *font = NULL); | |
424 | ||
a23fd0e1 VZ |
425 | // size and resolution |
426 | // ------------------- | |
427 | ||
428 | // in device units | |
429 | void GetSize(int *width, int *height) const | |
430 | { DoGetSize(width, height); } | |
431 | wxSize GetSize() const | |
432 | { | |
433 | int w, h; | |
434 | DoGetSize(&w, &h); | |
435 | ||
436 | return wxSize(w, h); | |
437 | } | |
438 | ||
439 | // in mm | |
440 | void GetSizeMM(int* width, int* height) const | |
441 | { DoGetSizeMM(width, height); } | |
442 | wxSize GetSizeMM() const | |
443 | { | |
444 | int w, h; | |
445 | DoGetSizeMM(&w, &h); | |
446 | ||
447 | return wxSize(w, h); | |
448 | } | |
449 | ||
450 | // coordinates conversions | |
451 | // ----------------------- | |
452 | ||
453 | // This group of functions does actual conversion of the input, as you'd | |
454 | // expect. | |
72cdf4c9 VZ |
455 | wxCoord DeviceToLogicalX(wxCoord x) const; |
456 | wxCoord DeviceToLogicalY(wxCoord y) const; | |
457 | wxCoord DeviceToLogicalXRel(wxCoord x) const; | |
458 | wxCoord DeviceToLogicalYRel(wxCoord y) const; | |
459 | wxCoord LogicalToDeviceX(wxCoord x) const; | |
460 | wxCoord LogicalToDeviceY(wxCoord y) const; | |
461 | wxCoord LogicalToDeviceXRel(wxCoord x) const; | |
462 | wxCoord LogicalToDeviceYRel(wxCoord y) const; | |
a23fd0e1 VZ |
463 | |
464 | // query DC capabilities | |
465 | // --------------------- | |
466 | ||
467 | virtual bool CanDrawBitmap() const = 0; | |
468 | virtual bool CanGetTextExtent() const = 0; | |
469 | ||
470 | // colour depth | |
471 | virtual int GetDepth() const = 0; | |
472 | ||
473 | // Resolution in Pixels per inch | |
474 | virtual wxSize GetPPI() const = 0; | |
475 | ||
476 | virtual bool Ok() const { return m_ok; } | |
477 | ||
478 | // accessors | |
479 | // --------- | |
480 | ||
481 | // const... | |
f6bcfd97 | 482 | int GetBackgroundMode() const { return m_backgroundMode; } |
a23fd0e1 VZ |
483 | const wxBrush& GetBackground() const { return m_backgroundBrush; } |
484 | const wxBrush& GetBrush() const { return m_brush; } | |
485 | const wxFont& GetFont() const { return m_font; } | |
486 | const wxPen& GetPen() const { return m_pen; } | |
487 | const wxColour& GetTextBackground() const { return m_textBackgroundColour; } | |
488 | const wxColour& GetTextForeground() const { return m_textForegroundColour; } | |
489 | ||
490 | // ... and non const | |
491 | wxBrush& GetBackground() { return m_backgroundBrush; } | |
492 | wxBrush& GetBrush() { return m_brush; } | |
493 | wxFont& GetFont() { return m_font; } | |
494 | wxPen& GetPen() { return m_pen; } | |
495 | wxColour& GetTextBackground() { return m_textBackgroundColour; } | |
496 | wxColour& GetTextForeground() { return m_textForegroundColour; } | |
497 | ||
498 | virtual void SetTextForeground(const wxColour& colour) | |
499 | { m_textForegroundColour = colour; } | |
500 | virtual void SetTextBackground(const wxColour& colour) | |
501 | { m_textBackgroundColour = colour; } | |
502 | ||
503 | int GetMapMode() const { return m_mappingMode; } | |
504 | virtual void SetMapMode(int mode) = 0; | |
505 | ||
506 | virtual void GetUserScale(double *x, double *y) const | |
507 | { | |
508 | if ( x ) *x = m_userScaleX; | |
509 | if ( y ) *y = m_userScaleY; | |
510 | } | |
511 | virtual void SetUserScale(double x, double y) = 0; | |
512 | ||
a23fd0e1 VZ |
513 | virtual void GetLogicalScale(double *x, double *y) |
514 | { | |
515 | if ( x ) *x = m_logicalScaleX; | |
516 | if ( y ) *y = m_logicalScaleY; | |
517 | } | |
518 | virtual void SetLogicalScale(double x, double y) | |
519 | { | |
520 | m_logicalScaleX = x; | |
521 | m_logicalScaleY = y; | |
522 | } | |
523 | ||
72cdf4c9 | 524 | void GetLogicalOrigin(wxCoord *x, wxCoord *y) const |
a23fd0e1 VZ |
525 | { DoGetLogicalOrigin(x, y); } |
526 | wxPoint GetLogicalOrigin() const | |
72cdf4c9 VZ |
527 | { wxCoord x, y; DoGetLogicalOrigin(&x, &y); return wxPoint(x, y); } |
528 | virtual void SetLogicalOrigin(wxCoord x, wxCoord y) = 0; | |
a23fd0e1 | 529 | |
72cdf4c9 | 530 | void GetDeviceOrigin(wxCoord *x, wxCoord *y) const |
a23fd0e1 VZ |
531 | { DoGetDeviceOrigin(x, y); } |
532 | wxPoint GetDeviceOrigin() const | |
72cdf4c9 VZ |
533 | { wxCoord x, y; DoGetDeviceOrigin(&x, &y); return wxPoint(x, y); } |
534 | virtual void SetDeviceOrigin(wxCoord x, wxCoord y) = 0; | |
a23fd0e1 VZ |
535 | |
536 | virtual void SetAxisOrientation(bool xLeftRight, bool yBottomUp) = 0; | |
537 | ||
538 | int GetLogicalFunction() const { return m_logicalFunction; } | |
539 | virtual void SetLogicalFunction(int function) = 0; | |
540 | ||
541 | // Sometimes we need to override optimization, e.g. if other software is | |
542 | // drawing onto our surface and we can't be sure of who's done what. | |
543 | // | |
544 | // FIXME: is this (still) used? | |
545 | virtual void SetOptimization(bool WXUNUSED(opt)) { } | |
546 | virtual bool GetOptimization() { return FALSE; } | |
547 | ||
548 | // bounding box | |
549 | // ------------ | |
550 | ||
72cdf4c9 | 551 | virtual void CalcBoundingBox(wxCoord x, wxCoord y) |
a23fd0e1 | 552 | { |
f6bcfd97 BP |
553 | if ( m_isBBoxValid ) |
554 | { | |
555 | if ( x < m_minX ) m_minX = x; | |
556 | if ( y < m_minY ) m_minY = y; | |
557 | if ( x > m_maxX ) m_maxX = x; | |
558 | if ( y > m_maxY ) m_maxY = y; | |
559 | } | |
560 | else | |
561 | { | |
562 | m_isBBoxValid = TRUE; | |
563 | ||
564 | m_minX = x; | |
565 | m_minY = y; | |
566 | m_maxX = x; | |
567 | m_maxY = y; | |
568 | } | |
569 | } | |
570 | ||
571 | void ResetBoundingBox() | |
572 | { | |
573 | m_isBBoxValid = FALSE; | |
574 | ||
575 | m_minX = m_maxX = m_minY = m_maxY = 0; | |
a23fd0e1 VZ |
576 | } |
577 | ||
578 | // Get the final bounding box of the PostScript or Metafile picture. | |
72cdf4c9 VZ |
579 | wxCoord MinX() const { return m_minX; } |
580 | wxCoord MaxX() const { return m_maxX; } | |
581 | wxCoord MinY() const { return m_minY; } | |
582 | wxCoord MaxY() const { return m_maxY; } | |
a23fd0e1 VZ |
583 | |
584 | // misc old functions | |
585 | // ------------------ | |
586 | ||
72cdf4c9 VZ |
587 | // for compatibility with the old code when wxCoord was long everywhere |
588 | #ifndef __WIN16__ | |
589 | void GetTextExtent(const wxString& string, | |
590 | long *x, long *y, | |
591 | long *descent = NULL, | |
592 | long *externalLeading = NULL, | |
593 | wxFont *theFont = NULL) const | |
594 | { | |
595 | wxCoord x2, y2, descent2, externalLeading2; | |
596 | DoGetTextExtent(string, &x2, &y2, | |
597 | &descent2, &externalLeading2, | |
598 | theFont); | |
599 | if ( x ) | |
600 | *x = x2; | |
601 | if ( y ) | |
602 | *y = y2; | |
603 | if ( descent ) | |
604 | *descent = descent2; | |
605 | if ( externalLeading ) | |
606 | *externalLeading = externalLeading2; | |
607 | } | |
608 | ||
609 | void GetLogicalOrigin(long *x, long *y) const | |
610 | { | |
611 | wxCoord x2, y2; | |
612 | DoGetLogicalOrigin(&x2, &y2); | |
613 | if ( x ) | |
614 | *x = x2; | |
615 | if ( y ) | |
616 | *y = y2; | |
617 | } | |
618 | ||
619 | void GetDeviceOrigin(long *x, long *y) const | |
620 | { | |
621 | wxCoord x2, y2; | |
622 | DoGetDeviceOrigin(&x2, &y2); | |
623 | if ( x ) | |
624 | *x = x2; | |
625 | if ( y ) | |
626 | *y = y2; | |
627 | } | |
1dd989e1 | 628 | void GetClippingBox(long *x, long *y, long *w, long *h) const |
cd9da200 VZ |
629 | { |
630 | wxCoord xx,yy,ww,hh; | |
631 | DoGetClippingBox(&xx, &yy, &ww, &hh); | |
632 | if (x) *x = xx; | |
633 | if (y) *y = yy; | |
634 | if (w) *w = ww; | |
635 | if (h) *h = hh; | |
1dd989e1 | 636 | } |
72cdf4c9 VZ |
637 | #endif // !Win16 |
638 | ||
a23fd0e1 | 639 | #if WXWIN_COMPATIBILITY |
d275c7eb | 640 | |
a23fd0e1 VZ |
641 | void GetTextExtent(const wxString& string, float *x, float *y, |
642 | float *descent = NULL, float *externalLeading = NULL, | |
643 | wxFont *theFont = NULL, bool use16bit = FALSE) const ; | |
644 | void GetSize(float* width, float* height) const { int w, h; GetSize(& w, & h); *width = w; *height = h; } | |
e30285ab | 645 | void GetSizeMM(float *width, float *height) const { int w, h; GetSizeMM(& w, & h); *width = (float) w; *height = (float) h; } |
d275c7eb | 646 | |
a23fd0e1 VZ |
647 | #endif // WXWIN_COMPATIBILITY |
648 | ||
649 | protected: | |
650 | // the pure virtual functions which should be implemented by wxDC | |
387ebd3e | 651 | virtual bool DoFloodFill(wxCoord x, wxCoord y, const wxColour& col, |
a23fd0e1 VZ |
652 | int style = wxFLOOD_SURFACE) = 0; |
653 | ||
72cdf4c9 | 654 | virtual bool DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const = 0; |
a23fd0e1 | 655 | |
72cdf4c9 VZ |
656 | virtual void DoDrawPoint(wxCoord x, wxCoord y) = 0; |
657 | virtual void DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2) = 0; | |
a23fd0e1 | 658 | |
72cdf4c9 VZ |
659 | virtual void DoDrawArc(wxCoord x1, wxCoord y1, |
660 | wxCoord x2, wxCoord y2, | |
661 | wxCoord xc, wxCoord yc) = 0; | |
cd9da200 VZ |
662 | virtual void DoDrawCheckMark(wxCoord x, wxCoord y, |
663 | wxCoord width, wxCoord height); | |
72cdf4c9 | 664 | virtual void DoDrawEllipticArc(wxCoord x, wxCoord y, wxCoord w, wxCoord h, |
a23fd0e1 VZ |
665 | double sa, double ea) = 0; |
666 | ||
72cdf4c9 VZ |
667 | virtual void DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height) = 0; |
668 | virtual void DoDrawRoundedRectangle(wxCoord x, wxCoord y, | |
669 | wxCoord width, wxCoord height, | |
a23fd0e1 | 670 | double radius) = 0; |
72cdf4c9 VZ |
671 | virtual void DoDrawEllipse(wxCoord x, wxCoord y, |
672 | wxCoord width, wxCoord height) = 0; | |
a23fd0e1 | 673 | |
72cdf4c9 | 674 | virtual void DoCrossHair(wxCoord x, wxCoord y) = 0; |
a23fd0e1 | 675 | |
72cdf4c9 VZ |
676 | virtual void DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y) = 0; |
677 | virtual void DoDrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y, | |
a23fd0e1 VZ |
678 | bool useMask = FALSE) = 0; |
679 | ||
72cdf4c9 | 680 | virtual void DoDrawText(const wxString& text, wxCoord x, wxCoord y) = 0; |
95724b1a VZ |
681 | virtual void DoDrawRotatedText(const wxString& text, |
682 | wxCoord x, wxCoord y, double angle) = 0; | |
a23fd0e1 | 683 | |
72cdf4c9 VZ |
684 | virtual bool DoBlit(wxCoord xdest, wxCoord ydest, |
685 | wxCoord width, wxCoord height, | |
686 | wxDC *source, wxCoord xsrc, wxCoord ysrc, | |
0cbff120 | 687 | int rop = wxCOPY, bool useMask = FALSE, wxCoord xsrcMask = -1, wxCoord ysrcMask = -1) = 0; |
a23fd0e1 VZ |
688 | |
689 | virtual void DoGetSize(int *width, int *height) const = 0; | |
690 | virtual void DoGetSizeMM(int* width, int* height) const = 0; | |
691 | ||
692 | virtual void DoDrawLines(int n, wxPoint points[], | |
72cdf4c9 | 693 | wxCoord xoffset, wxCoord yoffset) = 0; |
a23fd0e1 | 694 | virtual void DoDrawPolygon(int n, wxPoint points[], |
72cdf4c9 | 695 | wxCoord xoffset, wxCoord yoffset, |
a23fd0e1 VZ |
696 | int fillStyle = wxODDEVEN_RULE) = 0; |
697 | ||
698 | virtual void DoSetClippingRegionAsRegion(const wxRegion& region) = 0; | |
72cdf4c9 VZ |
699 | virtual void DoSetClippingRegion(wxCoord x, wxCoord y, |
700 | wxCoord width, wxCoord height) = 0; | |
b0e0d661 VZ |
701 | |
702 | // FIXME are these functions really different? | |
72cdf4c9 VZ |
703 | virtual void DoGetClippingRegion(wxCoord *x, wxCoord *y, |
704 | wxCoord *w, wxCoord *h) | |
b0e0d661 | 705 | { DoGetClippingBox(x, y, w, h); } |
72cdf4c9 VZ |
706 | virtual void DoGetClippingBox(wxCoord *x, wxCoord *y, |
707 | wxCoord *w, wxCoord *h) const | |
a23fd0e1 VZ |
708 | { |
709 | if ( m_clipping ) | |
710 | { | |
711 | if ( x ) *x = m_clipX1; | |
712 | if ( y ) *y = m_clipY1; | |
713 | if ( w ) *w = m_clipX2 - m_clipX1; | |
714 | if ( h ) *h = m_clipY2 - m_clipY1; | |
715 | } | |
716 | else | |
717 | { | |
718 | *x = *y = *w = *h = 0; | |
719 | } | |
720 | } | |
721 | ||
72cdf4c9 | 722 | virtual void DoGetLogicalOrigin(wxCoord *x, wxCoord *y) const |
a23fd0e1 VZ |
723 | { |
724 | if ( x ) *x = m_logicalOriginX; | |
725 | if ( y ) *y = m_logicalOriginY; | |
726 | } | |
727 | ||
72cdf4c9 | 728 | virtual void DoGetDeviceOrigin(wxCoord *x, wxCoord *y) const |
a23fd0e1 VZ |
729 | { |
730 | if ( x ) *x = m_deviceOriginX; | |
731 | if ( y ) *y = m_deviceOriginY; | |
732 | } | |
733 | ||
72cdf4c9 VZ |
734 | virtual void DoGetTextExtent(const wxString& string, |
735 | wxCoord *x, wxCoord *y, | |
736 | wxCoord *descent = NULL, | |
737 | wxCoord *externalLeading = NULL, | |
738 | wxFont *theFont = NULL) const = 0; | |
739 | ||
64698f9a | 740 | #if wxUSE_SPLINES |
fe2e4366 | 741 | virtual void DoDrawSpline(wxList *points); |
64698f9a | 742 | #endif |
a23fd0e1 VZ |
743 | |
744 | protected: | |
745 | // flags | |
746 | bool m_colour:1; | |
747 | bool m_ok:1; | |
748 | bool m_clipping:1; | |
749 | bool m_isInteractive:1; | |
f6bcfd97 | 750 | bool m_isBBoxValid:1; |
a23fd0e1 VZ |
751 | |
752 | // coordinate system variables | |
753 | ||
754 | // TODO short descriptions of what exactly they are would be nice... | |
755 | ||
72cdf4c9 VZ |
756 | wxCoord m_logicalOriginX, m_logicalOriginY; |
757 | wxCoord m_deviceOriginX, m_deviceOriginY; | |
a23fd0e1 VZ |
758 | |
759 | double m_logicalScaleX, m_logicalScaleY; | |
760 | double m_userScaleX, m_userScaleY; | |
761 | double m_scaleX, m_scaleY; | |
762 | ||
763 | // Used by SetAxisOrientation() to invert the axes | |
764 | int m_signX, m_signY; | |
765 | ||
766 | // bounding and clipping boxes | |
72cdf4c9 VZ |
767 | wxCoord m_minX, m_minY, m_maxX, m_maxY; |
768 | wxCoord m_clipX1, m_clipY1, m_clipX2, m_clipY2; | |
a23fd0e1 VZ |
769 | |
770 | int m_logicalFunction; | |
771 | int m_backgroundMode; | |
772 | int m_mappingMode; | |
773 | ||
774 | // GDI objects | |
775 | wxPen m_pen; | |
776 | wxBrush m_brush; | |
777 | wxBrush m_backgroundBrush; | |
778 | wxColour m_textForegroundColour; | |
779 | wxColour m_textBackgroundColour; | |
780 | wxFont m_font; | |
d275c7eb VZ |
781 | |
782 | #if wxUSE_PALETTE | |
a23fd0e1 | 783 | wxPalette m_palette; |
b95edd47 | 784 | bool m_hasCustomPalette; |
d275c7eb | 785 | #endif // wxUSE_PALETTE |
a23fd0e1 VZ |
786 | |
787 | private: | |
ac84e37d | 788 | DECLARE_NO_COPY_CLASS(wxDCBase) |
cd9da200 | 789 | DECLARE_ABSTRACT_CLASS(wxDCBase) |
a23fd0e1 VZ |
790 | }; |
791 | ||
792 | // ---------------------------------------------------------------------------- | |
793 | // now include the declaration of wxDC class | |
794 | // ---------------------------------------------------------------------------- | |
795 | ||
2049ba38 | 796 | #if defined(__WXMSW__) |
a23fd0e1 | 797 | #include "wx/msw/dc.h" |
2049ba38 | 798 | #elif defined(__WXMOTIF__) |
a23fd0e1 | 799 | #include "wx/motif/dc.h" |
2049ba38 | 800 | #elif defined(__WXGTK__) |
a23fd0e1 | 801 | #include "wx/gtk/dc.h" |
83df96d6 JS |
802 | #elif defined(__WXX11__) |
803 | #include "wx/x11/dc.h" | |
1e6feb95 VZ |
804 | #elif defined(__WXMGL__) |
805 | #include "wx/mgl/dc.h" | |
34138703 | 806 | #elif defined(__WXMAC__) |
a23fd0e1 | 807 | #include "wx/mac/dc.h" |
f4515f98 DE |
808 | #elif defined(__WXCOCOA__) |
809 | #include "wx/cocoa/dc.h" | |
1777b9bb DW |
810 | #elif defined(__WXPM__) |
811 | #include "wx/os2/dc.h" | |
c801d85f KB |
812 | #endif |
813 | ||
1e6feb95 VZ |
814 | // ---------------------------------------------------------------------------- |
815 | // helper class: you can use it to temporarily change the DC text colour and | |
816 | // restore it automatically when the object goes out of scope | |
817 | // ---------------------------------------------------------------------------- | |
818 | ||
819 | class WXDLLEXPORT wxDCTextColourChanger | |
820 | { | |
821 | public: | |
ba161d7e | 822 | wxDCTextColourChanger(wxDC& dc) : m_dc(dc), m_colFgOld() { } |
1e6feb95 VZ |
823 | |
824 | ~wxDCTextColourChanger() | |
825 | { | |
826 | if ( m_colFgOld.Ok() ) | |
827 | m_dc.SetTextForeground(m_colFgOld); | |
828 | } | |
829 | ||
830 | void Set(const wxColour& col) | |
831 | { | |
832 | if ( !m_colFgOld.Ok() ) | |
833 | m_colFgOld = m_dc.GetTextForeground(); | |
834 | m_dc.SetTextForeground(col); | |
835 | } | |
836 | ||
837 | private: | |
838 | wxDC& m_dc; | |
839 | ||
840 | wxColour m_colFgOld; | |
fc7a2a60 VZ |
841 | |
842 | DECLARE_NO_COPY_CLASS(wxDCTextColourChanger) | |
1e6feb95 VZ |
843 | }; |
844 | ||
e26be42b VZ |
845 | // ---------------------------------------------------------------------------- |
846 | // another small helper class: sets the clipping region in its ctor and | |
847 | // destroys it in the dtor | |
848 | // ---------------------------------------------------------------------------- | |
849 | ||
850 | class WXDLLEXPORT wxDCClipper | |
851 | { | |
852 | public: | |
853 | wxDCClipper(wxDC& dc, const wxRect& r) : m_dc(dc) | |
854 | { dc.SetClippingRegion(r.x, r.y, r.width, r.height); } | |
855 | wxDCClipper(wxDC& dc, wxCoord x, wxCoord y, wxCoord w, wxCoord h) : m_dc(dc) | |
856 | { dc.SetClippingRegion(x, y, w, h); } | |
857 | ||
858 | ~wxDCClipper() { m_dc.DestroyClippingRegion(); } | |
859 | ||
860 | private: | |
861 | wxDC& m_dc; | |
fc7a2a60 VZ |
862 | |
863 | DECLARE_NO_COPY_CLASS(wxDCClipper) | |
e26be42b VZ |
864 | }; |
865 | ||
c801d85f | 866 | #endif |
34138703 | 867 | // _WX_DC_H_BASE_ |