Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Converted wxGTK's basic DC classes to new DC code

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@48910 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Robert Roebling
2007-09-23 11:27:41 +00:00
parent fc1f568e23
commit ab171e9502
16 changed files with 962 additions and 646 deletions
Download Patch File Download Diff File Expand all files Collapse all files

67
include/wx/dc.h
View File

@@ -37,6 +37,11 @@
#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
@@ -117,15 +122,16 @@ public:
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();
@@ -137,20 +143,21 @@ private:
// 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 );
};
//-----------------------------------------------------------------------------
@@ -163,7 +170,7 @@ public:
wxImplDC( wxDC *owner );
~wxImplDC();
wxDC *GetOwner() { return m_owner; }
wxDC *GetOwner() const { return m_owner; }
virtual bool IsOk() const { return m_ok; }
@@ -507,6 +514,9 @@ class wxDC: public wxObject
public:
wxDC() { m_pimpl = NULL; }
wxImplDC *GetImpl()
{ return m_pimpl; }
bool IsOk() const
{ return m_pimpl && m_pimpl->IsOk(); }
@@ -1023,21 +1033,6 @@ private:
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
//-----------------------------------------------------------------------------
@@ -1081,6 +1076,8 @@ public:
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); }

49
include/wx/dcmemory.h
View File

@@ -12,8 +12,53 @@
#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
@@ -48,6 +93,10 @@ protected:
virtual void DoSelect(const wxBitmap& bmp) = 0;
};
#endif
#if defined(__WXPALMOS__)
#include "wx/palmos/dcmemory.h"
#elif defined(__WXMSW__)

14
include/wx/dcscreen.h
View File

@@ -13,6 +13,20 @@
#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"

5
include/wx/gtk/bitmap.h
View File

@@ -137,6 +137,8 @@ private:
bool CreateFromImageAsPixbuf(const wxImage& image);
#endif // wxUSE_IMAGE
public:
// implementation only
enum Representation
{
Pixmap,
@@ -146,9 +148,6 @@ private:
// (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)
};

13
include/wx/gtk/dc.h
View File

@@ -16,16 +16,21 @@
//-----------------------------------------------------------------------------
#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); };

42
include/wx/gtk/dcclient.h
View File

@@ -27,8 +27,15 @@ class WXDLLIMPEXP_CORE wxWindowDC : public wxDC
#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();
@@ -115,9 +122,8 @@ public:
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;
@@ -126,7 +132,7 @@ public:
PangoLayout *m_layout;
PangoFontDescription *m_fontdesc;
void SetUpDC();
void SetUpDC( bool ismem = false );
void Destroy();
virtual void ComputeScaleAndOrigin();
@@ -134,7 +140,7 @@ public:
virtual GdkWindow *GetGDKWindow() const { return m_window; }
private:
DECLARE_DYNAMIC_CLASS(wxGTKWindowImplDC)
DECLARE_ABSTRACT_CLASS(wxGTKWindowImplDC)
};
//-----------------------------------------------------------------------------
@@ -149,14 +155,20 @@ class WXDLLIMPEXP_CORE wxClientDC : public wxWindowDC
#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)
};
//-----------------------------------------------------------------------------
@@ -171,11 +183,17 @@ class WXDLLIMPEXP_CORE wxPaintDC : public wxClientDC
#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__

41
include/wx/gtk/dcmemory.h
View File

@@ -16,13 +16,27 @@
// 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
@@ -36,21 +50,24 @@ public:
// 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_

34
include/wx/gtk/dcscreen.h
View File

@@ -12,37 +12,39 @@
#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

726
src/common/dcbase.cpp
View File

File diff suppressed because it is too large Load Diff

2
src/common/overlaycmn.cpp
View File

@@ -147,7 +147,7 @@ bool wxOverlayImpl::IsOk()
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();

15
src/gtk/dc.cpp
View File

@@ -18,12 +18,17 @@
//-----------------------------------------------------------------------------
#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;
@@ -32,6 +37,10 @@ wxGTKImplDC::wxGTKImplDC()
m_brush = *wxWHITE_BRUSH;
}
wxGTKImplDC::~wxGTKImplDC()
{
}
void wxGTKImplDC::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
{
m_clipping = TRUE;
@@ -49,7 +58,7 @@ void wxGTKImplDC::DoGetSizeMM( int* width, int* height ) const
{
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) );
}

