#if wxUSE_NEW_DC
class WXDLLIMPEXP_FWD_CORE wxDC;
+class WXDLLIMPEXP_FWD_CORE wxClientDC;
+class WXDLLIMPEXP_FWD_CORE wxPaintDC;
+class WXDLLIMPEXP_FWD_CORE wxWindowDC;
+class WXDLLIMPEXP_FWD_CORE wxScreenDC;
+class WXDLLIMPEXP_FWD_CORE wxMemoryDC;
#else
class WXDLLIMPEXP_FWD_CORE wxDCBase;
#endif
wxDCFactory() {}
virtual ~wxDCFactory() {}
- virtual wxImplDC* CreateWindowDC() = 0;
- virtual wxImplDC* CreateWindowDC( wxWindow *window ) = 0;
- virtual wxImplDC* CreateClientDC() = 0;
- virtual wxImplDC* CreateClientDC( wxWindow *window ) = 0;
- virtual wxImplDC* CreatePaintDC() = 0;
- virtual wxImplDC* CreatePaintDC( wxWindow *window ) = 0;
- virtual wxImplDC* CreateMemoryDC() = 0;
- virtual wxImplDC* CreateMemoryDC( wxBitmap &bitmap ) = 0;
- virtual wxImplDC* CreateMemoryDC( wxDC *dc ) = 0;
+ virtual wxImplDC* CreateWindowDC( wxWindowDC *owner ) = 0;
+ virtual wxImplDC* CreateWindowDC( wxWindowDC *owner, wxWindow *window ) = 0;
+ virtual wxImplDC* CreateClientDC( wxClientDC *owner ) = 0;
+ virtual wxImplDC* CreateClientDC( wxClientDC *owner, wxWindow *window ) = 0;
+ virtual wxImplDC* CreatePaintDC( wxPaintDC *owner ) = 0;
+ virtual wxImplDC* CreatePaintDC( wxPaintDC *owner, wxWindow *window ) = 0;
+ virtual wxImplDC* CreateMemoryDC( wxMemoryDC *owner ) = 0;
+ virtual wxImplDC* CreateMemoryDC( wxMemoryDC *owner, wxBitmap &bitmap ) = 0;
+ virtual wxImplDC* CreateMemoryDC( wxMemoryDC *owner, wxDC *dc ) = 0;
+ virtual wxImplDC* CreateScreenDC( wxScreenDC *owner ) = 0;
static void SetDCFactory( wxDCFactory *factory );
static wxDCFactory *GetFactory();
// wxNativeDCFactory
//-----------------------------------------------------------------------------
-class WXDLLIMPEXP_CORE wxNativeDCFactory
+class WXDLLIMPEXP_CORE wxNativeDCFactory: public wxDCFactory
{
public:
wxNativeDCFactory() {}
- virtual wxImplDC* CreateWindowDC();
- virtual wxImplDC* CreateWindowDC( wxWindow *window );
- virtual wxImplDC* CreateClientDC();
- virtual wxImplDC* CreateClientDC( wxWindow *window );
- virtual wxImplDC* CreatePaintDC();
- virtual wxImplDC* CreatePaintDC( wxWindow *window );
- virtual wxImplDC* CreateMemoryDC();
- virtual wxImplDC* CreateMemoryDC( wxBitmap &bitmap );
- virtual wxImplDC* CreateMemoryDC( wxDC *dc );
+ virtual wxImplDC* CreateWindowDC( wxWindowDC *owner );
+ virtual wxImplDC* CreateWindowDC( wxWindowDC *owner, wxWindow *window );
+ virtual wxImplDC* CreateClientDC( wxClientDC *owner );
+ virtual wxImplDC* CreateClientDC( wxClientDC *owner, wxWindow *window );
+ virtual wxImplDC* CreatePaintDC( wxPaintDC *owner );
+ virtual wxImplDC* CreatePaintDC( wxPaintDC *owner, wxWindow *window );
+ virtual wxImplDC* CreateMemoryDC( wxMemoryDC *owner );
+ virtual wxImplDC* CreateMemoryDC( wxMemoryDC *owner, wxBitmap &bitmap );
+ virtual wxImplDC* CreateMemoryDC( wxMemoryDC *owner, wxDC *dc );
+ virtual wxImplDC* CreateScreenDC( wxScreenDC *owner );
};
//-----------------------------------------------------------------------------
wxImplDC( wxDC *owner );
~wxImplDC();
- wxDC *GetOwner() { return m_owner; }
+ wxDC *GetOwner() const { return m_owner; }
virtual bool IsOk() const { return m_ok; }
public:
wxDC() { m_pimpl = NULL; }
+ wxImplDC *GetImpl()
+ { return m_pimpl; }
+
bool IsOk() const
{ return m_pimpl && m_pimpl->IsOk(); }
DECLARE_DYNAMIC_CLASS(wxClientDC)
};
-//-----------------------------------------------------------------------------
-// wxMemoryDC
-//-----------------------------------------------------------------------------
-
-class WXDLLIMPEXP_CORE wxMemoryDC: public wxDC
-{
-public:
- wxMemoryDC();
- wxMemoryDC( wxBitmap& bitmap );
- wxMemoryDC( wxDC *dc );
-
-private:
- DECLARE_DYNAMIC_CLASS(wxMemoryDC)
-};
-
//-----------------------------------------------------------------------------
// wxPaintDC
//-----------------------------------------------------------------------------
CalcBoundingBox(drawobject->MaxX(),drawobject->MaxY());
}
+ wxDC *GetOwner() const { return (wxDC*) this; }
+
bool FloodFill(wxCoord x, wxCoord y, const wxColour& col,
int style = wxFLOOD_SURFACE)
{ return DoFloodFill(x, y, col, style); }
#ifndef _WX_DCMEMORY_H_BASE_
#define _WX_DCMEMORY_H_BASE_
+#include "wx/dc.h"
#include "wx/bitmap.h"
+
+#if wxUSE_NEW_DC
+
+//-----------------------------------------------------------------------------
+// wxMemoryDC
+//-----------------------------------------------------------------------------
+
+class WXDLLIMPEXP_CORE wxMemoryImplDCBase
+{
+public:
+ wxMemoryImplDCBase() { }
+
+ virtual void DoSelect(const wxBitmap& bmp) = 0;
+
+ virtual const wxBitmap& DoGetSelectedBitmap() const = 0;
+ virtual wxBitmap& DoGetSelectedBitmap() = 0;
+};
+
+
+class WXDLLIMPEXP_CORE wxMemoryDC: public wxDC
+{
+public:
+ wxMemoryDC();
+ wxMemoryDC( wxBitmap& bitmap );
+ wxMemoryDC( wxDC *dc );
+
+ // select the given bitmap to draw on it
+ void SelectObject(wxBitmap& bmp);
+
+ // select the given bitmap for read-only
+ void SelectObjectAsSource(const wxBitmap& bmp);
+
+ // get selected bitmap
+ const wxBitmap& GetSelectedBitmap() const;
+ wxBitmap& GetSelectedBitmap();
+
+private:
+ DECLARE_DYNAMIC_CLASS(wxMemoryDC)
+};
+
+
+
+#else
+
// NOTE: different native implementations of wxMemoryDC will derive from
// different wxDC classes (wxPaintDC, wxWindowDC, etc), so that
// we cannot derive wxMemoryDCBase from wxDC and then use it as the
virtual void DoSelect(const wxBitmap& bmp) = 0;
};
+
+#endif
+
+
#if defined(__WXPALMOS__)
#include "wx/palmos/dcmemory.h"
#elif defined(__WXMSW__)
#define _WX_DCSCREEN_H_BASE_
#include "wx/defs.h"
+#include "wx/dc.h"
+
+#if wxUSE_NEW_DC
+
+class WXDLLIMPEXP_CORE wxScreenDC : public wxWindowDC
+{
+public:
+ wxScreenDC();
+
+private:
+ DECLARE_DYNAMIC_CLASS(wxScreenDC)
+};
+
+#endif
#if defined(__WXPALMOS__)
#include "wx/palmos/dcscreen.h"
bool CreateFromImageAsPixbuf(const wxImage& image);
#endif // wxUSE_IMAGE
+public:
+ // implementation only
enum Representation
{
Pixmap,
// (wxBitmap may keep same bitmap e.g. as both pixmap and pixbuf):
void PurgeOtherRepresentations(Representation keep);
- friend class wxMemoryDC;
- friend class wxBitmapHandler;
-
private:
DECLARE_DYNAMIC_CLASS(wxBitmap)
};
//-----------------------------------------------------------------------------
#if wxUSE_NEW_DC
-class WXDLLIMPEXP_CORE wxGTKImplDC : public wxDC
+class WXDLLIMPEXP_CORE wxGTKImplDC : public wxImplDC
#else
#define wxGTKImplDC wxDC
-class WXDLLIMPEXP_CORE wxGTKImplDC : public wxDCBase
+class WXDLLIMPEXP_CORE wxDC : public wxDCBase
#endif
{
public:
- wxGTKImplDC();
- virtual ~wxGTKImplDC() { }
+#if wxUSE_NEW_DC
+ wxGTKImplDC( wxDC *owner );
+#else
+ wxDC();
+#endif
+
+ virtual ~wxGTKImplDC();
#if wxUSE_PALETTE
void SetColourMap( const wxPalette& palette ) { SetPalette(palette); };
#endif
{
public:
- wxGTKWindowImplDC();
- wxGTKWindowImplDC( wxWindow *win );
+
+
+#if wxUSE_NEW_DC
+ wxGTKWindowImplDC( wxDC *owner );
+ wxGTKWindowImplDC( wxDC *owner, wxWindow *win );
+#else
+ wxWindowDC();
+ wxWindowDC( wxWindow *win );
+#endif
virtual ~wxGTKWindowImplDC();
GdkGC *m_textGC;
GdkGC *m_bgGC;
GdkColormap *m_cmap;
- bool m_isMemDC;
bool m_isScreenDC;
- wxWindow *m_owner;
+ wxWindow *m_owningWindow;
wxRegion m_currentClippingRegion;
wxRegion m_paintClippingRegion;
PangoLayout *m_layout;
PangoFontDescription *m_fontdesc;
- void SetUpDC();
+ void SetUpDC( bool ismem = false );
void Destroy();
virtual void ComputeScaleAndOrigin();
virtual GdkWindow *GetGDKWindow() const { return m_window; }
private:
- DECLARE_DYNAMIC_CLASS(wxGTKWindowImplDC)
+ DECLARE_ABSTRACT_CLASS(wxGTKWindowImplDC)
};
//-----------------------------------------------------------------------------
#endif
{
public:
- wxGTKClientImplDC() { }
- wxGTKClientImplDC( wxWindow *win );
+
+#if wxUSE_NEW_DC
+ wxGTKClientImplDC( wxDC *owner );
+ wxGTKClientImplDC( wxDC *owner, wxWindow *win );
+#else
+ wxClientDC();
+ wxClientDC( wxWindow *win );
+#endif
protected:
virtual void DoGetSize(int *width, int *height) const;
private:
- DECLARE_DYNAMIC_CLASS(wxGTKClientImplDC)
+ DECLARE_ABSTRACT_CLASS(wxGTKClientImplDC)
};
//-----------------------------------------------------------------------------
#endif
{
public:
- wxGTKPaintImplDC() { }
- wxGTKPaintImplDC( wxWindow *win );
+
+#if wxUSE_NEW_DC
+ wxGTKPaintImplDC( wxDC *owner );
+ wxGTKPaintImplDC( wxDC *owner, wxWindow *win );
+#else
+ wxPaintDC();
+ wxPaintDC( wxWindow *win );
+#endif
private:
- DECLARE_DYNAMIC_CLASS(wxGTKPaintImplDC)
+ DECLARE_ABSTRACT_CLASS(wxGTKPaintImplDC)
};
#endif // __GTKDCCLIENTH__
// wxMemoryDC
//-----------------------------------------------------------------------------
+
+#if wxUSE_NEW_DC
+class WXDLLIMPEXP_CORE wxGTKMemoryImplDC : public wxGTKWindowImplDC, public wxMemoryImplDCBase
+#else
+#define wxGTKMemoryImplDC wxMemoryDC
class WXDLLIMPEXP_CORE wxMemoryDC : public wxWindowDC, public wxMemoryDCBase
+#endif
{
public:
- wxMemoryDC() : wxWindowDC() { Init(); }
- wxMemoryDC(wxBitmap& bitmap) : wxWindowDC() { Init(); SelectObject(bitmap); }
- wxMemoryDC( wxDC *dc ); // Create compatible DC
- virtual ~wxMemoryDC();
+
+#if wxUSE_NEW_DC
+ wxGTKMemoryImplDC( wxMemoryDC *owner );
+ wxGTKMemoryImplDC( wxMemoryDC *owner, wxBitmap& bitmap );
+ wxGTKMemoryImplDC( wxMemoryDC *owner, wxDC *dc );
+#else
+ wxMemoryDC();
+ wxMemoryDC(wxBitmap& bitmap);
+ wxMemoryDC( wxDC *dc );
+#endif
+
+ virtual ~wxGTKMemoryImplDC();
// these get reimplemented for mono-bitmaps to behave
// more like their Win32 couterparts. They now interpret
// implementation
wxBitmap GetSelectedBitmap() const { return m_selected; }
- wxBitmap m_selected;
protected:
- void DoGetSize( int *width, int *height ) const;
+ // overridden from wxImplDC
+ virtual void DoGetSize( int *width, int *height ) const;
+ virtual wxBitmap DoGetAsBitmap(const wxRect *subrect) const;
+
+public:
+ // overridden from wxMemoryImplDCBase
virtual void DoSelect(const wxBitmap& bitmap);
- virtual wxBitmap DoGetAsBitmap(const wxRect *subrect) const
- {
- wxBitmap bmp = GetSelectedBitmap();
- return subrect ? bmp.GetSubBitmap(*subrect) : bmp;
- }
+ virtual const wxBitmap& DoGetSelectedBitmap() const;
+ virtual wxBitmap& DoGetSelectedBitmap();
+ wxBitmap m_selected;
+
private:
void Init();
- DECLARE_DYNAMIC_CLASS(wxMemoryDC)
+ DECLARE_ABSTRACT_CLASS(wxGTKMemoryImplDC)
};
#endif // _WX_GTK_DCMEMORY_H_
#include "wx/dcclient.h"
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
-
-class WXDLLIMPEXP_FWD_CORE wxScreenDC;
-
//-----------------------------------------------------------------------------
// wxScreenDC
//-----------------------------------------------------------------------------
-class WXDLLIMPEXP_CORE wxScreenDC : public wxPaintDC
+#if wxUSE_NEW_DC
+class WXDLLIMPEXP_CORE wxGTKScreenImplDC : public wxGTKWindowImplDC
+#else
+#define wxGTKScreenImplDC wxScreenDC
+class WXDLLIMPEXP_CORE wxScreenDC : public wxWindowDC
+#endif
{
public:
+
+#if wxUSE_NEW_DC
+ wxGTKScreenImplDC( wxScreenDC *owner );
+#else
wxScreenDC();
- virtual ~wxScreenDC();
+#endif
- static bool StartDrawingOnTop( wxWindow *window );
- static bool StartDrawingOnTop( wxRect *rect = (wxRect *) NULL );
- static bool EndDrawingOnTop();
+ ~wxGTKScreenImplDC();
- // implementation
+ static bool StartDrawingOnTop( wxWindow *window ) { return true; }
+ static bool StartDrawingOnTop( wxRect *rect = (wxRect *) NULL ) { return true; }
+ static bool EndDrawingOnTop() { return true; }
- static GdkWindow *sm_overlayWindow;
- static int sm_overlayWindowX;
- static int sm_overlayWindowY;
protected:
virtual void DoGetSize(int *width, int *height) const;
+
+ void Init();
private:
- DECLARE_DYNAMIC_CLASS(wxScreenDC)
+ DECLARE_ABSTRACT_CLASS(wxGTKScreenImplDC)
};
#endif
#endif
#include "wx/dc.h"
+#include "wx/dcclient.h"
+#include "wx/dcmemory.h"
+#include "wx/dcscreen.h"
#include "wx/dcbuffer.h" // for IMPLEMENT_DYNAMIC_CLASS
#ifndef WX_PRECOMP
// wxNativeDCFactory
//-----------------------------------------------------------------------------
-wxImplDC* wxNativeDCFactory::CreateWindowDC()
+wxImplDC* wxNativeDCFactory::CreateWindowDC( wxWindowDC *owner )
{
#if defined(__WXMSW__)
- return new wxWindowsWindowImplDC();
+ return new wxWindowsWindowImplDC( owner );
#elif defined(__WXGTK20__)
- return new wxGTKWindowImplDC();
+ return new wxGTKWindowImplDC( owner );
#elif defined(__WXGTK__)
- return new wxGTKWindowImplDC();
+ return new wxGTKWindowImplDC( owner );
#elif defined(__WXMAC__)
- return new wxMacWindowImplDC();
+ return new wxMacWindowImplDC( owner );
#elif defined(__WXCOCOA__)
- return new wxCocoaWindowImplDC();
+ return new wxCocoaWindowImplDC( owner );
#elif defined(__WXMOTIF__)
- return new wxMotifWindowImplDC();
+ return new wxMotifWindowImplDC( owner );
#elif defined(__WXX11__)
- return new wxX11WindowImplDC();
+ return new wxX11WindowImplDC( owner );
#elif defined(__WXMGL__)
- return new wxMGLWindowImplDC();
+ return new wxMGLWindowImplDC( owner );
#elif defined(__WXDFB__)
- return new wxDFBWindowImplDC();
+ return new wxDFBWindowImplDC( owner );
#elif defined(__WXPM__)
- return new wxPMWindowImplDC();
+ return new wxPMWindowImplDC( owner );
#elif defined(__PALMOS__)
- return new wxPalmWindowImplDC();
+ return new wxPalmWindowImplDC( owner );
#endif
}
-wxImplDC* wxNativeDCFactory::CreateWindowDC( wxWindow *window )
+wxImplDC* wxNativeDCFactory::CreateWindowDC( wxWindowDC *owner, wxWindow *window )
{
#if defined(__WXMSW__)
- return new wxWindowsWindowImplDC( window );
+ return new wxWindowsWindowImplDC( owner, window );
#elif defined(__WXGTK20__)
- return new wxGTKWindowImplDC( window );
+ return new wxGTKWindowImplDC( owner, window );
#elif defined(__WXGTK__)
- return new wxGTKWindowImplDC( window );
+ return new wxGTKWindowImplDC( owner, window );
#elif defined(__WXMAC__)
- return new wxMacWindowImplDC( window );
+ return new wxMacWindowImplDC( owner, window );
#elif defined(__WXCOCOA__)
- return new wxCocoaWindowImplDC( window );
+ return new wxCocoaWindowImplDC( owner, window );
#elif defined(__WXMOTIF__)
- return new wxMotifWindowImplDC( window );
+ return new wxMotifWindowImplDC( owner, window );
#elif defined(__WXX11__)
- return new wxX11WindowImplDC( window );
+ return new wxX11WindowImplDC( owner, window );
#elif defined(__WXMGL__)
- return new wxMGLWindowImplDC( window );
+ return new wxMGLWindowImplDC( owner, window );
#elif defined(__WXDFB__)
- return new wxDFBWindowImplDC( window );
+ return new wxDFBWindowImplDC( owner, window );
#elif defined(__WXPM__)
- return new wxPMWindowImplDC( window );
+ return new wxPMWindowImplDC( owner, window );
#elif defined(__PALMOS__)
- return new wxPalmWindowImplDC( window );
+ return new wxPalmWindowImplDC( owner, window );
#endif
}
-wxImplDC* wxNativeDCFactory::CreateClientDC()
+wxImplDC* wxNativeDCFactory::CreateClientDC( wxClientDC *owner )
{
#if defined(__WXMSW__)
- return new wxWindowsClientImplDC();
+ return new wxWindowsClientImplDC( owner );
#elif defined(__WXGTK20__)
- return new wxGTKClientImplDC();
+ return new wxGTKClientImplDC( owner );
#elif defined(__WXGTK__)
- return new wxGTKClientImplDC();
+ return new wxGTKClientImplDC( owner );
#elif defined(__WXMAC__)
- return new wxMacClientImplDC();
+ return new wxMacClientImplDC( owner );
#elif defined(__WXCOCOA__)
- return new wxCocoaClientImplDC();
+ return new wxCocoaClientImplDC( owner );
#elif defined(__WXMOTIF__)
- return new wxMotifClientImplDC();
+ return new wxMotifClientImplDC( owner );
#elif defined(__WXX11__)
- return new wxX11ClientImplDC();
+ return new wxX11ClientImplDC( owner );
#elif defined(__WXMGL__)
- return new wxMGLClientImplDC();
+ return new wxMGLClientImplDC( owner );
#elif defined(__WXDFB__)
- return new wxDFBClientImplDC();
+ return new wxDFBClientImplDC( owner );
#elif defined(__WXPM__)
- return new wxPMClientImplDC();
+ return new wxPMClientImplDC( owner );
#elif defined(__PALMOS__)
- return new wxPalmClientImplDC();
+ return new wxPalmClientImplDC( owner );
#endif
}
-wxImplDC* wxNativeDCFactory::CreateClientDC( wxWindow *window )
+wxImplDC* wxNativeDCFactory::CreateClientDC( wxClientDC *owner, wxWindow *window )
{
#if defined(__WXMSW__)
- return new wxWindowsClientImplDC( window );
+ return new wxWindowsClientImplDC( owner, window );
#elif defined(__WXGTK20__)
- return new wxGTKClientImplDC( window );
+ return new wxGTKClientImplDC( owner, window );
#elif defined(__WXGTK__)
- return new wxGTKClientImplDC( window );
+ return new wxGTKClientImplDC( owner, window );
#elif defined(__WXMAC__)
- return new wxMacClientImplDC( window );
+ return new wxMacClientImplDC( owner, window );
#elif defined(__WXCOCOA__)
- return new wxCocoaClientImplDC( window );
+ return new wxCocoaClientImplDC( owner, window );
#elif defined(__WXMOTIF__)
- return new wxMotifClientImplDC( window );
+ return new wxMotifClientImplDC( owner, window );
#elif defined(__WXX11__)
- return new wxX11ClientImplDC( window );
+ return new wxX11ClientImplDC( owner, window );
#elif defined(__WXMGL__)
- return new wxMGLClientImplDC( window );
+ return new wxMGLClientImplDC( owner, window );
#elif defined(__WXDFB__)
- return new wxDFBClientImplDC( window );
+ return new wxDFBClientImplDC( owner, window );
#elif defined(__WXPM__)
- return new wxPMClientImplDC( window );
+ return new wxPMClientImplDC( owner, window );
#elif defined(__PALMOS__)
- return new wxPalmClientImplDC( window );
+ return new wxPalmClientImplDC( owner, window );
#endif
}
-wxImplDC* wxNativeDCFactory::CreatePaintDC()
+wxImplDC* wxNativeDCFactory::CreatePaintDC( wxPaintDC *owner )
{
#if defined(__WXMSW__)
- return new wxWindowsPaintImplDC();
+ return new wxWindowsPaintImplDC( owner );
#elif defined(__WXGTK20__)
- return new wxGTKPaintImplDC();
+ return new wxGTKPaintImplDC( owner );
#elif defined(__WXGTK__)
- return new wxGTKPaintImplDC();
+ return new wxGTKPaintImplDC( owner );
#elif defined(__WXMAC__)
- return new wxMacPaintImplDC();
+ return new wxMacPaintImplDC( owner );
#elif defined(__WXCOCOA__)
- return new wxCocoaPaintImplDC();
+ return new wxCocoaPaintImplDC( owner );
#elif defined(__WXMOTIF__)
- return new wxMotifPaintImplDC();
+ return new wxMotifPaintImplDC( owner );
#elif defined(__WXX11__)
- return new wxX11PaintImplDC();
+ return new wxX11PaintImplDC( owner );
#elif defined(__WXMGL__)
- return new wxMGLPaintImplDC();
+ return new wxMGLPaintImplDC( owner );
#elif defined(__WXDFB__)
- return new wxDFBPaintImplDC();
+ return new wxDFBPaintImplDC( owner );
#elif defined(__WXPM__)
- return new wxPMPaintImplDC();
+ return new wxPMPaintImplDC( owner );
#elif defined(__PALMOS__)
- return new wxPalmPaintImplDC();
+ return new wxPalmPaintImplDC( owner );
#endif
}
-wxImplDC* wxNativeDCFactory::CreatePaintDC( wxWindow *window )
+wxImplDC* wxNativeDCFactory::CreatePaintDC( wxPaintDC *owner, wxWindow *window )
{
#if defined(__WXMSW__)
- return new wxWindowsPaintImplDC( window );
+ return new wxWindowsPaintImplDC( owner, window );
#elif defined(__WXGTK20__)
- return new wxGTKPaintImplDC( window );
+ return new wxGTKPaintImplDC( owner, window );
#elif defined(__WXGTK__)
- return new wxGTKPaintImplDC( window );
+ return new wxGTKPaintImplDC( owner, window );
#elif defined(__WXMAC__)
- return new wxMacPaintImplDC( window );
+ return new wxMacPaintImplDC( owner, window );
#elif defined(__WXCOCOA__)
- return new wxCocoaPaintImplDC( window );
+ return new wxCocoaPaintImplDC( owner, window );
#elif defined(__WXMOTIF__)
- return new wxMotifPaintImplDC( window );
+ return new wxMotifPaintImplDC( owner, window );
#elif defined(__WXX11__)
- return new wxX11PaintImplDC( window );
+ return new wxX11PaintImplDC( owner, window );
#elif defined(__WXMGL__)
- return new wxMGLPaintImplDC( window );
+ return new wxMGLPaintImplDC( owner, window );
#elif defined(__WXDFB__)
- return new wxDFBPaintImplDC( window );
+ return new wxDFBPaintImplDC( owner, window );
#elif defined(__WXPM__)
- return new wxPMPaintImplDC( window );
+ return new wxPMPaintImplDC( owner, window );
#elif defined(__PALMOS__)
- return new wxPalmPaintImplDC( window );
+ return new wxPalmPaintImplDC( owner, window );
#endif
}
-wxImplDC* wxNativeDCFactory::CreateMemoryDC()
+wxImplDC* wxNativeDCFactory::CreateMemoryDC( wxMemoryDC *owner )
{
#if defined(__WXMSW__)
- return new wxWindowsMemoryImplDC();
+ return new wxWindowsMemoryImplDC( owner );
#elif defined(__WXGTK20__)
- return new wxGTKMemoryImplDC();
+ return new wxGTKMemoryImplDC( owner );
#elif defined(__WXGTK__)
- return new wxGTKMemoryImplDC();
+ return new wxGTKMemoryImplDC( owner );
#elif defined(__WXMAC__)
- return new wxMacMemoryImplDC();
+ return new wxMacMemoryImplDC( owner );
#elif defined(__WXCOCOA__)
- return new wxCocoaMemoryImplDC();
+ return new wxCocoaMemoryImplDC( owner );
#elif defined(__WXMOTIF__)
- return new wxMotifMemoryImplDC();
+ return new wxMotifMemoryImplDC( owner );
#elif defined(__WXX11__)
- return new wxX11MemoryImplDC();
+ return new wxX11MemoryImplDC( owner );
#elif defined(__WXMGL__)
- return new wxMGLMemoryImplDC();
+ return new wxMGLMemoryImplDC( owner );
#elif defined(__WXDFB__)
- return new wxDFBMemoryImplDC();
+ return new wxDFBMemoryImplDC( owner );
#elif defined(__WXPM__)
- return new wxPMMemoryImplDC();
+ return new wxPMMemoryImplDC( owner );
#elif defined(__PALMOS__)
- return new wxPalmMemoryImplDC();
+ return new wxPalmMemoryImplDC( owner );
#endif
}
-wxImplDC* wxNativeDCFactory::CreateMemoryDC( wxBitmap &bitmap )
+wxImplDC* wxNativeDCFactory::CreateMemoryDC( wxMemoryDC *owner, wxBitmap &bitmap )
{
#if defined(__WXMSW__)
- return new wxWindowsMemoryImplDC( bitmap );
+ return new wxWindowsMemoryImplDC( owner, bitmap );
#elif defined(__WXGTK20__)
- return new wxGTKMemoryImplDC( bitmap );
+ return new wxGTKMemoryImplDC( owner, bitmap );
#elif defined(__WXGTK__)
- return new wxGTKMemoryImplDC( bitmap );
+ return new wxGTKMemoryImplDC( owner, bitmap );
#elif defined(__WXMAC__)
- return new wxMacMemoryImplDC( bitmap );
+ return new wxMacMemoryImplDC( owner, bitmap );
#elif defined(__WXCOCOA__)
- return new wxCocoaMemoryImplDC( bitmap );
+ return new wxCocoaMemoryImplDC( owner, bitmap );
#elif defined(__WXMOTIF__)
- return new wxMotifMemoryImplDC( bitmap );
+ return new wxMotifMemoryImplDC( owner, bitmap );
#elif defined(__WXX11__)
- return new wxX11MemoryImplDC( bitmap );
+ return new wxX11MemoryImplDC( owner, bitmap );
#elif defined(__WXMGL__)
- return new wxMGLMemoryImplDC( bitmap );
+ return new wxMGLMemoryImplDC( owner, bitmap );
#elif defined(__WXDFB__)
- return new wxDFBMemoryImplDC( bitmap );
+ return new wxDFBMemoryImplDC( owner, bitmap );
#elif defined(__WXPM__)
- return new wxPMMemoryImplDC( bitmap );
+ return new wxPMMemoryImplDC( owner, bitmap );
#elif defined(__PALMOS__)
- return new wxPalmMemoryImplDC( bitmap );
+ return new wxPalmMemoryImplDC( owner, bitmap );
#endif
}
-wxImplDC* wxNativeDCFactory::CreateMemoryDC( wxDC *dc )
+wxImplDC* wxNativeDCFactory::CreateMemoryDC( wxMemoryDC *owner, wxDC *dc )
{
#if defined(__WXMSW__)
- return new wxWindowsMemoryImplDC( dc );
+ return new wxWindowsMemoryImplDC( owner, dc );
#elif defined(__WXGTK20__)
- return new wxGTKMemoryImplDC( dc );
+ return new wxGTKMemoryImplDC( owner, dc );
#elif defined(__WXGTK__)
- return new wxGTKMemoryImplDC( dc );
+ return new wxGTKMemoryImplDC( owner, dc );
#elif defined(__WXMAC__)
- return new wxMacMemoryImplDC( dc );
+ return new wxMacMemoryImplDC( owner, dc );
#elif defined(__WXCOCOA__)
- return new wxCocoaMemoryImplDC( dc );
+ return new wxCocoaMemoryImplDC( owner, dc );
#elif defined(__WXMOTIF__)
- return new wxMotifMemoryImplDC( dc );
+ return new wxMotifMemoryImplDC( owner, dc );
#elif defined(__WXX11__)
- return new wxX11MemoryImplDC( dc );
+ return new wxX11MemoryImplDC( owner, dc );
#elif defined(__WXMGL__)
- return new wxMGLMemoryImplDC( dc );
+ return new wxMGLMemoryImplDC( owner, dc );
#elif defined(__WXDFB__)
- return new wxDFBMemoryImplDC( dc );
+ return new wxDFBMemoryImplDC( owner, dc );
#elif defined(__WXPM__)
- return new wxPMMemoryImplDC( dc );
+ return new wxPMMemoryImplDC( owner, dc );
#elif defined(__PALMOS__)
- return new wxPalmMemoryImplDC( dc );
+ return new wxPalmMemoryImplDC( owner, dc );
+#endif
+}
+
+wxImplDC* wxNativeDCFactory::CreateScreenDC( wxScreenDC *owner )
+{
+#if defined(__WXMSW__)
+ return new wxWindowsScreenImplDC( owner );
+#elif defined(__WXGTK20__)
+ return new wxGTKScreenImplDC( owner );
+#elif defined(__WXGTK__)
+ return new wxGTKScreenImplDC( owner );
+#elif defined(__WXMAC__)
+ return new wxMacScreenImplDC( owner );
+#elif defined(__WXCOCOA__)
+ return new wxCocoaScreenImplDC( owner );
+#elif defined(__WXMOTIF__)
+ return new wxMotifScreenImplDC( owner );
+#elif defined(__WXX11__)
+ return new wxX11ScreenImplDC( owner );
+#elif defined(__WXMGL__)
+ return new wxMGLScreenImplDC( owner );
+#elif defined(__WXDFB__)
+ return new wxDFBScreenImplDC( owner );
+#elif defined(__WXPM__)
+ return new wxPMScreenImplDC( owner );
+#elif defined(__PALMOS__)
+ return new wxPalmScreenImplDC( owner );
#endif
}
IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
-wxWindow::wxWindowDC()
+wxWindowDC::wxWindowDC()
{
wxDCFactory *factory = wxDCFactory::GetFactory();
- m_pimpl = factory->CreateWindowDC();
+ m_pimpl = factory->CreateWindowDC( this );
}
-wxWindow::wxWindowDC( wxWindow *win )
+wxWindowDC::wxWindowDC( wxWindow *win )
{
wxDCFactory *factory = wxDCFactory::GetFactory();
- m_pimpl = factory->CreateWindowDC( win );
+ m_pimpl = factory->CreateWindowDC( this, win );
}
//-----------------------------------------------------------------------------
wxClientDC::wxClientDC()
{
wxDCFactory *factory = wxDCFactory::GetFactory();
- m_pimpl = factory->CreateClientDC();
+ m_pimpl = factory->CreateClientDC( this );
}
wxClientDC::wxClientDC( wxWindow *win )
{
wxDCFactory *factory = wxDCFactory::GetFactory();
- m_pimpl = factory->CreateClientDC( win );
+ m_pimpl = factory->CreateClientDC( this, win );
}
//-----------------------------------------------------------------------------
wxMemoryDC::wxMemoryDC()
{
wxDCFactory *factory = wxDCFactory::GetFactory();
- m_pimpl = factory->CreateMemoryDC();
+ m_pimpl = factory->CreateMemoryDC( this );
}
wxMemoryDC::wxMemoryDC( wxBitmap& bitmap )
{
wxDCFactory *factory = wxDCFactory::GetFactory();
- m_pimpl = factory->CreateMemoryDC( bitmap );
+ m_pimpl = factory->CreateMemoryDC( this, bitmap );
}
wxMemoryDC::wxMemoryDC( wxDC *dc )
{
wxDCFactory *factory = wxDCFactory::GetFactory();
- m_pimpl = factory->CreateMemoryDC( dc );
+ m_pimpl = factory->CreateMemoryDC( this, dc );
+}
+
+void wxMemoryDC::SelectObject(wxBitmap& bmp)
+{
+ // make sure that the given wxBitmap is not sharing its data with other
+ // wxBitmap instances as its contents will be modified by any drawing
+ // operation done on this DC
+ if (bmp.IsOk())
+ bmp.UnShare();
+
+#ifdef __WXGTK__
+ wxGTKMemoryImplDC *mem_pimpl = wxDynamicCast( m_pimpl, wxGTKMemoryImplDC );
+#else
+ // TODO
+#endif
+ if (mem_pimpl)
+ mem_pimpl->DoSelect(bmp);
}
+
+void wxMemoryDC::SelectObjectAsSource(const wxBitmap& bmp)
+{
+#ifdef __WXGTK__
+ wxGTKMemoryImplDC *mem_pimpl = wxDynamicCast( m_pimpl, wxGTKMemoryImplDC );
+#else
+ // TODO
+#endif
+ mem_pimpl->DoSelect(bmp);
+}
+
+const wxBitmap& wxMemoryDC::GetSelectedBitmap() const
+{
+#ifdef __WXGTK__
+ wxGTKMemoryImplDC *mem_pimpl = wxDynamicCast( m_pimpl, wxGTKMemoryImplDC );
+#else
+ // TODO
+#endif
+ if (mem_pimpl)
+ return mem_pimpl->DoGetSelectedBitmap();
+
+ return wxNullBitmap;
+}
+
+wxBitmap& wxMemoryDC::GetSelectedBitmap()
+{
+#ifdef __WXGTK__
+ wxGTKMemoryImplDC *mem_pimpl = wxDynamicCast( m_pimpl, wxGTKMemoryImplDC );
+#else
+ // TODO
+#endif
+
+ if (mem_pimpl)
+ return mem_pimpl->DoGetSelectedBitmap();
+
+ return wxNullBitmap;
+}
+
//-----------------------------------------------------------------------------
// wxPaintDC
wxPaintDC::wxPaintDC()
{
wxDCFactory *factory = wxDCFactory::GetFactory();
- m_pimpl = factory->CreatePaintDC();
+ m_pimpl = factory->CreatePaintDC( this );
}
wxPaintDC::wxPaintDC( wxWindow *win )
{
wxDCFactory *factory = wxDCFactory::GetFactory();
- m_pimpl = factory->CreatePaintDC( win );
+ m_pimpl = factory->CreatePaintDC( this, win );
+}
+
+//-----------------------------------------------------------------------------
+// wxScreenDC
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_DYNAMIC_CLASS(wxScreenDC, wxWindowDC)
+
+wxScreenDC::wxScreenDC()
+{
+ wxDCFactory *factory = wxDCFactory::GetFactory();
+ m_pimpl = factory->CreateScreenDC( this );
}
//-----------------------------------------------------------------------------
{
}
-#if WXWIN_COMPATIBILITY_2_8
- // for compatibility with the old code when wxCoord was long everywhere
-void wxImplDC::GetTextExtent(const wxString& string,
- long *x, long *y,
- long *descent,
- long *externalLeading,
- const wxFont *theFont) const
- {
- wxCoord x2, y2, descent2, externalLeading2;
- DoGetTextExtent(string, &x2, &y2,
- &descent2, &externalLeading2,
- theFont);
- if ( x )
- *x = x2;
- if ( y )
- *y = y2;
- if ( descent )
- *descent = descent2;
- if ( externalLeading )
- *externalLeading = externalLeading2;
- }
-
-void wxImplDC::GetLogicalOrigin(long *x, long *y) const
- {
- wxCoord x2, y2;
- DoGetLogicalOrigin(&x2, &y2);
- if ( x )
- *x = x2;
- if ( y )
- *y = y2;
- }
-
-void wxImplDC::GetDeviceOrigin(long *x, long *y) const
- {
- wxCoord x2, y2;
- DoGetDeviceOrigin(&x2, &y2);
- if ( x )
- *x = x2;
- if ( y )
- *y = y2;
- }
-
-void wxImplDC::GetClippingBox(long *x, long *y, long *w, long *h) const
- {
- wxCoord xx,yy,ww,hh;
- DoGetClippingBox(&xx, &yy, &ww, &hh);
- if (x) *x = xx;
- if (y) *y = yy;
- if (w) *w = ww;
- if (h) *h = hh;
- }
-#endif // WXWIN_COMPATIBILITY_2_8
-
-
-
// ----------------------------------------------------------------------------
// coordinate conversions and transforms
// ----------------------------------------------------------------------------
}
else
{
- GetTextExtent(c, &w, &h);
+ DoGetTextExtent(c, &w, &h);
if (c_int < FWC_SIZE)
s_fontWidthCache.m_widths[c_int] = w;
}
void wxImplDC::DoDrawCheckMark(wxCoord x1, wxCoord y1,
wxCoord width, wxCoord height)
{
- wxCHECK_RET( Ok(), wxT("invalid window dc") );
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
wxCoord x2 = x1 + width,
y2 = y1 + height;
// the pen width is calibrated to give 3 for width == height == 10
- wxDCPenChanger pen(m_owner, wxPen(GetTextForeground(), (width + height + 1)/7));
+ wxDCPenChanger pen( *m_owner, wxPen(GetTextForeground(), (width + height + 1)/7));
// we're drawing a scaled version of wx/generic/tick.xpm here
wxCoord x3 = x1 + (4*width) / 10, // x of the tick bottom
return rc;
}
+#if 0
void wxImplDC::DrawLines(const wxList *list, wxCoord xoffset, wxCoord yoffset)
{
int n = list->GetCount();
delete [] points;
}
+#endif
void
wxImplDC::DoDrawPolyPolygon(int n,
#if wxUSE_SPLINES
// TODO: this API needs fixing (wxPointList, why (!const) "wxList *"?)
-void wxImplDC::DrawSpline(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord x3, wxCoord y3)
+void wxImplDC::DoDrawSpline(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord x3, wxCoord y3)
{
wxList point_list;
point3->x = x3; point3->y = y3;
point_list.Append((wxObject*)point3);
- DrawSpline(&point_list);
+ DoDrawSpline(&point_list);
for( wxList::compatibility_iterator node = point_list.GetFirst(); node; node = node->GetNext() )
{
}
}
-void wxImplDC::DrawSpline(int n, wxPoint points[])
+void wxImplDC::DoDrawSpline(int n, wxPoint points[])
{
wxList list;
for (int i =0; i < n; i++)
list.Append((wxObject*)&points[i]);
}
- DrawSpline(&list);
+ DoDrawSpline(&list);
}
// ----------------------------------- spline code ----------------------------------------
void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3,
double x4, double y4);
static bool wx_spline_add_point(double x, double y);
-static void wx_spline_draw_point_array(wxDCBase *dc);
+static void wx_spline_draw_point_array(wxDC *dc);
wxList wx_spline_point_list;
static void wx_spline_draw_point_array(wxDC *dc)
{
- dc->DrawLines(&wx_spline_point_list, 0, 0 );
+// dc->DrawLines(&wx_spline_point_list, 0, 0 ); wxList
wxList::compatibility_iterator node = wx_spline_point_list.GetFirst();
while (node)
{
void wxImplDC::DoDrawSpline( wxList *points )
{
- wxCHECK_RET( Ok(), wxT("invalid window dc") );
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
wxPoint *p;
double cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
#endif // wxUSE_SPLINES
-void wxImplDC::DrawLabel(const wxString& text,
- const wxBitmap& bitmap,
- const wxRect& rect,
- int alignment,
- int indexAccel,
- wxRect *rectBounding)
-{
- // find the text position
- wxCoord widthText, heightText, heightLine;
- GetMultiLineTextExtent(text, &widthText, &heightText, &heightLine);
-
- wxCoord width, height;
- if ( bitmap.Ok() )
- {
- width = widthText + bitmap.GetWidth();
- height = bitmap.GetHeight();
- }
- else // no bitmap
- {
- width = widthText;
- height = heightText;
- }
-
- wxCoord x, y;
- if ( alignment & wxALIGN_RIGHT )
- {
- x = rect.GetRight() - width;
- }
- else if ( alignment & wxALIGN_CENTRE_HORIZONTAL )
- {
- x = (rect.GetLeft() + rect.GetRight() + 1 - width) / 2;
- }
- else // alignment & wxALIGN_LEFT
- {
- x = rect.GetLeft();
- }
-
- if ( alignment & wxALIGN_BOTTOM )
- {
- y = rect.GetBottom() - height;
- }
- else if ( alignment & wxALIGN_CENTRE_VERTICAL )
- {
- y = (rect.GetTop() + rect.GetBottom() + 1 - height) / 2;
- }
- else // alignment & wxALIGN_TOP
- {
- y = rect.GetTop();
- }
-
- // draw the bitmap first
- wxCoord x0 = x,
- y0 = y,
- width0 = width;
- if ( bitmap.Ok() )
- {
- DoDrawBitmap(bitmap, x, y, true /* use mask */);
-
- wxCoord offset = bitmap.GetWidth() + 4;
- x += offset;
- width -= offset;
-
- y += (height - heightText) / 2;
- }
-
- // we will draw the underscore under the accel char later
- wxCoord startUnderscore = 0,
- endUnderscore = 0,
- yUnderscore = 0;
-
- // split the string into lines and draw each of them separately
- wxString curLine;
- for ( wxString::const_iterator pc = text.begin(); ; ++pc )
- {
- if ( *pc == _T('\n') || pc == text.end() )
- {
- int xRealStart = x; // init it here to avoid compielr warnings
-
- if ( !curLine.empty() )
- {
- // NB: can't test for !(alignment & wxALIGN_LEFT) because
- // wxALIGN_LEFT is 0
- if ( alignment & (wxALIGN_RIGHT | wxALIGN_CENTRE_HORIZONTAL) )
- {
- wxCoord widthLine;
- m_owner->GetTextExtent(curLine, &widthLine, NULL);
-
- if ( alignment & wxALIGN_RIGHT )
- {
- xRealStart += width - widthLine;
- }
- else // if ( alignment & wxALIGN_CENTRE_HORIZONTAL )
- {
- xRealStart += (width - widthLine) / 2;
- }
- }
- //else: left aligned, nothing to do
-
- DoDrawText(curLine, xRealStart, y);
- }
-
- y += heightLine;
-
- // do we have underscore in this line? we can check yUnderscore
- // because it is set below to just y + heightLine if we do
- if ( y == yUnderscore )
- {
- // adjust the horz positions to account for the shift
- startUnderscore += xRealStart;
- endUnderscore += xRealStart;
- }
-
- if ( pc == text.end() )
- break;
-
- curLine.clear();
- }
- else // not end of line
- {
- if ( pc - text.begin() == indexAccel )
- {
- // remeber to draw underscore here
- GetTextExtent(curLine, &startUnderscore, NULL);
- curLine += *pc;
- GetTextExtent(curLine, &endUnderscore, NULL);
-
- yUnderscore = y + heightLine;
- }
- else
- {
- curLine += *pc;
- }
- }
- }
-
- // draw the underscore if found
- if ( startUnderscore != endUnderscore )
- {
- // it should be of the same colour as text
- SetPen(wxPen(GetTextForeground(), 0, wxSOLID));
-
- yUnderscore--;
-
- DoDrawLine(startUnderscore, yUnderscore, endUnderscore, yUnderscore);
- }
-
- // return bounding rect if requested
- if ( rectBounding )
- {
- *rectBounding = wxRect(x, y - heightText, widthText, heightText);
- }
-
- CalcBoundingBox(x0, y0);
- CalcBoundingBox(x0 + width0, y0 + height);
-}
-
void wxImplDC::DoGradientFillLinear(const wxRect& rect,
const wxColour& initialColour,
//set the pixel
m_pen.SetColour(wxColour(nR,nG,nB));
- DoDrawPoint(wxPoint(x + rect.GetLeft(), y + rect.GetTop()));
+ DoDrawPoint(x + rect.GetLeft(), y + rect.GetTop());
}
}
//return old pen color
IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
+void wxDC::DrawLabel(const wxString& text,
+ const wxBitmap& bitmap,
+ const wxRect& rect,
+ int alignment,
+ int indexAccel,
+ wxRect *rectBounding)
+{
+ // find the text position
+ wxCoord widthText, heightText, heightLine;
+ GetMultiLineTextExtent(text, &widthText, &heightText, &heightLine);
+
+ wxCoord width, height;
+ if ( bitmap.Ok() )
+ {
+ width = widthText + bitmap.GetWidth();
+ height = bitmap.GetHeight();
+ }
+ else // no bitmap
+ {
+ width = widthText;
+ height = heightText;
+ }
+
+ wxCoord x, y;
+ if ( alignment & wxALIGN_RIGHT )
+ {
+ x = rect.GetRight() - width;
+ }
+ else if ( alignment & wxALIGN_CENTRE_HORIZONTAL )
+ {
+ x = (rect.GetLeft() + rect.GetRight() + 1 - width) / 2;
+ }
+ else // alignment & wxALIGN_LEFT
+ {
+ x = rect.GetLeft();
+ }
+
+ if ( alignment & wxALIGN_BOTTOM )
+ {
+ y = rect.GetBottom() - height;
+ }
+ else if ( alignment & wxALIGN_CENTRE_VERTICAL )
+ {
+ y = (rect.GetTop() + rect.GetBottom() + 1 - height) / 2;
+ }
+ else // alignment & wxALIGN_TOP
+ {
+ y = rect.GetTop();
+ }
+
+ // draw the bitmap first
+ wxCoord x0 = x,
+ y0 = y,
+ width0 = width;
+ if ( bitmap.Ok() )
+ {
+ DrawBitmap(bitmap, x, y, true /* use mask */);
+
+ wxCoord offset = bitmap.GetWidth() + 4;
+ x += offset;
+ width -= offset;
+
+ y += (height - heightText) / 2;
+ }
+
+ // we will draw the underscore under the accel char later
+ wxCoord startUnderscore = 0,
+ endUnderscore = 0,
+ yUnderscore = 0;
+
+ // split the string into lines and draw each of them separately
+ wxString curLine;
+ for ( wxString::const_iterator pc = text.begin(); ; ++pc )
+ {
+ if ( *pc == _T('\n') || pc == text.end() )
+ {
+ int xRealStart = x; // init it here to avoid compielr warnings
+
+ if ( !curLine.empty() )
+ {
+ // NB: can't test for !(alignment & wxALIGN_LEFT) because
+ // wxALIGN_LEFT is 0
+ if ( alignment & (wxALIGN_RIGHT | wxALIGN_CENTRE_HORIZONTAL) )
+ {
+ wxCoord widthLine;
+ GetTextExtent(curLine, &widthLine, NULL);
+
+ if ( alignment & wxALIGN_RIGHT )
+ {
+ xRealStart += width - widthLine;
+ }
+ else // if ( alignment & wxALIGN_CENTRE_HORIZONTAL )
+ {
+ xRealStart += (width - widthLine) / 2;
+ }
+ }
+ //else: left aligned, nothing to do
+
+ DrawText(curLine, xRealStart, y);
+ }
+
+ y += heightLine;
+
+ // do we have underscore in this line? we can check yUnderscore
+ // because it is set below to just y + heightLine if we do
+ if ( y == yUnderscore )
+ {
+ // adjust the horz positions to account for the shift
+ startUnderscore += xRealStart;
+ endUnderscore += xRealStart;
+ }
+
+ if ( pc == text.end() )
+ break;
+
+ curLine.clear();
+ }
+ else // not end of line
+ {
+ if ( pc - text.begin() == indexAccel )
+ {
+ // remeber to draw underscore here
+ GetTextExtent(curLine, &startUnderscore, NULL);
+ curLine += *pc;
+ GetTextExtent(curLine, &endUnderscore, NULL);
+
+ yUnderscore = y + heightLine;
+ }
+ else
+ {
+ curLine += *pc;
+ }
+ }
+ }
+
+ // draw the underscore if found
+ if ( startUnderscore != endUnderscore )
+ {
+ // it should be of the same colour as text
+ SetPen(wxPen(GetTextForeground(), 0, wxSOLID));
+
+ yUnderscore--;
+
+ DrawLine(startUnderscore, yUnderscore, endUnderscore, yUnderscore);
+ }
+
+ // return bounding rect if requested
+ if ( rectBounding )
+ {
+ *rectBounding = wxRect(x, y - heightText, widthText, heightText);
+ }
+
+ CalcBoundingBox(x0, y0);
+ CalcBoundingBox(x0 + width0, y0 + height);
+}
+
#if WXWIN_COMPATIBILITY_2_8
// for compatibility with the old code when wxCoord was long everywhere
void wxDC::GetTextExtent(const wxString& string,
void wxOverlayImpl::Init( wxWindowDC* dc, int x , int y , int width , int height )
{
#if defined(__WXGTK__)
- m_window = dc->m_owner;
+ m_window = dc->m_owningWindow;
#else
#if defined (__WXMSW__)
m_window = dc->GetWindow();
//-----------------------------------------------------------------------------
#if wxUSE_NEW_DC
-IMPLEMENT_ABSTRACT_CLASS(wxGTKImplDC, wxDC)
+IMPLEMENT_ABSTRACT_CLASS(wxGTKImplDC, wxImplDC)
#else
IMPLEMENT_ABSTRACT_CLASS(wxGTKImplDC, wxDCBase)
#endif
-wxGTKImplDC::wxGTKImplDC()
+#if wxUSE_NEW_DC
+wxGTKImplDC::wxGTKImplDC( wxDC *owner )
+ : wxImplDC( owner )
+#else
+wxDC::wxDC()
+#endif
{
m_ok = FALSE;
m_brush = *wxWHITE_BRUSH;
}
+wxGTKImplDC::~wxGTKImplDC()
+{
+}
+
void wxGTKImplDC::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
{
m_clipping = TRUE;
{
int w = 0;
int h = 0;
- GetSize( &w, &h );
+ GetOwner()->GetSize( &w, &h );
if (width) *width = int( double(w) / (m_userScaleX*m_mm_to_pix_x) );
if (height) *height = int( double(h) / (m_userScaleY*m_mm_to_pix_y) );
}
//-----------------------------------------------------------------------------
#if wxUSE_NEW_DC
-IMPLEMENT_DYNAMIC_CLASS(wxGTKWindowImplDC, wxGTKImplDC)
+IMPLEMENT_ABSTRACT_CLASS(wxGTKWindowImplDC, wxGTKImplDC)
#else
-IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
+IMPLEMENT_ABSTRACT_CLASS(wxWindowDC, wxDC)
#endif
-wxGTKWindowImplDC::wxGTKWindowImplDC()
+#if wxUSE_NEW_DC
+wxGTKWindowImplDC::wxGTKWindowImplDC( wxDC *owner ) :
+ wxGTKImplDC( owner )
+#else
+wxWindowDC::wxWindowDC()
+#endif
{
m_penGC = (GdkGC *) NULL;
m_brushGC = (GdkGC *) NULL;
m_textGC = (GdkGC *) NULL;
m_bgGC = (GdkGC *) NULL;
m_cmap = (GdkColormap *) NULL;
- m_isMemDC = false;
m_isScreenDC = false;
- m_owner = (wxWindow *)NULL;
+ m_owningWindow = (wxWindow *)NULL;
m_context = (PangoContext *)NULL;
m_layout = (PangoLayout *)NULL;
m_fontdesc = (PangoFontDescription *)NULL;
}
-wxGTKWindowImplDC::wxGTKWindowImplDC( wxWindow *window )
+#if wxUSE_NEW_DC
+wxGTKWindowImplDC::wxGTKWindowImplDC( wxDC *owner, wxWindow *window ) :
+ wxGTKImplDC( owner )
+#else
+wxWindowDC::wxWindowDC( wxWindow *window )
+#endif
{
wxASSERT_MSG( window, wxT("DC needs a window") );
m_textGC = (GdkGC *) NULL;
m_bgGC = (GdkGC *) NULL;
m_cmap = (GdkColormap *) NULL;
- m_owner = (wxWindow *)NULL;
- m_isMemDC = false;
+ m_owningWindow = (wxWindow *)NULL;
m_isScreenDC = false;
m_font = window->GetFont();
is white whereas a window might assume gray to be the
standard (as e.g. wxStatusBar) */
- m_owner = window;
+ m_owningWindow = window;
- if (m_owner && m_owner->m_wxwindow && (m_owner->GetLayoutDirection() == wxLayout_RightToLeft))
+ if (m_owningWindow && m_owningWindow->m_wxwindow &&
+ (m_owningWindow->GetLayoutDirection() == wxLayout_RightToLeft))
{
// reverse sense
m_signX = -1;
// origin in the upper right corner
- m_deviceOriginX = m_owner->GetClientSize().x;
+ m_deviceOriginX = m_owningWindow->GetClientSize().x;
}
}
pango_font_description_free( m_fontdesc );
}
-void wxGTKWindowImplDC::SetUpDC()
+void wxGTKWindowImplDC::SetUpDC( bool isMemDC )
{
m_ok = true;
wxASSERT_MSG( !m_penGC, wxT("GCs already created") );
- if (m_isScreenDC)
- {
- m_penGC = wxGetPoolGC( m_window, wxPEN_SCREEN );
- m_brushGC = wxGetPoolGC( m_window, wxBRUSH_SCREEN );
- m_textGC = wxGetPoolGC( m_window, wxTEXT_SCREEN );
- m_bgGC = wxGetPoolGC( m_window, wxBG_SCREEN );
- }
- else
- if (m_isMemDC && (((wxMemoryDC*)this)->m_selected.GetDepth() == 1))
+ bool done = false;
+
+ if (isMemDC)
{
- m_penGC = wxGetPoolGC( m_window, wxPEN_MONO );
- m_brushGC = wxGetPoolGC( m_window, wxBRUSH_MONO );
- m_textGC = wxGetPoolGC( m_window, wxTEXT_MONO );
- m_bgGC = wxGetPoolGC( m_window, wxBG_MONO );
+ wxGTKMemoryImplDC *mem_dc = (wxGTKMemoryImplDC*) this;
+ if (mem_dc->GetSelectedBitmap().GetDepth() == 1)
+ {
+ m_penGC = wxGetPoolGC( m_window, wxPEN_MONO );
+ m_brushGC = wxGetPoolGC( m_window, wxBRUSH_MONO );
+ m_textGC = wxGetPoolGC( m_window, wxTEXT_MONO );
+ m_bgGC = wxGetPoolGC( m_window, wxBG_MONO );
+ done = true;
+ }
}
- else
- {
- m_penGC = wxGetPoolGC( m_window, wxPEN_COLOUR );
- m_brushGC = wxGetPoolGC( m_window, wxBRUSH_COLOUR );
- m_textGC = wxGetPoolGC( m_window, wxTEXT_COLOUR );
- m_bgGC = wxGetPoolGC( m_window, wxBG_COLOUR );
+
+ if (!done)
+ {
+ if (m_isScreenDC)
+ {
+ m_penGC = wxGetPoolGC( m_window, wxPEN_SCREEN );
+ m_brushGC = wxGetPoolGC( m_window, wxBRUSH_SCREEN );
+ m_textGC = wxGetPoolGC( m_window, wxTEXT_SCREEN );
+ m_bgGC = wxGetPoolGC( m_window, wxBG_SCREEN );
+ }
+ else
+ {
+ m_penGC = wxGetPoolGC( m_window, wxPEN_COLOUR );
+ m_brushGC = wxGetPoolGC( m_window, wxBRUSH_COLOUR );
+ m_textGC = wxGetPoolGC( m_window, wxTEXT_COLOUR );
+ m_bgGC = wxGetPoolGC( m_window, wxBG_COLOUR );
+ }
}
/* background colour */
void wxGTKWindowImplDC::DoGetSize( int* width, int* height ) const
{
- wxCHECK_RET( m_owner, _T("GetSize() doesn't work without window") );
+ wxCHECK_RET( m_owningWindow, _T("GetSize() doesn't work without window") );
- m_owner->GetSize(width, height);
+ m_owningWindow->GetSize(width, height);
}
bool wxGTKWindowImplDC::DoFloodFill(wxCoord x, wxCoord y,
extern bool wxDoFloodFill(wxDC *dc, wxCoord x, wxCoord y,
const wxColour & col, int style);
- return wxDoFloodFill(this, x, y, col, style);
+ return wxDoFloodFill( GetOwner(), x, y, col, style);
#else
return false;
#endif
void wxGTKWindowImplDC::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 )
{
- wxCHECK_RET( Ok(), wxT("invalid window dc") );
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
if (m_pen.GetStyle() != wxTRANSPARENT)
{
void wxGTKWindowImplDC::DoCrossHair( wxCoord x, wxCoord y )
{
- wxCHECK_RET( Ok(), wxT("invalid window dc") );
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
if (m_pen.GetStyle() != wxTRANSPARENT)
{
int w = 0;
int h = 0;
- GetSize( &w, &h );
+ GetOwner()->GetSize( &w, &h );
wxCoord xx = XLOG2DEV(x);
wxCoord yy = YLOG2DEV(y);
if (m_window)
void wxGTKWindowImplDC::DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2,
wxCoord xc, wxCoord yc )
{
- wxCHECK_RET( Ok(), wxT("invalid window dc") );
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
wxCoord xx1 = XLOG2DEV(x1);
wxCoord yy1 = YLOG2DEV(y1);
void wxGTKWindowImplDC::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width, wxCoord height, double sa, double ea )
{
- wxCHECK_RET( Ok(), wxT("invalid window dc") );
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
wxCoord xx = XLOG2DEV(x);
wxCoord yy = YLOG2DEV(y);
void wxGTKWindowImplDC::DoDrawPoint( wxCoord x, wxCoord y )
{
- wxCHECK_RET( Ok(), wxT("invalid window dc") );
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
if ((m_pen.GetStyle() != wxTRANSPARENT) && m_window)
gdk_draw_point( m_window, m_penGC, XLOG2DEV(x), YLOG2DEV(y) );
void wxGTKWindowImplDC::DoDrawLines( int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset )
{
- wxCHECK_RET( Ok(), wxT("invalid window dc") );
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
if (m_pen.GetStyle() == wxTRANSPARENT) return;
if (n <= 0) return;
void wxGTKWindowImplDC::DoDrawPolygon( int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset, int WXUNUSED(fillStyle) )
{
- wxCHECK_RET( Ok(), wxT("invalid window dc") );
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
if (n <= 0) return;
void wxGTKWindowImplDC::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
{
- wxCHECK_RET( Ok(), wxT("invalid window dc") );
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
wxCoord xx = XLOG2DEV(x);
wxCoord yy = YLOG2DEV(y);
void wxGTKWindowImplDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius )
{
- wxCHECK_RET( Ok(), wxT("invalid window dc") );
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
if (radius < 0.0) radius = - radius * ((width < height) ? width : height);
// X drawing errors with small radii
if (rr == 0)
{
- DrawRectangle( x, y, width, height );
+ DoDrawRectangle( x, y, width, height );
return;
}
void wxGTKWindowImplDC::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
{
- wxCHECK_RET( Ok(), wxT("invalid window dc") );
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
wxCoord xx = XLOG2DEV(x);
wxCoord yy = YLOG2DEV(y);
wxCoord x, wxCoord y,
bool useMask )
{
- wxCHECK_RET( Ok(), wxT("invalid window dc") );
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
- wxCHECK_RET( bitmap.Ok(), wxT("invalid bitmap") );
+ wxCHECK_RET( bitmap.IsOk(), wxT("invalid bitmap") );
bool is_mono = bitmap.GetDepth() == 1;
int w = bitmap.GetWidth();
int h = bitmap.GetHeight();
- if (m_owner && m_owner->GetLayoutDirection() == wxLayout_RightToLeft)
+ if (m_owningWindow && m_owningWindow->GetLayoutDirection() == wxLayout_RightToLeft)
xx -= w;
CalcBoundingBox( x, y );
bool useMask,
wxCoord xsrcMask, wxCoord ysrcMask )
{
- wxCHECK_MSG( Ok(), false, wxT("invalid window dc") );
+ wxCHECK_MSG( IsOk(), false, wxT("invalid window dc") );
wxCHECK_MSG( source, false, wxT("invalid source dc") );
ysrcMask = ysrc;
}
- if (selected.Ok())
+ if (selected.IsOk())
{
is_mono = (selected.GetDepth() == 1);
}
else // use_bitmap_method
{
- if (selected.Ok() && ((width != ww) || (height != hh)))
+ if (selected.IsOk() && ((width != ww) || (height != hh)))
{
// get clip coords
wxRegion tmp( xx,yy,ww,hh );
else
{
// No scaling and not a memory dc with a mask either
-
+#if wxUSE_NEW_DC
+ GdkWindow* window = NULL;
+ wxImplDC *impl = source->GetImpl();
+ wxGTKWindowImplDC *gtk_impl = wxDynamicCast(impl, wxGTKWindowImplDC);
+ if (gtk_impl)
+ window = gtk_impl->GetGDKWindow();
+#else
GdkWindow* window = source->GetGDKWindow();
+#endif
if ( !window )
return false;
void wxGTKWindowImplDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
{
- wxCHECK_RET( Ok(), wxT("invalid window dc") );
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
if (!m_window) return;
gdk_pango_context_set_colormap( m_context, m_cmap );
- bool underlined = m_font.Ok() && m_font.GetUnderlined();
+ bool underlined = m_font.IsOk() && m_font.GetUnderlined();
const wxCharBuffer data = wxGTK_CONV( text );
if ( !data )
}
// Draw layout.
- if (m_owner && m_owner->GetLayoutDirection() == wxLayout_RightToLeft)
+ if (m_owningWindow && m_owningWindow->GetLayoutDirection() == wxLayout_RightToLeft)
gdk_draw_layout( m_window, m_textGC, x-w, y, m_layout );
else
gdk_draw_layout( m_window, m_textGC, x, y, m_layout );
}
// Draw layout.
- if (m_owner && m_owner->GetLayoutDirection() == wxLayout_RightToLeft)
+ if (m_owningWindow && m_owningWindow->GetLayoutDirection() == wxLayout_RightToLeft)
gdk_draw_layout( m_window, m_textGC, x-w, y, m_layout );
else
gdk_draw_layout( m_window, m_textGC, x, y, m_layout );
if (!m_window || text.empty())
return;
- wxCHECK_RET( Ok(), wxT("invalid window dc") );
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
if ( wxIsNullDouble(angle) )
{
- DrawText(text, x, y);
+ DoDrawText(text, x, y);
return;
}
wxCoord h;
// TODO: implement later without GdkFont for GTK 2.0
- GetTextExtent(text, &w, &h, NULL,NULL, &m_font);
+ DoGetTextExtent(text, &w, &h, NULL,NULL, &m_font);
// draw the string normally
wxBitmap src(w, h);
return;
// ensure that theFont is always non-NULL
- if ( !theFont || !theFont->Ok() )
+ if ( !theFont || !theFont->IsOk() )
theFont = wx_const_cast(wxFont *, &m_font);
// and use it if it's valid
- if ( theFont->Ok() )
+ if ( theFont->IsOk() )
{
pango_layout_set_font_description
(
void wxGTKWindowImplDC::Clear()
{
- wxCHECK_RET( Ok(), wxT("invalid window dc") );
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
if (!m_window) return;
- // VZ: the code below results in infinite recursion and crashes when
- // dc.Clear() is done from OnPaint() so I disable it for now.
- // I don't know what the correct fix is but Clear() surely should not
- // reenter OnPaint()!
-#if 0
- /* - we either are a memory dc or have a window as the
- owner. anything else shouldn't happen.
- - we don't use gdk_window_clear() as we don't set
- the window's background colour anymore. it is too
- much pain to keep the DC's and the window's back-
- ground colour in synch. */
-
- if (m_owner)
- {
- m_owner->Clear();
- return;
- }
-
- if (m_isMemDC)
- {
- int width,height;
- GetSize( &width, &height );
- gdk_draw_rectangle( m_window, m_bgGC, TRUE, 0, 0, width, height );
- return;
- }
-#else // 1
int width,height;
- GetSize( &width, &height );
+ DoGetSize( &width, &height );
gdk_draw_rectangle( m_window, m_bgGC, TRUE, 0, 0, width, height );
-#endif // 0/1
}
void wxGTKWindowImplDC::SetFont( const wxFont &font )
{
m_font = font;
- if (m_font.Ok())
+ if (m_font.IsOk())
{
if (m_fontdesc)
pango_font_description_free( m_fontdesc );
m_fontdesc = pango_font_description_copy( m_font.GetNativeFontInfo()->description );
- if (m_owner)
+ if (m_owningWindow)
{
PangoContext *oldContext = m_context;
- m_context = m_owner->GtkGetPangoDefaultContext();
+ m_context = m_owningWindow->GtkGetPangoDefaultContext();
// If we switch back/forth between different contexts
// we also have to create a new layout. I think so,
void wxGTKWindowImplDC::SetPen( const wxPen &pen )
{
- wxCHECK_RET( Ok(), wxT("invalid window dc") );
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
if (m_pen == pen) return;
m_pen = pen;
- if (!m_pen.Ok()) return;
+ if (!m_pen.IsOk()) return;
if (!m_window) return;
void wxGTKWindowImplDC::SetBrush( const wxBrush &brush )
{
- wxCHECK_RET( Ok(), wxT("invalid window dc") );
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
if (m_brush == brush) return;
m_brush = brush;
- if (!m_brush.Ok()) return;
+ if (!m_brush.IsOk()) return;
if (!m_window) return;
gdk_gc_set_fill( m_brushGC, GDK_SOLID );
- if ((m_brush.GetStyle() == wxSTIPPLE) && (m_brush.GetStipple()->Ok()))
+ if ((m_brush.GetStyle() == wxSTIPPLE) && (m_brush.GetStipple()->IsOk()))
{
if (m_brush.GetStipple()->GetDepth() != 1)
{
/* CMB 21/7/98: Added SetBackground. Sets background brush
* for Clear() and bg colour for shapes filled with cross-hatch brush */
- wxCHECK_RET( Ok(), wxT("invalid window dc") );
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
if (m_backgroundBrush == brush) return;
m_backgroundBrush = brush;
- if (!m_backgroundBrush.Ok()) return;
+ if (!m_backgroundBrush.IsOk()) return;
if (!m_window) return;
gdk_gc_set_fill( m_bgGC, GDK_SOLID );
- if ((m_backgroundBrush.GetStyle() == wxSTIPPLE) && (m_backgroundBrush.GetStipple()->Ok()))
+ if ((m_backgroundBrush.GetStyle() == wxSTIPPLE) && (m_backgroundBrush.GetStipple()->IsOk()))
{
if (m_backgroundBrush.GetStipple()->GetDepth() != 1)
{
void wxGTKWindowImplDC::SetLogicalFunction( int function )
{
- wxCHECK_RET( Ok(), wxT("invalid window dc") );
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
if (m_logicalFunction == function)
return;
void wxGTKWindowImplDC::SetTextForeground( const wxColour &col )
{
- wxCHECK_RET( Ok(), wxT("invalid window dc") );
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
// don't set m_textForegroundColour to an invalid colour as we'd crash
// later then (we use m_textForegroundColour.GetColor() without checking
// in a few places)
- if ( !col.Ok() || (m_textForegroundColour == col) )
+ if ( !col.IsOk() || (m_textForegroundColour == col) )
return;
m_textForegroundColour = col;
void wxGTKWindowImplDC::SetTextBackground( const wxColour &col )
{
- wxCHECK_RET( Ok(), wxT("invalid window dc") );
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
// same as above
- if ( !col.Ok() || (m_textBackgroundColour == col) )
+ if ( !col.IsOk() || (m_textBackgroundColour == col) )
return;
m_textBackgroundColour = col;
void wxGTKWindowImplDC::SetBackgroundMode( int mode )
{
- wxCHECK_RET( Ok(), wxT("invalid window dc") );
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
m_backgroundMode = mode;
void wxGTKWindowImplDC::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
{
- wxCHECK_RET( Ok(), wxT("invalid window dc") );
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
if (!m_window) return;
rect.width = XLOG2DEVREL(width);
rect.height = YLOG2DEVREL(height);
- if (m_owner && m_owner->m_wxwindow && (m_owner->GetLayoutDirection() == wxLayout_RightToLeft))
+ if (m_owningWindow && m_owningWindow->m_wxwindow &&
+ (m_owningWindow->GetLayoutDirection() == wxLayout_RightToLeft))
{
rect.x -= rect.width;
}
wxCoord xx, yy, ww, hh;
m_currentClippingRegion.GetBox( xx, yy, ww, hh );
+#if wxUSE_NEW_DC
+ wxImplDC::DoSetClippingRegion( xx, yy, ww, hh );
+#else
wxDC::DoSetClippingRegion( xx, yy, ww, hh );
+#endif
gdk_gc_set_clip_region( m_penGC, m_currentClippingRegion.GetRegion() );
gdk_gc_set_clip_region( m_brushGC, m_currentClippingRegion.GetRegion() );
void wxGTKWindowImplDC::DoSetClippingRegionAsRegion( const wxRegion ®ion )
{
- wxCHECK_RET( Ok(), wxT("invalid window dc") );
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
if (region.Empty())
{
wxCoord xx, yy, ww, hh;
m_currentClippingRegion.GetBox( xx, yy, ww, hh );
+#if wxUSE_NEW_DC
+ wxImplDC::DoSetClippingRegion( xx, yy, ww, hh );
+#else
wxDC::DoSetClippingRegion( xx, yy, ww, hh );
+#endif
gdk_gc_set_clip_region( m_penGC, m_currentClippingRegion.GetRegion() );
gdk_gc_set_clip_region( m_brushGC, m_currentClippingRegion.GetRegion() );
void wxGTKWindowImplDC::DestroyClippingRegion()
{
- wxCHECK_RET( Ok(), wxT("invalid window dc") );
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
+#if wxUSE_NEW_DC
+ wxImplDC::DestroyClippingRegion();
+#else
wxDC::DestroyClippingRegion();
+#endif
m_currentClippingRegion.Clear();
m_signX = (xLeftRight ? 1 : -1);
m_signY = (yBottomUp ? -1 : 1);
- if (m_owner && m_owner->m_wxwindow && (m_owner->GetLayoutDirection() == wxLayout_RightToLeft))
+ if (m_owningWindow && m_owningWindow->m_wxwindow &&
+ (m_owningWindow->GetLayoutDirection() == wxLayout_RightToLeft))
m_signX = -m_signX;
ComputeScaleAndOrigin();
{
const wxRealPoint origScale(m_scaleX, m_scaleY);
+#if wxUSE_NEW_DC
+ wxImplDC::ComputeScaleAndOrigin();
+#else
wxDC::ComputeScaleAndOrigin();
+#endif
// if scale has changed call SetPen to recalulate the line width
- if ( wxRealPoint(m_scaleX, m_scaleY) != origScale && m_pen.Ok() )
+ if ( wxRealPoint(m_scaleX, m_scaleY) != origScale && m_pen.IsOk() )
{
// this is a bit artificial, but we need to force wxDC to think the pen
// has changed
}
+//-----------------------------------------------------------------------------
+// wxClientDC
+//-----------------------------------------------------------------------------
+
+#if wxUSE_NEW_DC
+IMPLEMENT_ABSTRACT_CLASS(wxGTKClientImplDC, wxGTKWindowImplDC)
+#else
+IMPLEMENT_ABSTRACT_CLASS(wxClientDC, wxWindowDC)
+#endif
+
+#if wxUSE_NEW_DC
+wxGTKClientImplDC::wxGTKClientImplDC( wxDC *owner )
+ : wxGTKWindowImplDC( owner )
+{
+}
+
+wxGTKClientImplDC::wxGTKClientImplDC( wxDC *owner, wxWindow *win )
+ : wxGTKWindowImplDC( owner, win )
+#else
+wxClientDC::wxClientDC()
+{
+}
+
+wxClientDC::wxClientDC( wxWindow *win )
+ : wxWindowDC( win )
+#endif
+
+{
+ wxCHECK_RET( win, _T("NULL window in wxGTKClientImplDC::wxClientDC") );
+
+#ifdef __WXUNIVERSAL__
+ wxPoint ptOrigin = win->GetClientAreaOrigin();
+ SetDeviceOrigin(ptOrigin.x, ptOrigin.y);
+ wxSize size = win->GetClientSize();
+ SetClippingRegion(wxPoint(0, 0), size);
+#endif // __WXUNIVERSAL__
+}
+
+void wxGTKClientImplDC::DoGetSize(int *width, int *height) const
+{
+ wxCHECK_RET( m_owningWindow, _T("GetSize() doesn't work without window") );
+
+ m_owningWindow->GetClientSize( width, height );
+}
+
//-----------------------------------------------------------------------------
// wxPaintDC
//-----------------------------------------------------------------------------
#if wxUSE_NEW_DC
-IMPLEMENT_DYNAMIC_CLASS(wxGTKPaintImplDC, wxGTKClientImplDC)
+IMPLEMENT_ABSTRACT_CLASS(wxGTKPaintImplDC, wxGTKClientImplDC)
#else
-IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxClientDC)
+IMPLEMENT_ABSTRACT_CLASS(wxPaintDC, wxClientDC)
#endif
// Limit the paint region to the window size. Sometimes
}
}
-wxGTKPaintImplDC::wxGTKPaintImplDC( wxWindow *win )
- : wxGTKClientImplDC( win )
+#if wxUSE_NEW_DC
+wxGTKPaintImplDC::wxGTKPaintImplDC( wxDC *owner )
+ : wxGTKClientImplDC( owner )
+{
+}
+
+wxGTKPaintImplDC::wxGTKPaintImplDC( wxDC *owner, wxWindow *win )
+ : wxGTKClientImplDC( owner, win )
+#else
+wxPaintDC::wxPaintDC()
+ : wxClientDC()
+{
+}
+
+wxPaintDC::wxPaintDC( wxWindow *win )
+ : wxClientDC( win )
+#endif
{
#if USE_PAINT_REGION
if (!win->m_clipPaintRegion)
#endif // USE_PAINT_REGION
}
-//-----------------------------------------------------------------------------
-// wxClientDC
-//-----------------------------------------------------------------------------
-
-#if wxUSE_NEW_DC
-IMPLEMENT_DYNAMIC_CLASS(wxGTKClientImplDC, wxGTKWindowImplDC)
-#else
-IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxWindowDC)
-#endif
-
-wxGTKClientImplDC::wxGTKClientImplDC( wxWindow *win )
- : wxGTKWindowImplDC( win )
-{
- wxCHECK_RET( win, _T("NULL window in wxGTKClientImplDC::wxClientDC") );
-
-#ifdef __WXUNIVERSAL__
- wxPoint ptOrigin = win->GetClientAreaOrigin();
- SetDeviceOrigin(ptOrigin.x, ptOrigin.y);
- wxSize size = win->GetClientSize();
- SetClippingRegion(wxPoint(0, 0), size);
-#endif // __WXUNIVERSAL__
-}
-
-void wxGTKClientImplDC::DoGetSize(int *width, int *height) const
-{
- wxCHECK_RET( m_owner, _T("GetSize() doesn't work without window") );
-
- m_owner->GetClientSize( width, height );
-}
-
// ----------------------------------------------------------------------------
// wxDCModule
// ----------------------------------------------------------------------------
// wxMemoryDC
//-----------------------------------------------------------------------------
-IMPLEMENT_DYNAMIC_CLASS(wxMemoryDC,wxWindowDC)
+#if wxUSE_NEW_DC
+IMPLEMENT_ABSTRACT_CLASS(wxGTKMemoryImplDC, wxGTKWindowImplDC)
+#else
+IMPLEMENT_ABSTRACT_CLASS(wxMemoryDC,wxWindowDC)
+#endif
+
+#if wxUSE_NEW_DC
+wxGTKMemoryImplDC::wxGTKMemoryImplDC( wxMemoryDC *owner )
+ : wxGTKWindowImplDC( owner )
+{
+ Init();
+}
-void wxMemoryDC::Init()
-{
- m_ok = false;
+wxGTKMemoryImplDC::wxGTKMemoryImplDC( wxMemoryDC *owner, wxBitmap& bitmap)
+ : wxGTKWindowImplDC( owner )
+{
+ Init();
+ owner->SelectObject(bitmap);
+}
- m_cmap = gtk_widget_get_default_colormap();
+wxGTKMemoryImplDC::wxGTKMemoryImplDC( wxMemoryDC *owner, wxDC *WXUNUSED(dc) )
+ : wxGTKWindowImplDC( owner )
+{
+ Init();
+}
+#else
+wxMemoryDC::wxMemoryDC()
+{
+ Init();
+}
- m_context = gdk_pango_context_get();
- // Note: The Sun customised version of Pango shipping with Solaris 10
- // crashes if the language is left NULL (see bug 1374114)
- pango_context_set_language( m_context, gtk_get_default_language() );
- m_layout = pango_layout_new( m_context );
- m_fontdesc = pango_font_description_copy( pango_context_get_font_description( m_context ) );
+wxMemoryDC::wxMemoryDC(wxBitmap& bitmap)
+{
+ Init();
+ SelectObject(bitmap);
}
wxMemoryDC::wxMemoryDC( wxDC *WXUNUSED(dc) )
{
Init();
}
+#endif
-wxMemoryDC::~wxMemoryDC()
+wxGTKMemoryImplDC::~wxGTKMemoryImplDC()
{
g_object_unref(m_context);
}
-void wxMemoryDC::DoSelect( const wxBitmap& bitmap )
+void wxGTKMemoryImplDC::Init()
+{
+ m_ok = false;
+
+ m_cmap = gtk_widget_get_default_colormap();
+
+ m_context = gdk_pango_context_get();
+ // Note: The Sun customised version of Pango shipping with Solaris 10
+ // crashes if the language is left NULL (see bug 1374114)
+ pango_context_set_language( m_context, gtk_get_default_language() );
+ m_layout = pango_layout_new( m_context );
+ m_fontdesc = pango_font_description_copy( pango_context_get_font_description( m_context ) );
+}
+
+void wxGTKMemoryImplDC::DoSelect( const wxBitmap& bitmap )
{
Destroy();
m_selected.PurgeOtherRepresentations(wxBitmap::Pixmap);
- m_isMemDC = true;
-
- SetUpDC();
+ SetUpDC( true );
}
else
{
}
}
-void wxMemoryDC::SetPen( const wxPen& penOrig )
+void wxGTKMemoryImplDC::SetPen( const wxPen& penOrig )
{
wxPen pen( penOrig );
if ( m_selected.Ok() &&
pen.SetColour( pen.GetColour() == *wxWHITE ? *wxBLACK : *wxWHITE );
}
- wxWindowDC::SetPen( pen );
+ wxGTKWindowImplDC::SetPen( pen );
}
-void wxMemoryDC::SetBrush( const wxBrush& brushOrig )
+void wxGTKMemoryImplDC::SetBrush( const wxBrush& brushOrig )
{
wxBrush brush( brushOrig );
if ( m_selected.Ok() &&
brush.SetColour( brush.GetColour() == *wxWHITE ? *wxBLACK : *wxWHITE);
}
- wxWindowDC::SetBrush( brush );
+ wxGTKWindowImplDC::SetBrush( brush );
}
-void wxMemoryDC::SetBackground( const wxBrush& brushOrig )
+void wxGTKMemoryImplDC::SetBackground( const wxBrush& brushOrig )
{
wxBrush brush(brushOrig);
brush.SetColour( brush.GetColour() == *wxWHITE ? *wxBLACK : *wxWHITE );
}
- wxWindowDC::SetBackground( brush );
+ wxGTKWindowImplDC::SetBackground( brush );
}
-void wxMemoryDC::SetTextForeground( const wxColour& col )
+void wxGTKMemoryImplDC::SetTextForeground( const wxColour& col )
{
if ( m_selected.Ok() && m_selected.GetDepth() == 1 )
{
- wxWindowDC::SetTextForeground( col == *wxWHITE ? *wxBLACK : *wxWHITE);
+ wxGTKWindowImplDC::SetTextForeground( col == *wxWHITE ? *wxBLACK : *wxWHITE);
}
else
{
- wxWindowDC::SetTextForeground( col );
+ wxGTKWindowImplDC::SetTextForeground( col );
}
}
-void wxMemoryDC::SetTextBackground( const wxColour &col )
+void wxGTKMemoryImplDC::SetTextBackground( const wxColour &col )
{
if (m_selected.Ok() && m_selected.GetDepth() == 1)
{
- wxWindowDC::SetTextBackground( col == *wxWHITE ? *wxBLACK : *wxWHITE );
+ wxGTKWindowImplDC::SetTextBackground( col == *wxWHITE ? *wxBLACK : *wxWHITE );
}
else
{
- wxWindowDC::SetTextBackground( col );
+ wxGTKWindowImplDC::SetTextBackground( col );
}
}
-void wxMemoryDC::DoGetSize( int *width, int *height ) const
+void wxGTKMemoryImplDC::DoGetSize( int *width, int *height ) const
{
if (m_selected.Ok())
{
if (height) (*height) = 0;
}
}
+
+wxBitmap wxGTKMemoryImplDC::DoGetAsBitmap(const wxRect *subrect) const
+{
+ wxBitmap bmp = GetSelectedBitmap();
+ return subrect ? bmp.GetSubBitmap(*subrect) : bmp;
+}
+
+const wxBitmap& wxGTKMemoryImplDC::DoGetSelectedBitmap() const
+{
+ return m_selected;
+}
+
+wxBitmap& wxGTKMemoryImplDC::DoGetSelectedBitmap()
+{
+ return m_selected;
+}
+
#include <gdk/gdkx.h>
#include <gtk/gtk.h>
-//-----------------------------------------------------------------------------
-// global data initialization
-//-----------------------------------------------------------------------------
-
-GdkWindow *wxScreenDC::sm_overlayWindow = (GdkWindow*) NULL;
-int wxScreenDC::sm_overlayWindowX = 0;
-int wxScreenDC::sm_overlayWindowY = 0;
//-----------------------------------------------------------------------------
// wxScreenDC
//-----------------------------------------------------------------------------
-IMPLEMENT_DYNAMIC_CLASS(wxScreenDC,wxPaintDC)
+#if wxUSE_NEW_DC
+IMPLEMENT_ABSTRACT_CLASS(wxGTKScreenImplDC, wxGTKWindowImplDC)
+#else
+IMPLEMENT_ABSTRACT_CLASS(wxScreenDC,wxWindowDC)
+#endif
+
+#if wxUSE_NEW_DC
+wxGTKScreenImplDC::wxGTKScreenImplDC( wxScreenDC *owner )
+ : wxGTKWindowImplDC( owner )
+{
+ Init();
+}
-wxScreenDC::wxScreenDC()
+#else
+wxScreenDC::wxScreenDC()
+{
+ Init();
+}
+#endif
+
+void wxGTKScreenImplDC::Init()
{
m_ok = false;
m_cmap = gdk_colormap_get_system();
gdk_gc_set_subwindow( m_bgGC, GDK_INCLUDE_INFERIORS );
}
-wxScreenDC::~wxScreenDC()
+wxGTKScreenImplDC::~wxGTKScreenImplDC()
{
gdk_gc_set_subwindow( m_penGC, GDK_CLIP_BY_CHILDREN );
gdk_gc_set_subwindow( m_brushGC, GDK_CLIP_BY_CHILDREN );
gdk_gc_set_subwindow( m_textGC, GDK_CLIP_BY_CHILDREN );
gdk_gc_set_subwindow( m_bgGC, GDK_CLIP_BY_CHILDREN );
-
- EndDrawingOnTop();
-}
-
-bool wxScreenDC::StartDrawingOnTop( wxWindow * )
-{
- return true;
-}
-
-bool wxScreenDC::StartDrawingOnTop( wxRect * )
-{
- return true;
-}
-
-bool wxScreenDC::EndDrawingOnTop()
-{
- return true;
}
-void wxScreenDC::DoGetSize(int *width, int *height) const
+void wxGTKScreenImplDC::DoGetSize(int *width, int *height) const
{
wxDisplaySize(width, height);
}
int style = win->GetWindowStyle();
wxClientDC dc(win);
+
+#if wxUSE_NEW_DC
+ wxImplDC *impl = dc.GetImpl();
+ wxGTKClientImplDC *client_impl = wxDynamicCast( impl, wxGTKClientImplDC );
+ // Hack alert
+ client_impl->m_window = pizza->bin_window;
+#else
// Hack alert
dc.m_window = pizza->bin_window;
+#endif
if (style & wxRESIZE_BORDER)
{
{
GtkWidget *button = GetHeaderButtonWidget();
-
- GdkWindow* gdk_window = dc.GetGDKWindow();
+
+ GdkWindow* gdk_window = NULL;
+#if wxUSE_NEW_DC
+ wxImplDC *impl = dc.GetImpl();
+ wxGTKImplDC *gtk_impl = wxDynamicCast( impl, wxGTKImplDC );
+ if (gtk_impl)
+ gdk_window = gtk_impl->GetGDKWindow();
+#else
+ gdk_window = dc.GetGDKWindow();
+#endif
wxASSERT_MSG( gdk_window,
wxT("cannot use wxRendererNative on wxDC of this type") );
{
GtkWidget *tree = GetTreeWidget();
- GdkWindow* gdk_window = dc.GetGDKWindow();
+ GdkWindow* gdk_window = NULL;
+#if wxUSE_NEW_DC
+ wxImplDC *impl = dc.GetImpl();
+ wxGTKImplDC *gtk_impl = wxDynamicCast( impl, wxGTKImplDC );
+ if (gtk_impl)
+ gdk_window = gtk_impl->GetGDKWindow();
+#else
+ gdk_window = dc.GetGDKWindow();
+#endif
wxASSERT_MSG( gdk_window,
wxT("cannot use wxRendererNative on wxDC of this type") );
return;
}
- GdkWindow* gdk_window = dc.GetGDKWindow();
+ GdkWindow* gdk_window = NULL;
+#if wxUSE_NEW_DC
+ wxImplDC *impl = dc.GetImpl();
+ wxGTKImplDC *gtk_impl = wxDynamicCast( impl, wxGTKImplDC );
+ if (gtk_impl)
+ gdk_window = gtk_impl->GetGDKWindow();
+#else
+ gdk_window = dc.GetGDKWindow();
+#endif
wxASSERT_MSG( gdk_window,
wxT("cannot use wxRendererNative on wxDC of this type") );
// work for wxMemoryDC. So that is why we assume wxDC
// is wxWindowDC (wxClientDC, wxMemoryDC and wxPaintDC
// are derived from it) and use its m_window.
- GdkWindow* gdk_window = dc.GetGDKWindow();
+ GdkWindow* gdk_window = NULL;
+#if wxUSE_NEW_DC
+ wxImplDC *impl = dc.GetImpl();
+ wxGTKImplDC *gtk_impl = wxDynamicCast( impl, wxGTKImplDC );
+ if (gtk_impl)
+ gdk_window = gtk_impl->GetGDKWindow();
+#else
+ gdk_window = dc.GetGDKWindow();
+#endif
wxASSERT_MSG( gdk_window,
wxT("cannot use wxRendererNative on wxDC of this type") );
int flags )
{
GtkWidget *button = GetCheckButtonWidget();
-
- // for reason why we do this, see DrawDropArrow
- GdkWindow* gdk_window = dc.GetGDKWindow();
+
+ GdkWindow* gdk_window = NULL;
+#if wxUSE_NEW_DC
+ wxImplDC *impl = dc.GetImpl();
+ wxGTKImplDC *gtk_impl = wxDynamicCast( impl, wxGTKImplDC );
+ if (gtk_impl)
+ gdk_window = gtk_impl->GetGDKWindow();
+#else
+ gdk_window = dc.GetGDKWindow();
+#endif
wxASSERT_MSG( gdk_window,
wxT("cannot use wxRendererNative on wxDC of this type") );
{
GtkWidget *button = GetButtonWidget();
- // for reason why we do this, see DrawDropArrow
- GdkWindow* gdk_window = dc.GetGDKWindow();
+ GdkWindow* gdk_window = NULL;
+#if wxUSE_NEW_DC
+ wxImplDC *impl = dc.GetImpl();
+ wxGTKImplDC *gtk_impl = wxDynamicCast( impl, wxGTKImplDC );
+ if (gtk_impl)
+ gdk_window = gtk_impl->GetGDKWindow();
+#else
+ gdk_window = dc.GetGDKWindow();
+#endif
wxASSERT_MSG( gdk_window,
wxT("cannot use wxRendererNative on wxDC of this type") );
const wxRect& rect,
int flags )
{
- GdkWindow* gdk_window = dc.GetGDKWindow();
+ GdkWindow* gdk_window = NULL;
+#if wxUSE_NEW_DC
+ wxImplDC *impl = dc.GetImpl();
+ wxGTKImplDC *gtk_impl = wxDynamicCast( impl, wxGTKImplDC );
+ if (gtk_impl)
+ gdk_window = gtk_impl->GetGDKWindow();
+#else
+ gdk_window = dc.GetGDKWindow();
+#endif
wxASSERT_MSG( gdk_window,
wxT("cannot use wxRendererNative on wxDC of this type") );
void wxRendererGTK::DrawFocusRect(wxWindow* win, wxDC& dc, const wxRect& rect, int flags)
{
- GdkWindow* gdk_window = dc.GetGDKWindow();
+ GdkWindow* gdk_window = NULL;
+#if wxUSE_NEW_DC
+ wxImplDC *impl = dc.GetImpl();
+ wxGTKImplDC *gtk_impl = wxDynamicCast( impl, wxGTKImplDC );
+ if (gtk_impl)
+ gdk_window = gtk_impl->GetGDKWindow();
+#else
+ gdk_window = dc.GetGDKWindow();
+#endif
wxASSERT_MSG( gdk_window,
wxT("cannot use wxRendererNative on wxDC of this type") );
projects / wxWidgets.git / commitdiff
