public:
wxDCFactory() {}
virtual ~wxDCFactory() {}
-
+
virtual wxDCImpl* CreateWindowDC( wxWindowDC *owner ) = 0;
virtual wxDCImpl* CreateWindowDC( wxWindowDC *owner, wxWindow *window ) = 0;
virtual wxDCImpl* CreateClientDC( wxClientDC *owner ) = 0;
#if wxUSE_PRINTING_ARCHITECTURE
virtual wxDCImpl* CreatePrinterDC( wxPrinterDC *owner, const wxPrintData &data ) = 0;
#endif
-
+
static void SetDCFactory( wxDCFactory *factory );
- static wxDCFactory *GetFactory();
+ static wxDCFactory *Get();
+
private:
static wxDCFactory *m_factory;
};
{
public:
wxNativeDCFactory() {}
-
+
virtual wxDCImpl* CreateWindowDC( wxWindowDC *owner );
virtual wxDCImpl* CreateWindowDC( wxWindowDC *owner, wxWindow *window );
virtual wxDCImpl* CreateClientDC( wxClientDC *owner );
public:
wxDCImpl( wxDC *owner );
~wxDCImpl();
-
+
wxDC *GetOwner() const { return m_owner; }
-
+
wxWindow* GetWindow() const { return m_window; }
-
+
virtual bool IsOk() const { return m_ok; }
// query capabilities
virtual void DoGetSize(int *width, int *height) const = 0;
virtual void DoGetSizeMM(int* width, int* height) const = 0;
-
+
virtual int GetDepth() const = 0;
virtual wxSize GetPPI() const = 0;
-
+
// Right-To-Left (RTL) modes
-
+
virtual void SetLayoutDirection(wxLayoutDirection WXUNUSED(dir)) { }
virtual wxLayoutDirection GetLayoutDirection() const { return wxLayout_Default; }
-
- // page and document
-
+
+ // page and document
+
virtual bool StartDoc(const wxString& WXUNUSED(message)) { return true; }
virtual void EndDoc() { }
wxCoord MaxX() const { return m_maxX; }
wxCoord MinY() const { return m_minY; }
wxCoord MaxY() const { return m_maxY; }
-
+
// setters and getters
virtual void SetFont(const wxFont& font) = 0;
virtual const wxFont& GetFont() const { return m_font; }
-
+
virtual void SetPen(const wxPen& pen) = 0;
virtual const wxPen& GetPen() const { return m_pen; }
-
+
virtual void SetBrush(const wxBrush& brush) = 0;
virtual const wxBrush& GetBrush() const { return m_brush; }
-
+
virtual void SetBackground(const wxBrush& brush) = 0;
virtual const wxBrush& GetBackground() const { return m_backgroundBrush; }
-
+
virtual void SetBackgroundMode(int mode) = 0;
virtual int GetBackgroundMode() const { return m_backgroundMode; }
virtual void SetTextForeground(const wxColour& colour)
{ m_textForegroundColour = colour; }
virtual const wxColour& GetTextForeground() const { return m_textForegroundColour; }
-
+
virtual void SetTextBackground(const wxColour& colour)
{ m_textBackgroundColour = colour; }
virtual const wxColour& GetTextBackground() const { return m_textBackgroundColour; }
#endif // wxUSE_PALETTE
// logical functions
-
+
virtual void SetLogicalFunction(int function) = 0;
virtual int GetLogicalFunction() const { return m_logicalFunction; }
wxCoord *heightLine = NULL,
const wxFont *font = NULL) const;
virtual bool DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const;
-
+
// clearing
-
+
virtual void Clear() = 0;
// clipping
if ( x ) *x = m_deviceOriginX;
if ( y ) *y = m_deviceOriginY;
}
-
+
virtual void SetDeviceLocalOrigin( wxCoord x, wxCoord y );
virtual void ComputeScaleAndOrigin();
wxCoord xoffset, wxCoord yoffset ) = 0;
virtual void DrawLines(const wxPointList *list,
wxCoord xoffset, wxCoord yoffset );
-
+
virtual void DoDrawPolygon(int n, wxPoint points[],
wxCoord xoffset, wxCoord yoffset,
int fillStyle = wxODDEVEN_RULE) = 0;
virtual void DoDrawSpline(int n, wxPoint points[]);
virtual void DoDrawSpline(const wxPointList *points);
#endif
-
+
// ---------------------------------------------------------
// wxMemoryDC Impl API
virtual void DoSelect(const wxBitmap& WXUNUSED(bmp))
{ }
-
+
virtual const wxBitmap& GetSelectedBitmap() const
{ return wxNullBitmap; }
virtual wxBitmap& GetSelectedBitmap()
{ return wxNullBitmap; }
-
+
// ---------------------------------------------------------
// wxPrinterDC Impl API
virtual wxRect GetPaperRect()
{ int w = 0; int h = 0; DoGetSize( &w, &h ); return wxRect(0,0,w,h); }
-
+
virtual int GetResolution()
{ return -1; }
private:
wxDC *m_owner;
-protected:
+protected:
// unset clipping variables (after clipping region was destroyed)
void ResetClipping()
{
// window on which the DC draws or NULL
wxWindow *m_window;
-
+
// flags
bool m_colour:1;
bool m_ok:1;
wxCoord m_logicalOriginX, m_logicalOriginY;
wxCoord m_deviceOriginX, m_deviceOriginY; // Usually 0,0, can be change by user
-
+
wxCoord m_deviceLocalOriginX, m_deviceLocalOriginY; // non-zero if native top-left corner
// is not at 0,0. This was the case under
// Mac's GrafPorts (coordinate system
double m_scaleX, m_scaleY; // calculated from logical scale and user scale
int m_signX, m_signY; // Used by SetAxisOrientation() to invert the axes
-
+
// what is a mm on a screen you don't know the size of?
double m_mm_to_pix_x,
m_mm_to_pix_y;
-
+
// bounding and clipping boxes
wxCoord m_minX, m_minY, m_maxX, m_maxY;
wxCoord m_clipX1, m_clipY1, m_clipX2, m_clipY2;
};
-class WXDLLIMPEXP_CORE wxDC: public wxObject
+class WXDLLIMPEXP_CORE wxDC : public wxObject
{
public:
- wxDC() { m_pimpl = NULL; }
- ~wxDC() { if (m_pimpl) delete m_pimpl; }
+ virtual ~wxDC() { delete m_pimpl; }
wxDCImpl *GetImpl()
{ return m_pimpl; }
wxWindow *GetWindow()
{ return m_pimpl->GetWindow(); }
- bool IsOk() const
+ bool IsOk() const
{ return m_pimpl && m_pimpl->IsOk(); }
// query capabilities
- bool CanDrawBitmap() const
+ 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
{
int w, h;
m_pimpl->DoGetSizeMM(&w, &h);
return wxSize(w, h);
}
-
+
int GetDepth() const
{ return m_pimpl->GetDepth(); }
wxSize GetPPI() const
virtual int GetResolution()
{ 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
-
+
+ // page and document
+
bool StartDoc(const wxString& message)
{ return m_pimpl->StartDoc(message); }
void EndDoc()
{ 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->MinY(); }
wxCoord MaxY() const
{ return m_pimpl->MaxY(); }
-
+
// setters and getters
void SetFont(const wxFont& font)
{ m_pimpl->SetFont( font ); }
- const wxFont& GetFont() const
+ const wxFont& GetFont() const
{ return m_pimpl->GetFont(); }
-
+
void SetPen(const wxPen& pen)
{ m_pimpl->SetPen( pen ); }
- const wxPen& GetPen() const
+ 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
{ 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
+ 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(int function)
{ m_pimpl->SetLogicalFunction(function); }
int 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,
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(); }
{ 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
void SetAxisOrientation(bool xLeftRight, bool yBottomUp)
{ m_pimpl->SetAxisOrientation(xLeftRight, yBottomUp); }
-
- // mostly internal
+
+ // mostly internal
void SetDeviceLocalOrigin( wxCoord x, wxCoord y )
{ m_pimpl->SetDeviceLocalOrigin( x, y ); }
{ m_pimpl->DoDrawLines(n, points, xoffset, yoffset); }
void DrawLines(const wxPointList *list,
wxCoord xoffset = 0, wxCoord yoffset = 0)
- { m_pimpl->DrawLines( list, xoffset, yoffset ); }
+ { m_pimpl->DrawLines( list, xoffset, yoffset ); }
#if WXWIN_COMPATIBILITY_2_8
wxDEPRECATED( void DrawLines(const wxList *list,
wxCoord xoffset = 0, wxCoord yoffset = 0) );
source, srcPt.x, srcPt.y, rop, useMask, srcPtMask.x, srcPtMask.y);
}
- bool StretchBlit(wxCoord dstX, wxCoord dstY,
+ bool StretchBlit(wxCoord dstX, wxCoord dstY,
wxCoord dstWidth, wxCoord dstHeight,
- wxDC *source,
+ wxDC *source,
wxCoord srcX, wxCoord srcY,
wxCoord srcWidth, wxCoord srcHeight,
- int rop = wxCOPY, bool useMask = false,
+ int rop = wxCOPY, bool useMask = false,
wxCoord srcMaskX = wxDefaultCoord, wxCoord srcMaskY = wxDefaultCoord)
{
return m_pimpl->DoStretchBlit(dstX, dstY, dstWidth, dstHeight,
{ m_pimpl->DoDrawSpline(x1,y1,x2,y2,x3,y3); }
void DrawSpline(int n, wxPoint points[])
{ m_pimpl->DoDrawSpline(n,points); }
- void DrawSpline(const wxPointList *points)
+ void DrawSpline(const wxPointList *points)
{ m_pimpl->DoDrawSpline(points); }
#endif // wxUSE_SPLINES
protected:
- wxDCImpl *m_pimpl;
+ // 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)
};
// ----------------------------------------------------------------------------
// Name: wx/dcclient.h
// Purpose: wxClientDC base header
// Author: Julian Smart
-// Modified by:
-// Created:
// Copyright: (c) Julian Smart
// RCS-ID: $Id$
// Licence: wxWindows Licence
class WXDLLIMPEXP_CORE wxWindowDC : public wxDC
{
public:
- wxWindowDC();
- wxWindowDC( wxWindow *win );
+ wxWindowDC(wxWindow *win);
+
+protected:
+ wxWindowDC(wxDCImpl *impl) : wxDC(impl) { }
private:
- DECLARE_DYNAMIC_CLASS(wxWindowDC)
+ DECLARE_ABSTRACT_CLASS(wxWindowDC)
};
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxClientDC : public wxWindowDC
{
public:
- wxClientDC();
- wxClientDC( wxWindow *win );
+ wxClientDC(wxWindow *win);
+
+protected:
+ wxClientDC(wxDCImpl *impl) : wxWindowDC(impl) { }
private:
- DECLARE_DYNAMIC_CLASS(wxClientDC)
+ DECLARE_ABSTRACT_CLASS(wxClientDC)
};
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxPaintDC : public wxClientDC
{
public:
- wxPaintDC();
- wxPaintDC( wxWindow *win );
+ wxPaintDC(wxWindow *win);
+
+protected:
+ wxPaintDC(wxDCImpl *impl) : wxClientDC(impl) { }
private:
- DECLARE_DYNAMIC_CLASS(wxPaintDC)
+ DECLARE_ABSTRACT_CLASS(wxPaintDC)
};
-#endif
- // _WX_DCCLIENT_H_BASE_
+#endif // _WX_DCCLIENT_H_BASE_
// wxMirrorDC allows to write the same code for horz/vertical layout
// ----------------------------------------------------------------------------
-class WXDLLEXPORT wxMirrorDC : public wxDC
+class WXDLLEXPORT wxMirrorDCImpl : public wxDCImpl
{
public:
// constructs a mirror DC associated with the given real DC
// if mirror parameter is true, all vertical and horizontal coordinates are
// exchanged, otherwise this class behaves in exactly the same way as a
// plain DC
- //
- // the cast to wxMirrorDC is a dirty hack done to allow us to call the
- // protected methods of wxDCBase directly in our code below, without it it
- // would be impossible (this is correct from C++ point of view but doesn't
- // make any sense in this particular situation)
- wxMirrorDC(wxDC& dc, bool mirror) : m_dc((wxMirrorDC&)dc)
- { m_mirror = mirror; }
+ wxMirrorDCImpl(wxDC *owner, wxDCImpl& dc, bool mirror)
+ : wxDCImpl(owner),
+ m_dc(dc)
+ {
+ m_mirror = mirror;
+ }
// wxDCBase operations
virtual void Clear() { m_dc.Clear(); }
virtual bool CanGetTextExtent() const { return m_dc.CanGetTextExtent(); }
virtual int GetDepth() const { return m_dc.GetDepth(); }
virtual wxSize GetPPI() const { return m_dc.GetPPI(); }
- virtual bool Ok() const { return IsOk(); }
- virtual bool IsOk() const { return m_dc.Ok(); }
+ virtual bool IsOk() const { return m_dc.IsOk(); }
virtual void SetMapMode(int mode) { m_dc.SetMapMode(mode); }
virtual void SetUserScale(double x, double y)
{ m_dc.SetUserScale(GetX(x, y), GetY(x, y)); }
virtual void SetLogicalFunction(int function)
{ m_dc.SetLogicalFunction(function); }
- // helper functions which may be useful for the users of this class
- wxSize Reflect(const wxSize& sizeOrig)
- {
- return m_mirror ? wxSize(sizeOrig.y, sizeOrig.x) : sizeOrig;
- }
-
protected:
// returns x and y if not mirroring or y and x if mirroring
wxCoord GetX(wxCoord x, wxCoord y) const { return m_mirror ? y : x; }
}
private:
- wxMirrorDC& m_dc;
+ wxDCImpl& m_dc;
+
+ bool m_mirror;
+
+ DECLARE_NO_COPY_CLASS(wxMirrorDCImpl)
+};
+class WXDLLEXPORT wxMirrorDC : public wxDC
+{
+public:
+ wxMirrorDC(wxDC& dc, bool mirror)
+ : wxDC(new wxMirrorDCImpl(this, *dc.GetImpl(), mirror))
+ {
+ m_mirror = mirror;
+ }
+
+ // helper functions which may be useful for the users of this class
+ wxSize Reflect(const wxSize& sizeOrig)
+ {
+ return m_mirror ? wxSize(sizeOrig.y, sizeOrig.x) : sizeOrig;
+ }
+
+private:
bool m_mirror;
DECLARE_NO_COPY_CLASS(wxMirrorDC)
public:
wxPrinterDC();
wxPrinterDC(const wxPrintData& data);
- virtual ~wxPrinterDC();
wxRect GetPaperRect();
int GetResolution();
+protected:
+ wxPrinterDC(wxDCImpl *impl) : wxDC(impl) { }
+
private:
DECLARE_DYNAMIC_CLASS(wxPrinterDC)
};
class WXDLLIMPEXP_CORE wxSVGFileDC : public wxDC
{
public:
- wxSVGFileDC( const wxString &filename,
- int width=320, int height=240, double dpi=72.0 )
+ wxSVGFileDC(const wxString& filename,
+ int width = 320,
+ int height = 240,
+ double dpi = 72.0)
+ : wxDC(new wxSVGFileDCImpl(this, filename, width, height, dpi))
{
- m_pimpl = new wxSVGFileDCImpl( this, filename, width, height, dpi );
}
};
virtual void SetLogicalOrigin(wxCoord x, wxCoord y);
virtual void SetDeviceOrigin(wxCoord x, wxCoord y);
virtual void SetAxisOrientation(bool xLeftRight, bool yBottomUp);
-
+
virtual void SetLogicalFunction(int function);
// implementation from now on
virtual void DoDrawPolyPolygon(int n, int count[], wxPoint points[],
wxCoord xoffset, wxCoord yoffset,
int fillStyle = wxODDEVEN_RULE);
- virtual wxBitmap DoGetAsBitmap(const wxRect *subrect) const
- { return subrect == NULL ? GetSelectedBitmap() : GetSelectedBitmap().GetSubBitmap(*subrect); }
+ virtual wxBitmap DoGetAsBitmap(const wxRect *subrect) const
+ {
+ return subrect == NULL ? GetSelectedBitmap()
+ : GetSelectedBitmap().GetSubBitmap(*subrect);
+ }
#if wxUSE_PALETTE
// only/mainly)
// ----------------------------------------------------------------------------
-class WXDLLEXPORT wxDCTempImpl: public wxMSWDCImpl
+class WXDLLEXPORT wxDCTempImpl : public wxMSWDCImpl
{
public:
// construct a temporary DC with the specified HDC and size (it should be
DECLARE_NO_COPY_CLASS(wxDCTempImpl)
};
-class WXDLLEXPORT wxDCTemp: public wxDC
+class WXDLLEXPORT wxDCTemp : public wxDC
{
public:
- wxDCTemp( WXHDC hdc, const wxSize& size = wxDefaultSize )
+ wxDCTemp(WXHDC hdc, const wxSize& size = wxDefaultSize)
+ : wxDC(new wxDCTempImpl(this, hdc, size))
{
- m_pimpl = new wxDCTempImpl( this, hdc, size );
}
-
};
-
-
#endif // _WX_MSW_DC_H_
{
public:
wxPrinterDCFromHDC( WXHDC theDC )
+ : wxPrinterDC(new wxPrinterDCImpl(this, theDC))
{
- m_pimpl = new wxPrinterDCImpl( this, theDC );
}
};
wxDCFactory::m_factory = factory;
}
-wxDCFactory *wxDCFactory::GetFactory()
+wxDCFactory *wxDCFactory::Get()
{
if (!wxDCFactory::m_factory)
wxDCFactory::m_factory = new wxNativeDCFactory;
//-----------------------------------------------------------------------------
wxDCImpl* wxNativeDCFactory::CreateWindowDC( wxWindowDC *owner )
-{
+{
return new wxWindowDCImpl( owner );
}
wxDCImpl* wxNativeDCFactory::CreateWindowDC( wxWindowDC *owner, wxWindow *window )
-{
+{
return new wxWindowDCImpl( owner, window );
}
// wxWindowDC
//-----------------------------------------------------------------------------
-IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
-
-wxWindowDC::wxWindowDC()
-{
-}
+IMPLEMENT_ABSTRACT_CLASS(wxWindowDC, wxDC)
-wxWindowDC::wxWindowDC( wxWindow *win )
+wxWindowDC::wxWindowDC(wxWindow *win)
+ : wxDC(wxDCFactory::Get()->CreateWindowDC(this, win))
{
- wxDCFactory *factory = wxDCFactory::GetFactory();
- m_pimpl = factory->CreateWindowDC( this, win );
}
//-----------------------------------------------------------------------------
// wxClientDC
//-----------------------------------------------------------------------------
-IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxWindowDC)
+IMPLEMENT_ABSTRACT_CLASS(wxClientDC, wxWindowDC)
-wxClientDC::wxClientDC()
+wxClientDC::wxClientDC(wxWindow *win)
+ : wxWindowDC(wxDCFactory::Get()->CreateClientDC(this, win))
{
}
-wxClientDC::wxClientDC( wxWindow *win )
-{
- wxDCFactory *factory = wxDCFactory::GetFactory();
- m_pimpl = factory->CreateClientDC( this, win );
-}
-
//-----------------------------------------------------------------------------
// wxMemoryDC
//-----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxMemoryDC, wxDC)
wxMemoryDC::wxMemoryDC()
+ : wxDC(wxDCFactory::Get()->CreateMemoryDC(this))
{
- wxDCFactory *factory = wxDCFactory::GetFactory();
- m_pimpl = factory->CreateMemoryDC( this );
}
-wxMemoryDC::wxMemoryDC( wxBitmap& bitmap )
+wxMemoryDC::wxMemoryDC(wxBitmap& bitmap)
+ : wxDC(wxDCFactory::Get()->CreateMemoryDC(this, bitmap))
{
- wxDCFactory *factory = wxDCFactory::GetFactory();
- m_pimpl = factory->CreateMemoryDC( this, bitmap );
}
-wxMemoryDC::wxMemoryDC( wxDC *dc )
+wxMemoryDC::wxMemoryDC(wxDC *dc)
+ : wxDC(wxDCFactory::Get()->CreateMemoryDC(this, dc))
{
- wxDCFactory *factory = wxDCFactory::GetFactory();
- m_pimpl = factory->CreateMemoryDC( this, dc );
}
void wxMemoryDC::SelectObject(wxBitmap& bmp)
return GetImpl()->GetSelectedBitmap();
}
-
+
//-----------------------------------------------------------------------------
// wxPaintDC
//-----------------------------------------------------------------------------
-IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxClientDC)
+IMPLEMENT_ABSTRACT_CLASS(wxPaintDC, wxClientDC)
-wxPaintDC::wxPaintDC()
+wxPaintDC::wxPaintDC(wxWindow *win)
+ : wxClientDC(wxDCFactory::Get()->CreatePaintDC(this, win))
{
}
-wxPaintDC::wxPaintDC( wxWindow *win )
-{
- wxDCFactory *factory = wxDCFactory::GetFactory();
- m_pimpl = factory->CreatePaintDC( this, win );
-}
-
//-----------------------------------------------------------------------------
// wxScreenDC
//-----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxScreenDC, wxWindowDC)
wxScreenDC::wxScreenDC()
+ : wxDC(wxDCFactory::Get()->CreateScreenDC(this))
{
- wxDCFactory *factory = wxDCFactory::GetFactory();
- m_pimpl = factory->CreateScreenDC( this );
}
//-----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxPrinterDC, wxDC)
wxPrinterDC::wxPrinterDC()
+ : wxDC(wxDCFactory::Get()->CreatePrinterDC(this, wxPrintData()))
{
- wxPrintData data; // Does this make sense?
- wxDCFactory *factory = wxDCFactory::GetFactory();
- m_pimpl = factory->CreatePrinterDC( this, data );
}
-wxPrinterDC::wxPrinterDC( const wxPrintData &data )
-{
- wxDCFactory *factory = wxDCFactory::GetFactory();
- m_pimpl = factory->CreatePrinterDC( this, data );
-}
-
-wxPrinterDC::~wxPrinterDC()
+wxPrinterDC::wxPrinterDC(const wxPrintData& data)
+ : wxDC(wxDCFactory::Get()->CreatePrinterDC(this, data))
{
}
return GetImpl()->GetResolution();
}
-#endif
+#endif // wxUSE_PRINTING_ARCHITECTURE
//-----------------------------------------------------------------------------
// wxDCImpl
(double)wxGetDisplaySizeMM().GetWidth();
m_mm_to_pix_y = (double)wxGetDisplaySize().GetHeight() /
(double)wxGetDisplaySizeMM().GetHeight();
-
+
ResetBoundingBox();
ResetClipping();
}
*externalLeading = externalLeading2;
}
-void wxDC::GetLogicalOrigin(long *x, long *y) const
+void wxDC::GetLogicalOrigin(long *x, long *y) const
{
wxCoord x2, y2;
m_pimpl->DoGetLogicalOrigin(&x2, &y2);
*y = y2;
}
-void wxDC::GetDeviceOrigin(long *x, long *y) const
+void wxDC::GetDeviceOrigin(long *x, long *y) const
{
wxCoord x2, y2;
m_pimpl->DoGetDeviceOrigin(&x2, &y2);
*x = x2;
if ( y )
*y = y2;
- }
-
-void wxDC::GetClippingBox(long *x, long *y, long *w, long *h) const
+ }
+
+void wxDC::GetClippingBox(long *x, long *y, long *w, long *h) const
{
wxCoord xx,yy,ww,hh;
m_pimpl->DoGetClippingBox(&xx, &yy, &ww, &hh);
if (y) *y = yy;
if (w) *w = ww;
if (h) *h = hh;
- }
-
+ }
+
#endif // WXWIN_COMPATIBILITY_2_8
{
}
-wxWindowDCImpl::wxWindowDCImpl( wxDC *owner, wxWindow *window ) :
+wxWindowDCImpl::wxWindowDCImpl( wxDC *owner, wxWindow *window ) :
wxMSWDCImpl( owner )
{
wxCHECK_RET( window, _T("invalid window in wxWindowDCImpl") );
public:
wxPaintDCExImpl( wxDC *owner, wxWindow *window, WXHDC dc );
~wxPaintDCExImpl();
-
+
int m_saveState;
};
IMPLEMENT_ABSTRACT_CLASS(wxPaintDCEx,wxPaintDC)
-wxPaintDCEx::wxPaintDCEx( wxWindow *window, WXHDC dc )
+wxPaintDCEx::wxPaintDCEx(wxWindow *window, WXHDC dc)
+ : wxPaintDC(new wxPaintDCExImpl(this, window, dc))
{
- m_pimpl = new wxPaintDCExImpl( this, window, dc );
}
-
-
-wxPaintDCExImpl::wxPaintDCExImpl( wxDC *owner, wxWindow *window, WXHDC dc ) :
- wxPaintDCImpl( owner )
+wxPaintDCExImpl::wxPaintDCExImpl(wxDC *owner, wxWindow *window, WXHDC dc)
+ : wxPaintDCImpl( owner )
{
wxCHECK_RET( dc, wxT("wxPaintDCEx requires an existing device context") );
m_saveState = 0;
-
+
m_window = window;
wxPaintDCInfo *info = FindInCache();
wxMSWDCImpl *msw_impl = wxDynamicCast( impl, wxMSWDCImpl );
if (!msw_impl)
return false;
-
+
if ( !::PlayEnhMetaFile(GetHdcOf(*msw_impl), GetEMF(), &rect) )
{
wxLogLastError(_T("PlayEnhMetaFile"));
class wxEnhMetaFileDCImpl : public wxMSWDCImpl
{
public:
- wxEnhMetaFileDCImpl( wxEnhMetaFileDC *owner,
+ wxEnhMetaFileDCImpl( wxEnhMetaFileDC *owner,
const wxString& filename, int width, int height,
const wxString& description );
virtual ~wxEnhMetaFileDCImpl();
wxEnhMetaFileDC::wxEnhMetaFileDC(const wxString& filename,
int width, int height,
const wxString& description)
+ : wxDC(new wxEnhMetaFileDCImpl(this,
+ filename,
+ width, height,
+ description))
{
- m_pimpl = new wxEnhMetaFileDCImpl( this, filename, width, height, description );
}
projects / wxWidgets.git / commitdiff
