1 /////////////////////////////////////////////////////////////////////////////
4 // Author: Vadim Zeitlin
8 // Copyright: (c) wxWidgets team
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 #ifndef _WX_DC_H_BASE_
13 #define _WX_DC_H_BASE_
15 // ----------------------------------------------------------------------------
16 // headers which we must include here
17 // ----------------------------------------------------------------------------
19 #include "wx/object.h" // the base class
21 #include "wx/cursor.h" // we have member variables of these classes
22 #include "wx/font.h" // so we can't do without them
23 #include "wx/colour.h"
24 #include "wx/bitmap.h" // for wxNullBitmap
27 #include "wx/palette.h"
28 #include "wx/list.h" // we use wxList in inline functions
29 #include "wx/dynarray.h"
32 class WXDLLEXPORT wxDC
;
33 class WXDLLEXPORT wxDCBase
;
35 class WXDLLEXPORT wxDrawObject
40 : m_isBBoxValid(false)
41 , m_minX(0), m_minY(0), m_maxX(0), m_maxY(0)
44 virtual ~wxDrawObject() { }
46 virtual void Draw(wxDCBase
&) const { }
48 virtual void CalcBoundingBox(wxCoord x
, wxCoord y
)
52 if ( x
< m_minX
) m_minX
= x
;
53 if ( y
< m_minY
) m_minY
= y
;
54 if ( x
> m_maxX
) m_maxX
= x
;
55 if ( y
> m_maxY
) m_maxY
= y
;
68 void ResetBoundingBox()
70 m_isBBoxValid
= false;
72 m_minX
= m_maxX
= m_minY
= m_maxY
= 0;
75 // Get the final bounding box of the PostScript or Metafile picture.
77 wxCoord
MinX() const { return m_minX
; }
78 wxCoord
MaxX() const { return m_maxX
; }
79 wxCoord
MinY() const { return m_minY
; }
80 wxCoord
MaxY() const { return m_maxY
; }
82 //to define the type of object for derived objects
83 virtual int GetType()=0;
86 //for boundingbox calculation
88 //for boundingbox calculation
89 wxCoord m_minX
, m_minY
, m_maxX
, m_maxY
;
92 // ---------------------------------------------------------------------------
94 // ---------------------------------------------------------------------------
96 // ---------------------------------------------------------------------------
97 // wxDC is the device context - object on which any drawing is done
98 // ---------------------------------------------------------------------------
100 class WXDLLEXPORT wxDCBase
: public wxObject
104 : m_colour(wxColourDisplay())
108 , m_isBBoxValid(false)
109 , m_logicalOriginX(0), m_logicalOriginY(0)
110 , m_deviceOriginX(0), m_deviceOriginY(0)
111 , m_logicalScaleX(1.0), m_logicalScaleY(1.0)
112 , m_userScaleX(1.0), m_userScaleY(1.0)
113 , m_scaleX(1.0), m_scaleY(1.0)
114 , m_signX(1), m_signY(1)
115 , m_minX(0), m_minY(0), m_maxX(0), m_maxY(0)
116 , m_clipX1(0), m_clipY1(0), m_clipX2(0), m_clipY2(0)
117 , m_logicalFunction(wxCOPY
)
118 , m_backgroundMode(wxTRANSPARENT
)
119 , m_mappingMode(wxMM_TEXT
)
122 , m_backgroundBrush(*wxTRANSPARENT_BRUSH
)
123 , m_textForegroundColour(*wxBLACK
)
124 , m_textBackgroundColour(*wxWHITE
)
128 , m_hasCustomPalette(false)
129 #endif // wxUSE_PALETTE
135 virtual ~wxDCBase() { }
137 #if WXWIN_COMPATIBILITY_2_6
138 wxDEPRECATED( virtual void BeginDrawing() );
139 wxDEPRECATED( virtual void EndDrawing() );
140 #endif // WXWIN_COMPATIBILITY_2_6
142 // graphic primitives
143 // ------------------
145 virtual void DrawObject(wxDrawObject
* drawobject
)
147 drawobject
->Draw(*this);
148 CalcBoundingBox(drawobject
->MinX(),drawobject
->MinY());
149 CalcBoundingBox(drawobject
->MaxX(),drawobject
->MaxY());
152 bool FloodFill(wxCoord x
, wxCoord y
, const wxColour
& col
,
153 int style
= wxFLOOD_SURFACE
)
154 { return DoFloodFill(x
, y
, col
, style
); }
155 bool FloodFill(const wxPoint
& pt
, const wxColour
& col
,
156 int style
= wxFLOOD_SURFACE
)
157 { return DoFloodFill(pt
.x
, pt
.y
, col
, style
); }
159 // fill the area specified by rect with a radial gradient, starting from
160 // initialColour in the centre of the cercle and fading to destColour.
161 void GradientFillConcentric(const wxRect
& rect
,
162 const wxColour
& initialColour
,
163 const wxColour
& destColour
)
164 { GradientFillConcentric(rect
, initialColour
, destColour
,
165 wxPoint(rect
.GetWidth() / 2,
166 rect
.GetHeight() / 2)); }
168 void GradientFillConcentric(const wxRect
& rect
,
169 const wxColour
& initialColour
,
170 const wxColour
& destColour
,
171 const wxPoint
& circleCenter
)
172 { DoGradientFillConcentric(rect
, initialColour
, destColour
, circleCenter
); }
174 // fill the area specified by rect with a linear gradient
175 void GradientFillLinear(const wxRect
& rect
,
176 const wxColour
& initialColour
,
177 const wxColour
& destColour
,
178 wxDirection nDirection
= wxEAST
)
179 { DoGradientFillLinear(rect
, initialColour
, destColour
, nDirection
); }
181 bool GetPixel(wxCoord x
, wxCoord y
, wxColour
*col
) const
182 { return DoGetPixel(x
, y
, col
); }
183 bool GetPixel(const wxPoint
& pt
, wxColour
*col
) const
184 { return DoGetPixel(pt
.x
, pt
.y
, col
); }
186 void DrawLine(wxCoord x1
, wxCoord y1
, wxCoord x2
, wxCoord y2
)
187 { DoDrawLine(x1
, y1
, x2
, y2
); }
188 void DrawLine(const wxPoint
& pt1
, const wxPoint
& pt2
)
189 { DoDrawLine(pt1
.x
, pt1
.y
, pt2
.x
, pt2
.y
); }
191 void CrossHair(wxCoord x
, wxCoord y
)
192 { DoCrossHair(x
, y
); }
193 void CrossHair(const wxPoint
& pt
)
194 { DoCrossHair(pt
.x
, pt
.y
); }
196 void DrawArc(wxCoord x1
, wxCoord y1
, wxCoord x2
, wxCoord y2
,
197 wxCoord xc
, wxCoord yc
)
198 { DoDrawArc(x1
, y1
, x2
, y2
, xc
, yc
); }
199 void DrawArc(const wxPoint
& pt1
, const wxPoint
& pt2
, const wxPoint
& centre
)
200 { DoDrawArc(pt1
.x
, pt1
.y
, pt2
.x
, pt2
.y
, centre
.x
, centre
.y
); }
202 void DrawCheckMark(wxCoord x
, wxCoord y
,
203 wxCoord width
, wxCoord height
)
204 { DoDrawCheckMark(x
, y
, width
, height
); }
205 void DrawCheckMark(const wxRect
& rect
)
206 { DoDrawCheckMark(rect
.x
, rect
.y
, rect
.width
, rect
.height
); }
208 void DrawEllipticArc(wxCoord x
, wxCoord y
, wxCoord w
, wxCoord h
,
209 double sa
, double ea
)
210 { DoDrawEllipticArc(x
, y
, w
, h
, sa
, ea
); }
211 void DrawEllipticArc(const wxPoint
& pt
, const wxSize
& sz
,
212 double sa
, double ea
)
213 { DoDrawEllipticArc(pt
.x
, pt
.y
, sz
.x
, sz
.y
, sa
, ea
); }
215 void DrawPoint(wxCoord x
, wxCoord y
)
216 { DoDrawPoint(x
, y
); }
217 void DrawPoint(const wxPoint
& pt
)
218 { DoDrawPoint(pt
.x
, pt
.y
); }
220 void DrawLines(int n
, wxPoint points
[],
221 wxCoord xoffset
= 0, wxCoord yoffset
= 0)
222 { DoDrawLines(n
, points
, xoffset
, yoffset
); }
223 void DrawLines(const wxList
*list
,
224 wxCoord xoffset
= 0, wxCoord yoffset
= 0);
226 void DrawPolygon(int n
, wxPoint points
[],
227 wxCoord xoffset
= 0, wxCoord yoffset
= 0,
228 int fillStyle
= wxODDEVEN_RULE
)
229 { DoDrawPolygon(n
, points
, xoffset
, yoffset
, fillStyle
); }
231 void DrawPolygon(const wxList
*list
,
232 wxCoord xoffset
= 0, wxCoord yoffset
= 0,
233 int fillStyle
= wxODDEVEN_RULE
);
235 void DrawPolyPolygon(int n
, int count
[], wxPoint points
[],
236 wxCoord xoffset
= 0, wxCoord yoffset
= 0,
237 int fillStyle
= wxODDEVEN_RULE
)
238 { DoDrawPolyPolygon(n
, count
, points
, xoffset
, yoffset
, fillStyle
); }
240 void DrawRectangle(wxCoord x
, wxCoord y
, wxCoord width
, wxCoord height
)
241 { DoDrawRectangle(x
, y
, width
, height
); }
242 void DrawRectangle(const wxPoint
& pt
, const wxSize
& sz
)
243 { DoDrawRectangle(pt
.x
, pt
.y
, sz
.x
, sz
.y
); }
244 void DrawRectangle(const wxRect
& rect
)
245 { DoDrawRectangle(rect
.x
, rect
.y
, rect
.width
, rect
.height
); }
247 void DrawRoundedRectangle(wxCoord x
, wxCoord y
, wxCoord width
, wxCoord height
,
249 { DoDrawRoundedRectangle(x
, y
, width
, height
, radius
); }
250 void DrawRoundedRectangle(const wxPoint
& pt
, const wxSize
& sz
,
252 { DoDrawRoundedRectangle(pt
.x
, pt
.y
, sz
.x
, sz
.y
, radius
); }
253 void DrawRoundedRectangle(const wxRect
& r
, double radius
)
254 { DoDrawRoundedRectangle(r
.x
, r
.y
, r
.width
, r
.height
, radius
); }
256 void DrawCircle(wxCoord x
, wxCoord y
, wxCoord radius
)
257 { DoDrawEllipse(x
- radius
, y
- radius
, 2*radius
, 2*radius
); }
258 void DrawCircle(const wxPoint
& pt
, wxCoord radius
)
259 { DrawCircle(pt
.x
, pt
.y
, radius
); }
261 void DrawEllipse(wxCoord x
, wxCoord y
, wxCoord width
, wxCoord height
)
262 { DoDrawEllipse(x
, y
, width
, height
); }
263 void DrawEllipse(const wxPoint
& pt
, const wxSize
& sz
)
264 { DoDrawEllipse(pt
.x
, pt
.y
, sz
.x
, sz
.y
); }
265 void DrawEllipse(const wxRect
& rect
)
266 { DoDrawEllipse(rect
.x
, rect
.y
, rect
.width
, rect
.height
); }
268 void DrawIcon(const wxIcon
& icon
, wxCoord x
, wxCoord y
)
269 { DoDrawIcon(icon
, x
, y
); }
270 void DrawIcon(const wxIcon
& icon
, const wxPoint
& pt
)
271 { DoDrawIcon(icon
, pt
.x
, pt
.y
); }
273 void DrawBitmap(const wxBitmap
&bmp
, wxCoord x
, wxCoord y
,
274 bool useMask
= false)
275 { DoDrawBitmap(bmp
, x
, y
, useMask
); }
276 void DrawBitmap(const wxBitmap
&bmp
, const wxPoint
& pt
,
277 bool useMask
= false)
278 { DoDrawBitmap(bmp
, pt
.x
, pt
.y
, useMask
); }
280 void DrawText(const wxString
& text
, wxCoord x
, wxCoord y
)
281 { DoDrawText(text
, x
, y
); }
282 void DrawText(const wxString
& text
, const wxPoint
& pt
)
283 { DoDrawText(text
, pt
.x
, pt
.y
); }
285 void DrawRotatedText(const wxString
& text
, wxCoord x
, wxCoord y
, double angle
)
286 { DoDrawRotatedText(text
, x
, y
, angle
); }
287 void DrawRotatedText(const wxString
& text
, const wxPoint
& pt
, double angle
)
288 { DoDrawRotatedText(text
, pt
.x
, pt
.y
, angle
); }
290 // this version puts both optional bitmap and the text into the given
291 // rectangle and aligns is as specified by alignment parameter; it also
292 // will emphasize the character with the given index if it is != -1 and
293 // return the bounding rectangle if required
294 virtual void DrawLabel(const wxString
& text
,
295 const wxBitmap
& image
,
297 int alignment
= wxALIGN_LEFT
| wxALIGN_TOP
,
299 wxRect
*rectBounding
= NULL
);
301 void DrawLabel(const wxString
& text
, const wxRect
& rect
,
302 int alignment
= wxALIGN_LEFT
| wxALIGN_TOP
,
304 { DrawLabel(text
, wxNullBitmap
, rect
, alignment
, indexAccel
); }
306 bool Blit(wxCoord xdest
, wxCoord ydest
, wxCoord width
, wxCoord height
,
307 wxDC
*source
, wxCoord xsrc
, wxCoord ysrc
,
308 int rop
= wxCOPY
, bool useMask
= false, wxCoord xsrcMask
= wxDefaultCoord
, wxCoord ysrcMask
= wxDefaultCoord
)
310 return DoBlit(xdest
, ydest
, width
, height
,
311 source
, xsrc
, ysrc
, rop
, useMask
, xsrcMask
, ysrcMask
);
313 bool Blit(const wxPoint
& destPt
, const wxSize
& sz
,
314 wxDC
*source
, const wxPoint
& srcPt
,
315 int rop
= wxCOPY
, bool useMask
= false, const wxPoint
& srcPtMask
= wxDefaultPosition
)
317 return DoBlit(destPt
.x
, destPt
.y
, sz
.x
, sz
.y
,
318 source
, srcPt
.x
, srcPt
.y
, rop
, useMask
, srcPtMask
.x
, srcPtMask
.y
);
322 // TODO: this API needs fixing (wxPointList, why (!const) "wxList *"?)
323 void DrawSpline(wxCoord x1
, wxCoord y1
,
324 wxCoord x2
, wxCoord y2
,
325 wxCoord x3
, wxCoord y3
);
326 void DrawSpline(int n
, wxPoint points
[]);
328 void DrawSpline(wxList
*points
) { DoDrawSpline(points
); }
329 #endif // wxUSE_SPLINES
331 // Eventually we will have wxUSE_GENERIC_DRAWELLIPSE
333 //! Generic method to draw ellipses, circles and arcs with current pen and brush.
334 /*! \param x Upper left corner of bounding box.
335 * \param y Upper left corner of bounding box.
336 * \param w Width of bounding box.
337 * \param h Height of bounding box.
338 * \param sa Starting angle of arc
339 * (counterclockwise, start at 3 o'clock, 360 is full circle).
340 * \param ea Ending angle of arc.
341 * \param angle Rotation angle, the Arc will be rotated after
342 * calculating begin and end.
344 void DrawEllipticArcRot( wxCoord x
, wxCoord y
,
345 wxCoord width
, wxCoord height
,
346 double sa
= 0, double ea
= 0, double angle
= 0 )
347 { DoDrawEllipticArcRot( x
, y
, width
, height
, sa
, ea
, angle
); }
349 void DrawEllipticArcRot( const wxPoint
& pt
,
351 double sa
= 0, double ea
= 0, double angle
= 0 )
352 { DoDrawEllipticArcRot( pt
.x
, pt
.y
, sz
.x
, sz
.y
, sa
, ea
, angle
); }
354 void DrawEllipticArcRot( const wxRect
& rect
,
355 double sa
= 0, double ea
= 0, double angle
= 0 )
356 { DoDrawEllipticArcRot( rect
.x
, rect
.y
, rect
.width
, rect
.height
, sa
, ea
, angle
); }
358 virtual void DoDrawEllipticArcRot( wxCoord x
, wxCoord y
,
359 wxCoord w
, wxCoord h
,
360 double sa
= 0, double ea
= 0, double angle
= 0 );
362 //! Rotates points around center.
363 /*! This is a quite straight method, it calculates in pixels
364 * and so it produces rounding errors.
365 * \param points The points inside will be rotated.
366 * \param angle Rotating angle (counterclockwise, start at 3 o'clock, 360 is full circle).
367 * \param center Center of rotation.
369 void Rotate( wxList
* points
, double angle
, wxPoint center
= wxPoint(0,0) );
371 // used by DrawEllipticArcRot
372 // Careful: wxList gets filled with points you have to delete later.
373 void CalculateEllipticPoints( wxList
* points
,
374 wxCoord xStart
, wxCoord yStart
,
375 wxCoord w
, wxCoord h
,
376 double sa
, double ea
);
379 // global DC operations
380 // --------------------
382 virtual void Clear() = 0;
384 virtual bool StartDoc(const wxString
& WXUNUSED(message
)) { return true; }
385 virtual void EndDoc() { }
387 virtual void StartPage() { }
388 virtual void EndPage() { }
390 // set objects to use for drawing
391 // ------------------------------
393 virtual void SetFont(const wxFont
& font
) = 0;
394 virtual void SetPen(const wxPen
& pen
) = 0;
395 virtual void SetBrush(const wxBrush
& brush
) = 0;
396 virtual void SetBackground(const wxBrush
& brush
) = 0;
397 virtual void SetBackgroundMode(int mode
) = 0;
399 virtual void SetPalette(const wxPalette
& palette
) = 0;
400 #endif // wxUSE_PALETTE
405 void SetClippingRegion(wxCoord x
, wxCoord y
, wxCoord width
, wxCoord height
)
406 { DoSetClippingRegion(x
, y
, width
, height
); }
407 void SetClippingRegion(const wxPoint
& pt
, const wxSize
& sz
)
408 { DoSetClippingRegion(pt
.x
, pt
.y
, sz
.x
, sz
.y
); }
409 void SetClippingRegion(const wxRect
& rect
)
410 { DoSetClippingRegion(rect
.x
, rect
.y
, rect
.width
, rect
.height
); }
411 void SetClippingRegion(const wxRegion
& region
)
412 { DoSetClippingRegionAsRegion(region
); }
414 virtual void DestroyClippingRegion() { ResetClipping(); }
416 void GetClippingBox(wxCoord
*x
, wxCoord
*y
, wxCoord
*w
, wxCoord
*h
) const
417 { DoGetClippingBox(x
, y
, w
, h
); }
418 void GetClippingBox(wxRect
& rect
) const
420 DoGetClippingBox(&rect
.x
, &rect
.y
, &rect
.width
, &rect
.height
);
426 virtual wxCoord
GetCharHeight() const = 0;
427 virtual wxCoord
GetCharWidth() const = 0;
429 // only works for single line strings
430 void GetTextExtent(const wxString
& string
,
431 wxCoord
*x
, wxCoord
*y
,
432 wxCoord
*descent
= NULL
,
433 wxCoord
*externalLeading
= NULL
,
434 wxFont
*theFont
= NULL
) const
435 { DoGetTextExtent(string
, x
, y
, descent
, externalLeading
, theFont
); }
437 // works for single as well as multi-line strings
438 virtual void GetMultiLineTextExtent(const wxString
& text
,
441 wxCoord
*heightLine
= NULL
,
442 wxFont
*font
= NULL
);
444 // Measure cumulative width of text after each character
445 bool GetPartialTextExtents(const wxString
& text
, wxArrayInt
& widths
) const
446 { return DoGetPartialTextExtents(text
, widths
); }
449 // size and resolution
450 // -------------------
453 void GetSize(int *width
, int *height
) const
454 { DoGetSize(width
, height
); }
455 wxSize
GetSize() const
464 void GetSizeMM(int* width
, int* height
) const
465 { DoGetSizeMM(width
, height
); }
466 wxSize
GetSizeMM() const
474 // coordinates conversions
475 // -----------------------
477 // This group of functions does actual conversion of the input, as you'd
479 wxCoord
DeviceToLogicalX(wxCoord x
) const;
480 wxCoord
DeviceToLogicalY(wxCoord y
) const;
481 wxCoord
DeviceToLogicalXRel(wxCoord x
) const;
482 wxCoord
DeviceToLogicalYRel(wxCoord y
) const;
483 wxCoord
LogicalToDeviceX(wxCoord x
) const;
484 wxCoord
LogicalToDeviceY(wxCoord y
) const;
485 wxCoord
LogicalToDeviceXRel(wxCoord x
) const;
486 wxCoord
LogicalToDeviceYRel(wxCoord y
) const;
488 // query DC capabilities
489 // ---------------------
491 virtual bool CanDrawBitmap() const = 0;
492 virtual bool CanGetTextExtent() const = 0;
495 virtual int GetDepth() const = 0;
497 // Resolution in Pixels per inch
498 virtual wxSize
GetPPI() const = 0;
500 virtual bool Ok() const { return IsOk(); }
501 virtual bool IsOk() const { return m_ok
; }
503 // accessors and setters
504 // ---------------------
506 int GetBackgroundMode() const { return m_backgroundMode
; }
507 const wxBrush
& GetBackground() const { return m_backgroundBrush
; }
508 const wxBrush
& GetBrush() const { return m_brush
; }
509 const wxFont
& GetFont() const { return m_font
; }
510 const wxPen
& GetPen() const { return m_pen
; }
512 const wxColour
& GetTextForeground() const { return m_textForegroundColour
; }
513 const wxColour
& GetTextBackground() const { return m_textBackgroundColour
; }
514 virtual void SetTextForeground(const wxColour
& colour
)
515 { m_textForegroundColour
= colour
; }
516 virtual void SetTextBackground(const wxColour
& colour
)
517 { m_textBackgroundColour
= colour
; }
519 int GetMapMode() const { return m_mappingMode
; }
520 virtual void SetMapMode(int mode
) = 0;
522 virtual void GetUserScale(double *x
, double *y
) const
524 if ( x
) *x
= m_userScaleX
;
525 if ( y
) *y
= m_userScaleY
;
527 virtual void SetUserScale(double x
, double y
) = 0;
529 virtual void GetLogicalScale(double *x
, double *y
)
531 if ( x
) *x
= m_logicalScaleX
;
532 if ( y
) *y
= m_logicalScaleY
;
534 virtual void SetLogicalScale(double x
, double y
)
540 void GetLogicalOrigin(wxCoord
*x
, wxCoord
*y
) const
541 { DoGetLogicalOrigin(x
, y
); }
542 wxPoint
GetLogicalOrigin() const
543 { wxCoord x
, y
; DoGetLogicalOrigin(&x
, &y
); return wxPoint(x
, y
); }
544 virtual void SetLogicalOrigin(wxCoord x
, wxCoord y
) = 0;
546 void GetDeviceOrigin(wxCoord
*x
, wxCoord
*y
) const
547 { DoGetDeviceOrigin(x
, y
); }
548 wxPoint
GetDeviceOrigin() const
549 { wxCoord x
, y
; DoGetDeviceOrigin(&x
, &y
); return wxPoint(x
, y
); }
550 virtual void SetDeviceOrigin(wxCoord x
, wxCoord y
) = 0;
552 virtual void ComputeScaleAndOrigin() {}
554 virtual void SetAxisOrientation(bool xLeftRight
, bool yBottomUp
) = 0;
556 int GetLogicalFunction() const { return m_logicalFunction
; }
557 virtual void SetLogicalFunction(int function
) = 0;
559 #if WXWIN_COMPATIBILITY_2_4
560 virtual void SetOptimization(bool WXUNUSED(opt
)) { }
561 virtual bool GetOptimization() { return false; }
567 virtual void CalcBoundingBox(wxCoord x
, wxCoord y
)
571 if ( x
< m_minX
) m_minX
= x
;
572 if ( y
< m_minY
) m_minY
= y
;
573 if ( x
> m_maxX
) m_maxX
= x
;
574 if ( y
> m_maxY
) m_maxY
= y
;
578 m_isBBoxValid
= true;
587 void ResetBoundingBox()
589 m_isBBoxValid
= false;
591 m_minX
= m_maxX
= m_minY
= m_maxY
= 0;
594 // Get the final bounding box of the PostScript or Metafile picture.
595 wxCoord
MinX() const { return m_minX
; }
596 wxCoord
MaxX() const { return m_maxX
; }
597 wxCoord
MinY() const { return m_minY
; }
598 wxCoord
MaxY() const { return m_maxY
; }
600 // misc old functions
601 // ------------------
603 // for compatibility with the old code when wxCoord was long everywhere
604 void GetTextExtent(const wxString
& string
,
606 long *descent
= NULL
,
607 long *externalLeading
= NULL
,
608 wxFont
*theFont
= NULL
) const
610 wxCoord x2
, y2
, descent2
, externalLeading2
;
611 DoGetTextExtent(string
, &x2
, &y2
,
612 &descent2
, &externalLeading2
,
620 if ( externalLeading
)
621 *externalLeading
= externalLeading2
;
624 void GetLogicalOrigin(long *x
, long *y
) const
627 DoGetLogicalOrigin(&x2
, &y2
);
634 void GetDeviceOrigin(long *x
, long *y
) const
637 DoGetDeviceOrigin(&x2
, &y2
);
643 void GetClippingBox(long *x
, long *y
, long *w
, long *h
) const
646 DoGetClippingBox(&xx
, &yy
, &ww
, &hh
);
654 // the pure virtual functions which should be implemented by wxDC
655 virtual bool DoFloodFill(wxCoord x
, wxCoord y
, const wxColour
& col
,
656 int style
= wxFLOOD_SURFACE
) = 0;
658 virtual void DoGradientFillLinear(const wxRect
& rect
,
659 const wxColour
& initialColour
,
660 const wxColour
& destColour
,
661 wxDirection nDirection
= wxEAST
);
663 virtual void DoGradientFillConcentric(const wxRect
& rect
,
664 const wxColour
& initialColour
,
665 const wxColour
& destColour
,
666 const wxPoint
& circleCenter
);
668 virtual bool DoGetPixel(wxCoord x
, wxCoord y
, wxColour
*col
) const = 0;
670 virtual void DoDrawPoint(wxCoord x
, wxCoord y
) = 0;
671 virtual void DoDrawLine(wxCoord x1
, wxCoord y1
, wxCoord x2
, wxCoord y2
) = 0;
673 virtual void DoDrawArc(wxCoord x1
, wxCoord y1
,
674 wxCoord x2
, wxCoord y2
,
675 wxCoord xc
, wxCoord yc
) = 0;
676 virtual void DoDrawCheckMark(wxCoord x
, wxCoord y
,
677 wxCoord width
, wxCoord height
);
678 virtual void DoDrawEllipticArc(wxCoord x
, wxCoord y
, wxCoord w
, wxCoord h
,
679 double sa
, double ea
) = 0;
681 virtual void DoDrawRectangle(wxCoord x
, wxCoord y
, wxCoord width
, wxCoord height
) = 0;
682 virtual void DoDrawRoundedRectangle(wxCoord x
, wxCoord y
,
683 wxCoord width
, wxCoord height
,
685 virtual void DoDrawEllipse(wxCoord x
, wxCoord y
,
686 wxCoord width
, wxCoord height
) = 0;
688 virtual void DoCrossHair(wxCoord x
, wxCoord y
) = 0;
690 virtual void DoDrawIcon(const wxIcon
& icon
, wxCoord x
, wxCoord y
) = 0;
691 virtual void DoDrawBitmap(const wxBitmap
&bmp
, wxCoord x
, wxCoord y
,
692 bool useMask
= false) = 0;
694 virtual void DoDrawText(const wxString
& text
, wxCoord x
, wxCoord y
) = 0;
695 virtual void DoDrawRotatedText(const wxString
& text
,
696 wxCoord x
, wxCoord y
, double angle
) = 0;
698 virtual bool DoBlit(wxCoord xdest
, wxCoord ydest
,
699 wxCoord width
, wxCoord height
,
700 wxDC
*source
, wxCoord xsrc
, wxCoord ysrc
,
701 int rop
= wxCOPY
, bool useMask
= false, wxCoord xsrcMask
= wxDefaultCoord
, wxCoord ysrcMask
= wxDefaultCoord
) = 0;
703 virtual void DoGetSize(int *width
, int *height
) const = 0;
704 virtual void DoGetSizeMM(int* width
, int* height
) const = 0;
706 virtual void DoDrawLines(int n
, wxPoint points
[],
707 wxCoord xoffset
, wxCoord yoffset
) = 0;
708 virtual void DoDrawPolygon(int n
, wxPoint points
[],
709 wxCoord xoffset
, wxCoord yoffset
,
710 int fillStyle
= wxODDEVEN_RULE
) = 0;
711 virtual void DoDrawPolyPolygon(int n
, int count
[], wxPoint points
[],
712 wxCoord xoffset
, wxCoord yoffset
,
715 virtual void DoSetClippingRegionAsRegion(const wxRegion
& region
) = 0;
716 virtual void DoSetClippingRegion(wxCoord x
, wxCoord y
,
717 wxCoord width
, wxCoord height
) = 0;
719 #if WXWIN_COMPATIBILITY_2_4
720 // this was only for confusing people, use DoGetClippingBox only
721 virtual void DoGetClippingRegion(wxCoord
*x
, wxCoord
*y
,
722 wxCoord
*w
, wxCoord
*h
)
723 { DoGetClippingBox(x
, y
, w
, h
); }
726 virtual void DoGetClippingBox(wxCoord
*x
, wxCoord
*y
,
727 wxCoord
*w
, wxCoord
*h
) const
734 *w
= m_clipX2
- m_clipX1
;
736 *h
= m_clipY2
- m_clipY1
;
739 virtual void DoGetLogicalOrigin(wxCoord
*x
, wxCoord
*y
) const
741 if ( x
) *x
= m_logicalOriginX
;
742 if ( y
) *y
= m_logicalOriginY
;
745 virtual void DoGetDeviceOrigin(wxCoord
*x
, wxCoord
*y
) const
747 if ( x
) *x
= m_deviceOriginX
;
748 if ( y
) *y
= m_deviceOriginY
;
751 virtual void DoGetTextExtent(const wxString
& string
,
752 wxCoord
*x
, wxCoord
*y
,
753 wxCoord
*descent
= NULL
,
754 wxCoord
*externalLeading
= NULL
,
755 wxFont
*theFont
= NULL
) const = 0;
757 virtual bool DoGetPartialTextExtents(const wxString
& text
, wxArrayInt
& widths
) const;
760 virtual void DoDrawSpline(wxList
*points
);
764 // unset clipping variables (after clipping region was destroyed)
769 m_clipX1
= m_clipX2
= m_clipY1
= m_clipY2
= 0;
776 bool m_isInteractive
:1;
777 bool m_isBBoxValid
:1;
779 // coordinate system variables
781 // TODO short descriptions of what exactly they are would be nice...
783 wxCoord m_logicalOriginX
, m_logicalOriginY
;
784 wxCoord m_deviceOriginX
, m_deviceOriginY
;
786 double m_logicalScaleX
, m_logicalScaleY
;
787 double m_userScaleX
, m_userScaleY
;
788 double m_scaleX
, m_scaleY
;
790 // Used by SetAxisOrientation() to invert the axes
791 int m_signX
, m_signY
;
793 // bounding and clipping boxes
794 wxCoord m_minX
, m_minY
, m_maxX
, m_maxY
;
795 wxCoord m_clipX1
, m_clipY1
, m_clipX2
, m_clipY2
;
797 int m_logicalFunction
;
798 int m_backgroundMode
;
804 wxBrush m_backgroundBrush
;
805 wxColour m_textForegroundColour
;
806 wxColour m_textBackgroundColour
;
811 bool m_hasCustomPalette
;
812 #endif // wxUSE_PALETTE
815 DECLARE_NO_COPY_CLASS(wxDCBase
)
816 DECLARE_ABSTRACT_CLASS(wxDCBase
)
819 // ----------------------------------------------------------------------------
820 // now include the declaration of wxDC class
821 // ----------------------------------------------------------------------------
823 #if defined(__WXPALMOS__)
824 #include "wx/palmos/dc.h"
825 #elif defined(__WXMSW__)
826 #include "wx/msw/dc.h"
827 #elif defined(__WXMOTIF__)
828 #include "wx/motif/dc.h"
829 #elif defined(__WXGTK20__)
830 #include "wx/gtk/dc.h"
831 #elif defined(__WXGTK__)
832 #include "wx/gtk1/dc.h"
833 #elif defined(__WXX11__)
834 #include "wx/x11/dc.h"
835 #elif defined(__WXMGL__)
836 #include "wx/mgl/dc.h"
837 #elif defined(__WXDFB__)
838 #include "wx/dfb/dc.h"
839 #elif defined(__WXMAC__)
840 #include "wx/mac/dc.h"
841 #elif defined(__WXCOCOA__)
842 #include "wx/cocoa/dc.h"
843 #elif defined(__WXPM__)
844 #include "wx/os2/dc.h"
847 // ----------------------------------------------------------------------------
848 // helper class: you can use it to temporarily change the DC text colour and
849 // restore it automatically when the object goes out of scope
850 // ----------------------------------------------------------------------------
852 class WXDLLEXPORT wxDCTextColourChanger
855 wxDCTextColourChanger(wxDC
& dc
) : m_dc(dc
), m_colFgOld() { }
857 ~wxDCTextColourChanger()
859 if ( m_colFgOld
.Ok() )
860 m_dc
.SetTextForeground(m_colFgOld
);
863 void Set(const wxColour
& col
)
865 if ( !m_colFgOld
.Ok() )
866 m_colFgOld
= m_dc
.GetTextForeground();
867 m_dc
.SetTextForeground(col
);
875 DECLARE_NO_COPY_CLASS(wxDCTextColourChanger
)
878 // ----------------------------------------------------------------------------
879 // helper class: you can use it to temporarily change the DC pen and
880 // restore it automatically when the object goes out of scope
881 // ----------------------------------------------------------------------------
883 class WXDLLEXPORT wxDCPenChanger
886 wxDCPenChanger(wxDC
& dc
, const wxPen
& pen
) : m_dc(dc
), m_penOld(dc
.GetPen())
894 m_dc
.SetPen(m_penOld
);
902 DECLARE_NO_COPY_CLASS(wxDCPenChanger
)
905 // ----------------------------------------------------------------------------
906 // helper class: you can use it to temporarily change the DC brush and
907 // restore it automatically when the object goes out of scope
908 // ----------------------------------------------------------------------------
910 class WXDLLEXPORT wxDCBrushChanger
913 wxDCBrushChanger(wxDC
& dc
, const wxBrush
& brush
) : m_dc(dc
), m_brushOld(dc
.GetBrush())
915 m_dc
.SetBrush(brush
);
920 if ( m_brushOld
.Ok() )
921 m_dc
.SetBrush(m_brushOld
);
929 DECLARE_NO_COPY_CLASS(wxDCBrushChanger
)
932 // ----------------------------------------------------------------------------
933 // another small helper class: sets the clipping region in its ctor and
934 // destroys it in the dtor
935 // ----------------------------------------------------------------------------
937 class WXDLLEXPORT wxDCClipper
940 wxDCClipper(wxDC
& dc
, const wxRegion
& r
) : m_dc(dc
)
941 { dc
.SetClippingRegion(r
); }
942 wxDCClipper(wxDC
& dc
, const wxRect
& r
) : m_dc(dc
)
943 { dc
.SetClippingRegion(r
.x
, r
.y
, r
.width
, r
.height
); }
944 wxDCClipper(wxDC
& dc
, wxCoord x
, wxCoord y
, wxCoord w
, wxCoord h
) : m_dc(dc
)
945 { dc
.SetClippingRegion(x
, y
, w
, h
); }
947 ~wxDCClipper() { m_dc
.DestroyClippingRegion(); }
952 DECLARE_NO_COPY_CLASS(wxDCClipper
)