341
src/gtk/dcclient.cpp
View File

@@ -253,27 +253,36 @@ static void wxFreePoolGC( GdkGC *gc )
//-----------------------------------------------------------------------------
#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") );
@@ -282,8 +291,7 @@ wxGTKWindowImplDC::wxGTKWindowImplDC( wxWindow *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();
@@ -327,15 +335,16 @@ wxGTKWindowImplDC::wxGTKWindowImplDC( wxWindow *window )
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;
}
}
@@ -349,33 +358,43 @@ wxGTKWindowImplDC::~wxGTKWindowImplDC()
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)
bool done = false;
if (isMemDC)
{
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 );
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
if (m_isMemDC && (((wxMemoryDC*)this)->m_selected.GetDepth() == 1))
if (!done)
{
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 );
}
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 (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 */
@@ -443,9 +462,9 @@ void wxGTKWindowImplDC::SetUpDC()
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,
@@ -455,7 +474,7 @@ 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
@@ -482,7 +501,7 @@ bool wxGTKWindowImplDC::DoGetPixel( wxCoord x1, wxCoord y1, wxColour *col ) cons
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)
{
@@ -496,13 +515,13 @@ void wxGTKWindowImplDC::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord
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)
@@ -516,7 +535,7 @@ void wxGTKWindowImplDC::DoCrossHair( wxCoord x, wxCoord y )
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);
@@ -610,7 +629,7 @@ void wxGTKWindowImplDC::DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y
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);
@@ -672,7 +691,7 @@ void wxGTKWindowImplDC::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width,
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) );
@@ -682,7 +701,7 @@ void wxGTKWindowImplDC::DoDrawPoint( wxCoord x, wxCoord 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;
@@ -716,7 +735,7 @@ void wxGTKWindowImplDC::DoDrawLines( int n, wxPoint points[], wxCoord xoffset, w
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;
@@ -802,7 +821,7 @@ void wxGTKWindowImplDC::DoDrawPolygon( int n, wxPoint points[], wxCoord xoffset,
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);
@@ -893,7 +912,7 @@ void wxGTKWindowImplDC::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wx
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);
@@ -911,7 +930,7 @@ void wxGTKWindowImplDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord wi
// X drawing errors with small radii
if (rr == 0)
{
DrawRectangle( x, y, width, height );
DoDrawRectangle( x, y, width, height );
return;
}
@@ -1016,7 +1035,7 @@ void wxGTKWindowImplDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord wi
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);
@@ -1083,9 +1102,9 @@ void wxGTKWindowImplDC::DoDrawBitmap( const wxBitmap &bitmap,
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;
@@ -1096,7 +1115,7 @@ void wxGTKWindowImplDC::DoDrawBitmap( const wxBitmap &bitmap,
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 );
@@ -1218,7 +1237,7 @@ bool wxGTKWindowImplDC::DoBlit( wxCoord xdest, wxCoord ydest,
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") );
@@ -1246,7 +1265,7 @@ bool wxGTKWindowImplDC::DoBlit( wxCoord xdest, wxCoord ydest,
ysrcMask = ysrc;
}
if (selected.Ok())
if (selected.IsOk())
{
is_mono = (selected.GetDepth() == 1);
@@ -1421,7 +1440,7 @@ bool wxGTKWindowImplDC::DoBlit( wxCoord xdest, wxCoord ydest,
}
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 );
@@ -1439,8 +1458,15 @@ bool wxGTKWindowImplDC::DoBlit( wxCoord xdest, wxCoord ydest,
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;
@@ -1461,7 +1487,7 @@ bool wxGTKWindowImplDC::DoBlit( wxCoord xdest, wxCoord ydest,
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;
@@ -1476,7 +1502,7 @@ void wxGTKWindowImplDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
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 )
@@ -1574,7 +1600,7 @@ void wxGTKWindowImplDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
}
// 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 );
@@ -1596,7 +1622,7 @@ void wxGTKWindowImplDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
}
// 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 );
@@ -1631,11 +1657,11 @@ void wxGTKWindowImplDC::DoDrawRotatedText( const wxString &text, wxCoord x, wxCo
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;
}
@@ -1643,7 +1669,7 @@ void wxGTKWindowImplDC::DoDrawRotatedText( const wxString &text, wxCoord x, wxCo
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);
@@ -1747,11 +1773,11 @@ void wxGTKWindowImplDC::DoGetTextExtent(const wxString &string,
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
(
@@ -1857,47 +1883,20 @@ wxCoord wxGTKWindowImplDC::GetCharHeight() const
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 );
@@ -1905,11 +1904,11 @@ void wxGTKWindowImplDC::SetFont( const wxFont &font )
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,
@@ -1929,13 +1928,13 @@ void wxGTKWindowImplDC::SetFont( const wxFont &font )
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;
@@ -2079,13 +2078,13 @@ void wxGTKWindowImplDC::SetPen( const wxPen &pen )
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;
@@ -2094,7 +2093,7 @@ void wxGTKWindowImplDC::SetBrush( const wxBrush &brush )
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)
{
@@ -2127,13 +2126,13 @@ void wxGTKWindowImplDC::SetBackground( const wxBrush &brush )
/* 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;
@@ -2145,7 +2144,7 @@ void wxGTKWindowImplDC::SetBackground( const wxBrush &brush )
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)
{
@@ -2169,7 +2168,7 @@ void wxGTKWindowImplDC::SetBackground( const wxBrush &brush )
void wxGTKWindowImplDC::SetLogicalFunction( int function )
{
wxCHECK_RET( Ok(), wxT("invalid window dc") );
wxCHECK_RET( IsOk(), wxT("invalid window dc") );
if (m_logicalFunction == function)
return;
@@ -2217,12 +2216,12 @@ void wxGTKWindowImplDC::SetLogicalFunction( int function )
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;
@@ -2236,10 +2235,10 @@ void wxGTKWindowImplDC::SetTextForeground( const wxColour &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;
@@ -2253,7 +2252,7 @@ void wxGTKWindowImplDC::SetTextBackground( const wxColour &col )
void wxGTKWindowImplDC::SetBackgroundMode( int mode )
{
wxCHECK_RET( Ok(), wxT("invalid window dc") );
wxCHECK_RET( IsOk(), wxT("invalid window dc") );
m_backgroundMode = mode;
@@ -2276,7 +2275,7 @@ void wxGTKWindowImplDC::SetPalette( const wxPalette& WXUNUSED(palette) )
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;
@@ -2286,7 +2285,8 @@ void wxGTKWindowImplDC::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width
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;
}
@@ -2303,7 +2303,11 @@ void wxGTKWindowImplDC::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord 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() );
@@ -2313,7 +2317,7 @@ void wxGTKWindowImplDC::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width
void wxGTKWindowImplDC::DoSetClippingRegionAsRegion( const wxRegion &region )
{
wxCHECK_RET( Ok(), wxT("invalid window dc") );
wxCHECK_RET( IsOk(), wxT("invalid window dc") );
if (region.Empty())
{
@@ -2335,7 +2339,11 @@ void wxGTKWindowImplDC::DoSetClippingRegionAsRegion( const wxRegion &region )
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() );
@@ -2345,9 +2353,13 @@ void wxGTKWindowImplDC::DoSetClippingRegionAsRegion( const wxRegion &region )
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();
@@ -2399,7 +2411,8 @@ void wxGTKWindowImplDC::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
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();
@@ -2409,10 +2422,14 @@ void wxGTKWindowImplDC::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
@@ -2434,14 +2451,59 @@ int wxGTKWindowImplDC::GetDepth() const
}
//-----------------------------------------------------------------------------
// 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
@@ -2463,8 +2525,23 @@ static void wxLimitRegionToSize(wxRegion& region, const wxSize& sz)
}
}
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)
@@ -2491,36 +2568,6 @@ wxGTKPaintImplDC::wxGTKPaintImplDC( wxWindow *win )
#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
// ----------------------------------------------------------------------------

111
src/gtk/dcmemory.cpp
View File

@@ -19,9 +19,56 @@
// wxMemoryDC
//-----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxMemoryDC,wxWindowDC)
#if wxUSE_NEW_DC
IMPLEMENT_ABSTRACT_CLASS(wxGTKMemoryImplDC, wxGTKWindowImplDC)
#else
IMPLEMENT_ABSTRACT_CLASS(wxMemoryDC,wxWindowDC)
#endif
void wxMemoryDC::Init()
#if wxUSE_NEW_DC
wxGTKMemoryImplDC::wxGTKMemoryImplDC( wxMemoryDC *owner )
: wxGTKWindowImplDC( owner )
{
Init();
}
wxGTKMemoryImplDC::wxGTKMemoryImplDC( wxMemoryDC *owner, wxBitmap& bitmap)
: wxGTKWindowImplDC( owner )
{
Init();
owner->SelectObject(bitmap);
}
wxGTKMemoryImplDC::wxGTKMemoryImplDC( wxMemoryDC *owner, wxDC *WXUNUSED(dc) )
: wxGTKWindowImplDC( owner )
{
Init();
}
#else
wxMemoryDC::wxMemoryDC()
{
Init();
}
wxMemoryDC::wxMemoryDC(wxBitmap& bitmap)
{
Init();
SelectObject(bitmap);
}
wxMemoryDC::wxMemoryDC( wxDC *WXUNUSED(dc) )
: wxWindowDC()
{
Init();
}
#endif
wxGTKMemoryImplDC::~wxGTKMemoryImplDC()
{
g_object_unref(m_context);
}
void wxGTKMemoryImplDC::Init()
{
m_ok = false;
@@ -35,18 +82,7 @@ void wxMemoryDC::Init()
m_fontdesc = pango_font_description_copy( pango_context_get_font_description( m_context ) );
}
wxMemoryDC::wxMemoryDC( wxDC *WXUNUSED(dc) )
: wxWindowDC()
{
Init();
}
wxMemoryDC::~wxMemoryDC()
{
g_object_unref(m_context);
}
void wxMemoryDC::DoSelect( const wxBitmap& bitmap )
void wxGTKMemoryImplDC::DoSelect( const wxBitmap& bitmap )
{
Destroy();
@@ -57,9 +93,7 @@ void wxMemoryDC::DoSelect( const wxBitmap& bitmap )
m_selected.PurgeOtherRepresentations(wxBitmap::Pixmap);
m_isMemDC = true;
SetUpDC();
SetUpDC( true );
}
else
{
@@ -68,7 +102,7 @@ void wxMemoryDC::DoSelect( const wxBitmap& bitmap )
}
}
void wxMemoryDC::SetPen( const wxPen& penOrig )
void wxGTKMemoryImplDC::SetPen( const wxPen& penOrig )
{
wxPen pen( penOrig );
if ( m_selected.Ok() &&
@@ -78,10 +112,10 @@ void wxMemoryDC::SetPen( const wxPen& penOrig )
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() &&
@@ -91,10 +125,10 @@ void wxMemoryDC::SetBrush( const wxBrush& brushOrig )
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);
@@ -105,34 +139,34 @@ void wxMemoryDC::SetBackground( const wxBrush& 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())
{
@@ -145,3 +179,20 @@ void wxMemoryDC::DoGetSize( int *width, int *height ) const
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;
}

48
src/gtk/dcscreen.cpp
View File

@@ -20,21 +20,32 @@
#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();
}
#else
wxScreenDC::wxScreenDC()
{
Init();
}
#endif
void wxGTKScreenImplDC::Init()
{
m_ok = false;
m_cmap = gdk_colormap_get_system();
@@ -57,32 +68,15 @@ wxScreenDC::wxScreenDC()
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);
}

8
src/gtk/minifram.cpp
View File

@@ -76,8 +76,16 @@ static gboolean gtk_window_own_expose_callback(GtkWidget* widget, GdkEventExpose
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)
{

82
src/gtk/renderer.cpp
View File

@@ -219,7 +219,15 @@ wxRendererGTK::DrawHeaderButton(wxWindow *win,
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") );
@@ -249,7 +257,15 @@ wxRendererGTK::DrawTreeItemButton(wxWindow* win,
{
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") );
@@ -332,7 +348,15 @@ wxRendererGTK::DrawSplitterSash(wxWindow *win,
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") );
@@ -396,7 +420,15 @@ wxRendererGTK::DrawDropArrow(wxWindow *WXUNUSED(win),
// 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") );
@@ -458,8 +490,15 @@ wxRendererGTK::DrawCheckBox(wxWindow *WXUNUSED(win),
{
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") );
@@ -497,8 +536,15 @@ wxRendererGTK::DrawPushButton(wxWindow *WXUNUSED(win),
{
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") );
@@ -533,7 +579,15 @@ wxRendererGTK::DrawItemSelectionRect(wxWindow *win,
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") );
@@ -582,7 +636,15 @@ wxRendererGTK::DrawItemSelectionRect(wxWindow *win,
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") );