+ DECLARE_ABSTRACT_CLASS(wxDCImpl)
+};
+
+
+class WXDLLIMPEXP_CORE wxDC : public wxObject
+{
+public:
+ virtual ~wxDC() { delete m_pimpl; }
+
+ wxDCImpl *GetImpl()
+ { return m_pimpl; }
+ const wxDCImpl *GetImpl() const
+ { return m_pimpl; }
+
+ wxWindow *GetWindow() const
+ { return m_pimpl->GetWindow(); }
+
+ bool IsOk() const
+ { return m_pimpl && m_pimpl->IsOk(); }
+
+ // query capabilities
+
+ bool CanDrawBitmap() const
+ { return m_pimpl->CanDrawBitmap(); }
+ bool CanGetTextExtent() const
+ { return m_pimpl->CanGetTextExtent(); }
+
+ // query dimension, colour deps, resolution
+
+ void GetSize(int *width, int *height) const
+ { m_pimpl->DoGetSize(width, height); }
+ wxSize GetSize() const
+ { return m_pimpl->GetSize(); }
+
+ void GetSizeMM(int* width, int* height) const
+ { m_pimpl->DoGetSizeMM(width, height); }
+ wxSize GetSizeMM() const
+ {
+ int w, h;
+ m_pimpl->DoGetSizeMM(&w, &h);
+ return wxSize(w, h);
+ }
+
+ int GetDepth() const
+ { return m_pimpl->GetDepth(); }
+ wxSize GetPPI() const
+ { return m_pimpl->GetPPI(); }
+
+ virtual int GetResolution() const
+ { return m_pimpl->GetResolution(); }
+
+ // Right-To-Left (RTL) modes
+
+ void SetLayoutDirection(wxLayoutDirection dir)
+ { m_pimpl->SetLayoutDirection( dir ); }
+ wxLayoutDirection GetLayoutDirection() const
+ { return m_pimpl->GetLayoutDirection(); }
+
+ // page and document
+
+ bool StartDoc(const wxString& message)
+ { return m_pimpl->StartDoc(message); }
+ void EndDoc()
+ { m_pimpl->EndDoc(); }
+
+ void StartPage()
+ { m_pimpl->StartPage(); }
+ void EndPage()
+ { m_pimpl->EndPage(); }
+
+ // bounding box
+
+ void CalcBoundingBox(wxCoord x, wxCoord y)
+ { m_pimpl->CalcBoundingBox(x,y); }
+ void ResetBoundingBox()
+ { m_pimpl->ResetBoundingBox(); }
+
+ wxCoord MinX() const
+ { return m_pimpl->MinX(); }
+ wxCoord MaxX() const
+ { return m_pimpl->MaxX(); }
+ wxCoord MinY() const
+ { return m_pimpl->MinY(); }
+ wxCoord MaxY() const
+ { return m_pimpl->MaxY(); }
+
+ // setters and getters
+
+ void SetFont(const wxFont& font)
+ { m_pimpl->SetFont( font ); }
+ const wxFont& GetFont() const
+ { return m_pimpl->GetFont(); }
+
+ void SetPen(const wxPen& pen)
+ { m_pimpl->SetPen( pen ); }
+ const wxPen& GetPen() const
+ { return m_pimpl->GetPen(); }
+
+ void SetBrush(const wxBrush& brush)
+ { m_pimpl->SetBrush( brush ); }
+ const wxBrush& GetBrush() const
+ { return m_pimpl->GetBrush(); }
+
+ void SetBackground(const wxBrush& brush)
+ { m_pimpl->SetBackground( brush ); }
+ const wxBrush& GetBackground() const
+ { return m_pimpl->GetBackground(); }
+
+ void SetBackgroundMode(int mode)
+ { m_pimpl->SetBackgroundMode( mode ); }
+ int GetBackgroundMode() const
+ { return m_pimpl->GetBackgroundMode(); }
+
+ void SetTextForeground(const wxColour& colour)
+ { m_pimpl->SetTextForeground(colour); }
+ const wxColour& GetTextForeground() const
+ { return m_pimpl->GetTextForeground(); }
+
+ void SetTextBackground(const wxColour& colour)
+ { m_pimpl->SetTextBackground(colour); }
+ const wxColour& GetTextBackground() const
+ { return m_pimpl->GetTextBackground(); }
+
+#if wxUSE_PALETTE
+ void SetPalette(const wxPalette& palette)
+ { m_pimpl->SetPalette(palette); }
+#endif // wxUSE_PALETTE
+
+ // logical functions
+
+ void SetLogicalFunction(wxRasterOperationMode function)
+ { m_pimpl->SetLogicalFunction(function); }
+ wxRasterOperationMode GetLogicalFunction() const
+ { return m_pimpl->GetLogicalFunction(); }
+
+ // text measurement
+
+ wxCoord GetCharHeight() const
+ { return m_pimpl->GetCharHeight(); }
+ wxCoord GetCharWidth() const
+ { return m_pimpl->GetCharWidth(); }
+
+ void GetTextExtent(const wxString& string,
+ wxCoord *x, wxCoord *y,
+ wxCoord *descent = NULL,
+ wxCoord *externalLeading = NULL,
+ const wxFont *theFont = NULL) const
+ { m_pimpl->DoGetTextExtent(string, x, y, descent, externalLeading, theFont); }
+
+ wxSize GetTextExtent(const wxString& string) const
+ {
+ wxCoord w, h;
+ m_pimpl->DoGetTextExtent(string, &w, &h);
+ return wxSize(w, h);
+ }
+
+ void GetMultiLineTextExtent(const wxString& string,
+ wxCoord *width,
+ wxCoord *height,
+ wxCoord *heightLine = NULL,
+ const wxFont *font = NULL) const
+ { m_pimpl->GetMultiLineTextExtent( string, width, height, heightLine, font ); }
+
+ wxSize GetMultiLineTextExtent(const wxString& string) const
+ {
+ wxCoord w, h;
+ m_pimpl->GetMultiLineTextExtent(string, &w, &h);
+ return wxSize(w, h);
+ }
+
+ bool GetPartialTextExtents(const wxString& text, wxArrayInt& widths) const
+ { return m_pimpl->DoGetPartialTextExtents(text, widths); }
+
+ // clearing
+
+ void Clear()
+ { m_pimpl->Clear(); }
+
+ // clipping
+
+ void SetClippingRegion(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
+ { m_pimpl->DoSetClippingRegion(x, y, width, height); }
+ void SetClippingRegion(const wxPoint& pt, const wxSize& sz)
+ { m_pimpl->DoSetClippingRegion(pt.x, pt.y, sz.x, sz.y); }
+ void SetClippingRegion(const wxRect& rect)
+ { m_pimpl->DoSetClippingRegion(rect.x, rect.y, rect.width, rect.height); }
+
+ // unlike the functions above, the coordinates of the region used in this
+ // one are in device coordinates, not the logical ones
+ void SetDeviceClippingRegion(const wxRegion& region)
+ { m_pimpl->DoSetDeviceClippingRegion(region); }
+
+ // this function is deprecated because its name is confusing: you may
+ // expect it to work with logical coordinates but, in fact, it does exactly
+ // the same thing as SetDeviceClippingRegion()
+ //
+ // please review the code using it and either replace it with calls to
+ // SetDeviceClippingRegion() or correct it if it was [wrongly] passing
+ // logical coordinates to this function
+ wxDEPRECATED_INLINE(void SetClippingRegion(const wxRegion& region),
+ SetDeviceClippingRegion(region); )
+
+ void DestroyClippingRegion()
+ { m_pimpl->DestroyClippingRegion(); }
+
+ void GetClippingBox(wxCoord *x, wxCoord *y, wxCoord *w, wxCoord *h) const
+ { m_pimpl->DoGetClippingBox(x, y, w, h); }
+ void GetClippingBox(wxRect& rect) const
+ { m_pimpl->DoGetClippingBox(&rect.x, &rect.y, &rect.width, &rect.height); }
+
+ // coordinates conversions and transforms
+
+ wxCoord DeviceToLogicalX(wxCoord x) const
+ { return m_pimpl->DeviceToLogicalX(x); }
+ wxCoord DeviceToLogicalY(wxCoord y) const
+ { return m_pimpl->DeviceToLogicalY(y); }
+ wxCoord DeviceToLogicalXRel(wxCoord x) const
+ { return m_pimpl->DeviceToLogicalXRel(x); }
+ wxCoord DeviceToLogicalYRel(wxCoord y) const
+ { return m_pimpl->DeviceToLogicalYRel(y); }
+ wxCoord LogicalToDeviceX(wxCoord x) const
+ { return m_pimpl->LogicalToDeviceX(x); }
+ wxCoord LogicalToDeviceY(wxCoord y) const
+ { return m_pimpl->LogicalToDeviceY(y); }
+ wxCoord LogicalToDeviceXRel(wxCoord x) const
+ { return m_pimpl->LogicalToDeviceXRel(x); }
+ wxCoord LogicalToDeviceYRel(wxCoord y) const
+ { return m_pimpl->LogicalToDeviceYRel(y); }
+
+ void SetMapMode(wxMappingMode mode)
+ { m_pimpl->SetMapMode(mode); }
+ wxMappingMode GetMapMode() const
+ { return m_pimpl->GetMapMode(); }
+
+ void SetUserScale(double x, double y)
+ { m_pimpl->SetUserScale(x,y); }
+ void GetUserScale(double *x, double *y) const
+ { m_pimpl->GetUserScale( x, y ); }
+
+ void SetLogicalScale(double x, double y)
+ { m_pimpl->SetLogicalScale( x, y ); }
+ void GetLogicalScale(double *x, double *y)
+ { m_pimpl->GetLogicalScale( x, y ); }
+
+ void SetLogicalOrigin(wxCoord x, wxCoord y)
+ { m_pimpl->SetLogicalOrigin(x,y); }
+ void GetLogicalOrigin(wxCoord *x, wxCoord *y) const
+ { m_pimpl->DoGetLogicalOrigin(x, y); }
+ wxPoint GetLogicalOrigin() const
+ { wxCoord x, y; m_pimpl->DoGetLogicalOrigin(&x, &y); return wxPoint(x, y); }
+
+ void SetDeviceOrigin(wxCoord x, wxCoord y)
+ { m_pimpl->SetDeviceOrigin( x, y); }
+ void GetDeviceOrigin(wxCoord *x, wxCoord *y) const
+ { m_pimpl->DoGetDeviceOrigin(x, y); }
+ wxPoint GetDeviceOrigin() const
+ { wxCoord x, y; m_pimpl->DoGetDeviceOrigin(&x, &y); return wxPoint(x, y); }
+
+ void SetAxisOrientation(bool xLeftRight, bool yBottomUp)
+ { m_pimpl->SetAxisOrientation(xLeftRight, yBottomUp); }
+
+ // mostly internal
+ void SetDeviceLocalOrigin( wxCoord x, wxCoord y )
+ { m_pimpl->SetDeviceLocalOrigin( x, y ); }
+
+
+ // draw generic object
+
+ void DrawObject(wxDrawObject* drawobject)
+ {
+ drawobject->Draw(*this);
+ CalcBoundingBox(drawobject->MinX(),drawobject->MinY());
+ CalcBoundingBox(drawobject->MaxX(),drawobject->MaxY());
+ }
+
+ // -----------------------------------------------
+ // the actual drawing API
+
+ bool FloodFill(wxCoord x, wxCoord y, const wxColour& col,
+ wxFloodFillStyle style = wxFLOOD_SURFACE)
+ { return m_pimpl->DoFloodFill(x, y, col, style); }
+ bool FloodFill(const wxPoint& pt, const wxColour& col,
+ wxFloodFillStyle style = wxFLOOD_SURFACE)
+ { return m_pimpl->DoFloodFill(pt.x, pt.y, col, style); }
+
+ // fill the area specified by rect with a radial gradient, starting from
+ // initialColour in the centre of the cercle and fading to destColour.
+ void GradientFillConcentric(const wxRect& rect,
+ const wxColour& initialColour,
+ const wxColour& destColour)
+ { m_pimpl->DoGradientFillConcentric( rect, initialColour, destColour,
+ wxPoint(rect.GetWidth() / 2,
+ rect.GetHeight() / 2)); }
+
+ void GradientFillConcentric(const wxRect& rect,
+ const wxColour& initialColour,
+ const wxColour& destColour,
+ const wxPoint& circleCenter)
+ { m_pimpl->DoGradientFillConcentric(rect, initialColour, destColour, circleCenter); }
+
+ // fill the area specified by rect with a linear gradient
+ void GradientFillLinear(const wxRect& rect,
+ const wxColour& initialColour,
+ const wxColour& destColour,
+ wxDirection nDirection = wxEAST)
+ { m_pimpl->DoGradientFillLinear(rect, initialColour, destColour, nDirection); }
+
+ bool GetPixel(wxCoord x, wxCoord y, wxColour *col) const
+ { return m_pimpl->DoGetPixel(x, y, col); }
+ bool GetPixel(const wxPoint& pt, wxColour *col) const
+ { return m_pimpl->DoGetPixel(pt.x, pt.y, col); }
+
+ void DrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
+ { m_pimpl->DoDrawLine(x1, y1, x2, y2); }
+ void DrawLine(const wxPoint& pt1, const wxPoint& pt2)
+ { m_pimpl->DoDrawLine(pt1.x, pt1.y, pt2.x, pt2.y); }
+
+ void CrossHair(wxCoord x, wxCoord y)
+ { m_pimpl->DoCrossHair(x, y); }
+ void CrossHair(const wxPoint& pt)
+ { m_pimpl->DoCrossHair(pt.x, pt.y); }
+
+ void DrawArc(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2,
+ wxCoord xc, wxCoord yc)
+ { m_pimpl->DoDrawArc(x1, y1, x2, y2, xc, yc); }
+ void DrawArc(const wxPoint& pt1, const wxPoint& pt2, const wxPoint& centre)
+ { m_pimpl->DoDrawArc(pt1.x, pt1.y, pt2.x, pt2.y, centre.x, centre.y); }
+
+ void DrawCheckMark(wxCoord x, wxCoord y,
+ wxCoord width, wxCoord height)
+ { m_pimpl->DoDrawCheckMark(x, y, width, height); }
+ void DrawCheckMark(const wxRect& rect)
+ { m_pimpl->DoDrawCheckMark(rect.x, rect.y, rect.width, rect.height); }
+
+ void DrawEllipticArc(wxCoord x, wxCoord y, wxCoord w, wxCoord h,
+ double sa, double ea)
+ { m_pimpl->DoDrawEllipticArc(x, y, w, h, sa, ea); }
+ void DrawEllipticArc(const wxPoint& pt, const wxSize& sz,
+ double sa, double ea)
+ { m_pimpl->DoDrawEllipticArc(pt.x, pt.y, sz.x, sz.y, sa, ea); }
+
+ void DrawPoint(wxCoord x, wxCoord y)
+ { m_pimpl->DoDrawPoint(x, y); }
+ void DrawPoint(const wxPoint& pt)
+ { m_pimpl->DoDrawPoint(pt.x, pt.y); }
+
+ void DrawLines(int n, wxPoint points[],
+ wxCoord xoffset = 0, wxCoord yoffset = 0)
+ { m_pimpl->DoDrawLines(n, points, xoffset, yoffset); }
+ void DrawLines(const wxPointList *list,
+ wxCoord xoffset = 0, wxCoord yoffset = 0)
+ { m_pimpl->DrawLines( list, xoffset, yoffset ); }
+#if WXWIN_COMPATIBILITY_2_8
+ wxDEPRECATED( void DrawLines(const wxList *list,
+ wxCoord xoffset = 0, wxCoord yoffset = 0) );
+#endif // WXWIN_COMPATIBILITY_2_8
+
+ void DrawPolygon(int n, wxPoint points[],
+ wxCoord xoffset = 0, wxCoord yoffset = 0,
+ wxPolygonFillMode fillStyle = wxODDEVEN_RULE)
+ { m_pimpl->DoDrawPolygon(n, points, xoffset, yoffset, fillStyle); }
+ void DrawPolygon(const wxPointList *list,
+ wxCoord xoffset = 0, wxCoord yoffset = 0,
+ wxPolygonFillMode fillStyle = wxODDEVEN_RULE)
+ { m_pimpl->DrawPolygon( list, xoffset, yoffset, fillStyle ); }
+ void DrawPolyPolygon(int n, int count[], wxPoint points[],
+ wxCoord xoffset = 0, wxCoord yoffset = 0,
+ wxPolygonFillMode fillStyle = wxODDEVEN_RULE)
+ { m_pimpl->DoDrawPolyPolygon(n, count, points, xoffset, yoffset, fillStyle); }
+#if WXWIN_COMPATIBILITY_2_8
+ wxDEPRECATED( void DrawPolygon(const wxList *list,
+ wxCoord xoffset = 0, wxCoord yoffset = 0,
+ wxPolygonFillMode fillStyle = wxODDEVEN_RULE) );
+#endif // WXWIN_COMPATIBILITY_2_8
+
+ void DrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
+ { m_pimpl->DoDrawRectangle(x, y, width, height); }
+ void DrawRectangle(const wxPoint& pt, const wxSize& sz)
+ { m_pimpl->DoDrawRectangle(pt.x, pt.y, sz.x, sz.y); }
+ void DrawRectangle(const wxRect& rect)
+ { m_pimpl->DoDrawRectangle(rect.x, rect.y, rect.width, rect.height); }
+
+ void DrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height,
+ double radius)
+ { m_pimpl->DoDrawRoundedRectangle(x, y, width, height, radius); }
+ void DrawRoundedRectangle(const wxPoint& pt, const wxSize& sz,
+ double radius)
+ { m_pimpl->DoDrawRoundedRectangle(pt.x, pt.y, sz.x, sz.y, radius); }
+ void DrawRoundedRectangle(const wxRect& r, double radius)
+ { m_pimpl->DoDrawRoundedRectangle(r.x, r.y, r.width, r.height, radius); }
+
+ void DrawCircle(wxCoord x, wxCoord y, wxCoord radius)
+ { m_pimpl->DoDrawEllipse(x - radius, y - radius, 2*radius, 2*radius); }
+ void DrawCircle(const wxPoint& pt, wxCoord radius)
+ { m_pimpl->DoDrawEllipse(pt.x - radius, pt.y - radius, 2*radius, 2*radius); }
+
+ void DrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
+ { m_pimpl->DoDrawEllipse(x, y, width, height); }
+ void DrawEllipse(const wxPoint& pt, const wxSize& sz)
+ { m_pimpl->DoDrawEllipse(pt.x, pt.y, sz.x, sz.y); }
+ void DrawEllipse(const wxRect& rect)
+ { m_pimpl->DoDrawEllipse(rect.x, rect.y, rect.width, rect.height); }
+
+ void DrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
+ { m_pimpl->DoDrawIcon(icon, x, y); }
+ void DrawIcon(const wxIcon& icon, const wxPoint& pt)
+ { m_pimpl->DoDrawIcon(icon, pt.x, pt.y); }
+
+ void DrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y,
+ bool useMask = false)
+ { m_pimpl->DoDrawBitmap(bmp, x, y, useMask); }
+ void DrawBitmap(const wxBitmap &bmp, const wxPoint& pt,
+ bool useMask = false)
+ { m_pimpl->DoDrawBitmap(bmp, pt.x, pt.y, useMask); }
+
+ void DrawText(const wxString& text, wxCoord x, wxCoord y)
+ { m_pimpl->DoDrawText(text, x, y); }
+ void DrawText(const wxString& text, const wxPoint& pt)
+ { m_pimpl->DoDrawText(text, pt.x, pt.y); }
+
+ void DrawRotatedText(const wxString& text, wxCoord x, wxCoord y, double angle)
+ { m_pimpl->DoDrawRotatedText(text, x, y, angle); }
+ void DrawRotatedText(const wxString& text, const wxPoint& pt, double angle)
+ { m_pimpl->DoDrawRotatedText(text, pt.x, pt.y, angle); }
+
+ // this version puts both optional bitmap and the text into the given
+ // rectangle and aligns is as specified by alignment parameter; it also
+ // will emphasize the character with the given index if it is != -1 and
+ // return the bounding rectangle if required
+ void DrawLabel(const wxString& text,
+ const wxBitmap& image,
+ const wxRect& rect,
+ int alignment = wxALIGN_LEFT | wxALIGN_TOP,
+ int indexAccel = -1,
+ wxRect *rectBounding = NULL);
+
+ void DrawLabel(const wxString& text, const wxRect& rect,
+ int alignment = wxALIGN_LEFT | wxALIGN_TOP,
+ int indexAccel = -1)
+ { DrawLabel(text, wxNullBitmap, rect, alignment, indexAccel); }
+
+ bool Blit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
+ wxDC *source, wxCoord xsrc, wxCoord ysrc,
+ wxRasterOperationMode rop = wxCOPY, bool useMask = false,
+ wxCoord xsrcMask = wxDefaultCoord, wxCoord ysrcMask = wxDefaultCoord)
+ {
+ return m_pimpl->DoBlit(xdest, ydest, width, height,
+ source, xsrc, ysrc, rop, useMask, xsrcMask, ysrcMask);
+ }
+ bool Blit(const wxPoint& destPt, const wxSize& sz,
+ wxDC *source, const wxPoint& srcPt,
+ wxRasterOperationMode rop = wxCOPY, bool useMask = false,
+ const wxPoint& srcPtMask = wxDefaultPosition)
+ {
+ return m_pimpl->DoBlit(destPt.x, destPt.y, sz.x, sz.y,
+ source, srcPt.x, srcPt.y, rop, useMask, srcPtMask.x, srcPtMask.y);
+ }
+
+ bool StretchBlit(wxCoord dstX, wxCoord dstY,
+ wxCoord dstWidth, wxCoord dstHeight,
+ wxDC *source,
+ wxCoord srcX, wxCoord srcY,
+ wxCoord srcWidth, wxCoord srcHeight,
+ wxRasterOperationMode rop = wxCOPY, bool useMask = false,
+ wxCoord srcMaskX = wxDefaultCoord, wxCoord srcMaskY = wxDefaultCoord)
+ {
+ return m_pimpl->DoStretchBlit(dstX, dstY, dstWidth, dstHeight,
+ source, srcX, srcY, srcWidth, srcHeight, rop, useMask, srcMaskX, srcMaskY);
+ }
+ bool StretchBlit(const wxPoint& dstPt, const wxSize& dstSize,
+ wxDC *source, const wxPoint& srcPt, const wxSize& srcSize,
+ wxRasterOperationMode rop = wxCOPY, bool useMask = false,
+ const wxPoint& srcMaskPt = wxDefaultPosition)
+ {
+ return m_pimpl->DoStretchBlit(dstPt.x, dstPt.y, dstSize.x, dstSize.y,
+ source, srcPt.x, srcPt.y, srcSize.x, srcSize.y, rop, useMask, srcMaskPt.x, srcMaskPt.y);
+ }
+
+ wxBitmap GetAsBitmap(const wxRect *subrect = (const wxRect *) NULL) const
+ {
+ return m_pimpl->DoGetAsBitmap(subrect);
+ }
+
+#if wxUSE_SPLINES
+ void DrawSpline(wxCoord x1, wxCoord y1,
+ wxCoord x2, wxCoord y2,
+ wxCoord x3, wxCoord y3)
+ { m_pimpl->DrawSpline(x1,y1,x2,y2,x3,y3); }
+ void DrawSpline(int n, wxPoint points[])
+ { m_pimpl->DrawSpline(n,points); }
+ void DrawSpline(const wxPointList *points)
+ { m_pimpl->DrawSpline(points); }
+#endif // wxUSE_SPLINES
+
+
+#if WXWIN_COMPATIBILITY_2_8
+ // for compatibility with the old code when wxCoord was long everywhere
+ wxDEPRECATED( void GetTextExtent(const wxString& string,
+ long *x, long *y,
+ long *descent = NULL,
+ long *externalLeading = NULL,
+ const wxFont *theFont = NULL) const );
+ wxDEPRECATED( void GetLogicalOrigin(long *x, long *y) const );
+ wxDEPRECATED( void GetDeviceOrigin(long *x, long *y) const );
+ wxDEPRECATED( void GetClippingBox(long *x, long *y, long *w, long *h) const );
+
+#endif // WXWIN_COMPATIBILITY_2_8
+
+#ifdef __WXMSW__
+ WXHDC GetHDC() const;
+#endif // __WXMSW__
+
+protected:
+ // ctor takes ownership of the pointer
+ wxDC(wxDCImpl *pimpl) : m_pimpl(pimpl) { }
+
+ wxDCImpl * const m_pimpl;
+
+private:
+ DECLARE_ABSTRACT_CLASS(wxDC)
+ DECLARE_NO_COPY_CLASS(wxDC)
projects / wxWidgets.git / blobdiff