]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/nonownedwnd.cpp
Remove support for Gnome printing from wxGTK.
[wxWidgets.git] / src / gtk / nonownedwnd.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/gtk/nonownedwnd.cpp
3 // Purpose: wxGTK implementation of wxNonOwnedWindow.
4 // Author: Vadim Zeitlin
5 // Created: 2011-10-12
6 // Copyright: (c) 2011 Vadim Zeitlin <vadim@wxwidgets.org>
7 // Licence: wxWindows licence
8 ///////////////////////////////////////////////////////////////////////////////
9
10 // ============================================================================
11 // declarations
12 // ============================================================================
13
14 // ----------------------------------------------------------------------------
15 // headers
16 // ----------------------------------------------------------------------------
17
18 // for compilers that support precompilation, includes "wx.h".
19 #include "wx/wxprec.h"
20
21 #ifdef __BORLANDC__
22 #pragma hdrstop
23 #endif
24
25 #ifndef WX_PRECOMP
26 #include "wx/nonownedwnd.h"
27 #include "wx/dcclient.h"
28 #include "wx/dcmemory.h"
29 #include "wx/region.h"
30 #endif // WX_PRECOMP
31
32 #include "wx/graphics.h"
33
34 #include <gtk/gtk.h>
35 #include "wx/gtk/private/gtk2-compat.h"
36
37 // ----------------------------------------------------------------------------
38 // wxNonOwnedWindowShapeImpl: base class for region and path-based classes.
39 // ----------------------------------------------------------------------------
40
41 // This class provides behaviour common to both region and path-based
42 // implementations and defines SetShape() method and virtual dtor that can be
43 // called by wxNonOwnedWindow when it's realized leaving just the
44 // implementation of DoSetShape() to the derived classes.
45 class wxNonOwnedWindowShapeImpl : public wxEvtHandler
46 {
47 public:
48 wxNonOwnedWindowShapeImpl(wxWindow* win) : m_win(win)
49 {
50 }
51
52 virtual ~wxNonOwnedWindowShapeImpl() { }
53
54 bool SetShape()
55 {
56 if ( m_win->m_wxwindow )
57 SetShapeIfNonNull(gtk_widget_get_window(m_win->m_wxwindow));
58
59 return SetShapeIfNonNull(gtk_widget_get_window(m_win->m_widget));
60 }
61
62 // Must be overridden to indicate if the data object must stay around or if
63 // it can be deleted once SetShape() was called.
64 virtual bool CanBeDeleted() const = 0;
65
66 protected:
67 wxWindow* const m_win;
68
69 private:
70 // SetShape to the given GDK window by calling DoSetShape() if it's non-NULL.
71 bool SetShapeIfNonNull(GdkWindow* window)
72 {
73 return window && DoSetShape(window);
74 }
75
76 // SetShape the shape to the given GDK window which can be either the window
77 // of m_widget or m_wxwindow of the wxWindow we're used with.
78 virtual bool DoSetShape(GdkWindow* window) = 0;
79
80 wxDECLARE_NO_COPY_CLASS(wxNonOwnedWindowShapeImpl);
81 };
82
83 // Version not using any custom shape.
84 class wxNonOwnedWindowShapeImplNone : public wxNonOwnedWindowShapeImpl
85 {
86 public:
87 wxNonOwnedWindowShapeImplNone(wxWindow* win) :
88 wxNonOwnedWindowShapeImpl(win)
89 {
90 }
91
92 virtual bool CanBeDeleted() const { return true; }
93
94 private:
95 virtual bool DoSetShape(GdkWindow* window)
96 {
97 gdk_window_shape_combine_region(window, NULL, 0, 0);
98
99 return true;
100 }
101 };
102
103 // Version using simple wxRegion.
104 class wxNonOwnedWindowShapeImplRegion : public wxNonOwnedWindowShapeImpl
105 {
106 public:
107 wxNonOwnedWindowShapeImplRegion(wxWindow* win, const wxRegion& region) :
108 wxNonOwnedWindowShapeImpl(win),
109 m_region(region)
110 {
111 }
112
113 virtual bool CanBeDeleted() const { return true; }
114
115 private:
116 virtual bool DoSetShape(GdkWindow* window)
117 {
118 gdk_window_shape_combine_region(window, m_region.GetRegion(), 0, 0);
119
120 return true;
121 }
122
123 wxRegion m_region;
124 };
125
126 #if wxUSE_GRAPHICS_CONTEXT
127
128 // Version using more complex wxGraphicsPath.
129 class wxNonOwnedWindowShapeImplPath : public wxNonOwnedWindowShapeImpl
130 {
131 public:
132 wxNonOwnedWindowShapeImplPath(wxWindow* win, const wxGraphicsPath& path) :
133 wxNonOwnedWindowShapeImpl(win),
134 m_path(path),
135 m_mask(CreateShapeBitmap(path), *wxBLACK)
136 {
137
138 m_win->Connect
139 (
140 wxEVT_PAINT,
141 wxPaintEventHandler(wxNonOwnedWindowShapeImplPath::OnPaint),
142 NULL,
143 this
144 );
145 }
146
147 virtual ~wxNonOwnedWindowShapeImplPath()
148 {
149 m_win->Disconnect
150 (
151 wxEVT_PAINT,
152 wxPaintEventHandler(wxNonOwnedWindowShapeImplPath::OnPaint),
153 NULL,
154 this
155 );
156 }
157
158 // Currently we always return false from here, if drawing the border
159 // becomes optional, we could return true if we don't need to draw it.
160 virtual bool CanBeDeleted() const { return false; }
161
162 private:
163 wxBitmap CreateShapeBitmap(const wxGraphicsPath& path)
164 {
165 // Draw the path on a bitmap to get the mask we need.
166 //
167 // Notice that using monochrome bitmap here doesn't work because of an
168 // apparent wxGraphicsContext bug in wxGTK, so use a bitmap of screen
169 // depth even if this is wasteful.
170 wxBitmap bmp(m_win->GetSize());
171
172 wxMemoryDC dc(bmp);
173
174 dc.SetBackground(*wxBLACK);
175 dc.Clear();
176
177 #ifdef __WXGTK3__
178 wxGraphicsContext* context = dc.GetGraphicsContext();
179 #else
180 wxScopedPtr<wxGraphicsContext> context(wxGraphicsContext::Create(dc));
181 #endif
182 context->SetBrush(*wxWHITE);
183 context->FillPath(path);
184
185 return bmp;
186 }
187
188 virtual bool DoSetShape(GdkWindow *window)
189 {
190 if (!m_mask)
191 return false;
192
193 #ifdef __WXGTK3__
194 cairo_region_t* region = gdk_cairo_region_create_from_surface(m_mask);
195 gdk_window_shape_combine_region(window, region, 0, 0);
196 cairo_region_destroy(region);
197 #else
198 gdk_window_shape_combine_mask(window, m_mask, 0, 0);
199 #endif
200
201 return true;
202 }
203
204 // Draw a shaped window border.
205 void OnPaint(wxPaintEvent& event)
206 {
207 event.Skip();
208
209 wxPaintDC dc(m_win);
210 #ifdef __WXGTK3__
211 wxGraphicsContext* context = dc.GetGraphicsContext();
212 #else
213 wxScopedPtr<wxGraphicsContext> context(wxGraphicsContext::Create(dc));
214 #endif
215 context->SetPen(wxPen(*wxLIGHT_GREY, 2));
216 context->StrokePath(m_path);
217 }
218
219 wxGraphicsPath m_path;
220 wxMask m_mask;
221 };
222
223 #endif // wxUSE_GRAPHICS_CONTEXT
224
225 // ============================================================================
226 // wxNonOwnedWindow implementation
227 // ============================================================================
228
229 wxNonOwnedWindow::~wxNonOwnedWindow()
230 {
231 delete m_shapeImpl;
232 }
233
234 void wxNonOwnedWindow::GTKHandleRealized()
235 {
236 wxNonOwnedWindowBase::GTKHandleRealized();
237
238 if ( m_shapeImpl )
239 {
240 m_shapeImpl->SetShape();
241
242 // We can destroy wxNonOwnedWindowShapeImplRegion immediately but need
243 // to keep wxNonOwnedWindowShapeImplPath around as it draws the border
244 // on every repaint.
245 if ( m_shapeImpl->CanBeDeleted() )
246 {
247 delete m_shapeImpl;
248 m_shapeImpl = NULL;
249 }
250 }
251 }
252
253 bool wxNonOwnedWindow::DoClearShape()
254 {
255 if ( !m_shapeImpl )
256 {
257 // Nothing to do, we don't have any custom shape.
258 return true;
259 }
260
261 if ( gtk_widget_get_realized(m_widget) )
262 {
263 // Reset the existing shape immediately.
264 wxNonOwnedWindowShapeImplNone data(this);
265 data.SetShape();
266 }
267 //else: just do nothing, deleting m_shapeImpl is enough to ensure that we
268 // don't set the custom shape later when we're realized.
269
270 delete m_shapeImpl;
271 m_shapeImpl = NULL;
272
273 return true;
274 }
275
276 bool wxNonOwnedWindow::DoSetRegionShape(const wxRegion& region)
277 {
278 // In any case get rid of the old data.
279 delete m_shapeImpl;
280 m_shapeImpl = NULL;
281
282 if ( gtk_widget_get_realized(m_widget) )
283 {
284 // We can avoid an unnecessary heap allocation and just set the shape
285 // immediately.
286 wxNonOwnedWindowShapeImplRegion data(this, region);
287 return data.SetShape();
288 }
289 else // Create an object that will set shape when we're realized.
290 {
291 m_shapeImpl = new wxNonOwnedWindowShapeImplRegion(this, region);
292
293 // In general we don't know whether we are going to succeed or not, so
294 // be optimistic.
295 return true;
296 }
297 }
298
299 #if wxUSE_GRAPHICS_CONTEXT
300
301 bool wxNonOwnedWindow::DoSetPathShape(const wxGraphicsPath& path)
302 {
303 // The logic here is simpler than above because we always create
304 // wxNonOwnedWindowShapeImplPath on the heap as we must keep it around,
305 // even if we're already realized
306
307 delete m_shapeImpl;
308 m_shapeImpl = new wxNonOwnedWindowShapeImplPath(this, path);
309
310 if ( gtk_widget_get_realized(m_widget) )
311 {
312 return m_shapeImpl->SetShape();
313 }
314 //else: will be done later from GTKHandleRealized().
315
316 return true;
317 }
318
319 #endif // wxUSE_GRAPHICS_CONTEXT