]>
Commit | Line | Data |
---|---|---|
1 | /////////////////////////////////////////////////////////////////////////////// | |
2 | // Name: src/gtk1/renderer.cpp | |
3 | // Purpose: implementation of wxRendererNative for wxGTK | |
4 | // Author: Vadim Zeitlin | |
5 | // Modified by: | |
6 | // Created: 20.07.2003 | |
7 | // Copyright: (c) 2003 Vadim Zeitlin <vadim@wxwindows.org> | |
8 | // Licence: wxWindows licence | |
9 | /////////////////////////////////////////////////////////////////////////////// | |
10 | ||
11 | // ============================================================================ | |
12 | // declarations | |
13 | // ============================================================================ | |
14 | ||
15 | // ---------------------------------------------------------------------------- | |
16 | // headers | |
17 | // ---------------------------------------------------------------------------- | |
18 | ||
19 | // for compilers that support precompilation, includes "wx.h". | |
20 | #include "wx/wxprec.h" | |
21 | ||
22 | #ifdef __BORLANDC__ | |
23 | #pragma hdrstop | |
24 | #endif | |
25 | ||
26 | #include "wx/renderer.h" | |
27 | ||
28 | #ifndef WX_PRECOMP | |
29 | #include "wx/window.h" | |
30 | #include "wx/dc.h" | |
31 | #endif | |
32 | ||
33 | #include <gtk/gtk.h> | |
34 | #include "wx/gtk1/win_gtk.h" | |
35 | #include "wx/gtk1/dcclient.h" | |
36 | ||
37 | // RR: After a correction to the orientation of the sash | |
38 | // this doesn't seem to be required anymore and it | |
39 | // seems to confuse some themes so USE_ERASE_RECT=0 | |
40 | #define USE_ERASE_RECT 0 | |
41 | ||
42 | // ---------------------------------------------------------------------------- | |
43 | // wxRendererGTK: our wxRendererNative implementation | |
44 | // ---------------------------------------------------------------------------- | |
45 | ||
46 | class WXDLLEXPORT wxRendererGTK : public wxDelegateRendererNative | |
47 | { | |
48 | public: | |
49 | // draw the header control button (used by wxListCtrl) | |
50 | virtual int DrawHeaderButton(wxWindow *win, | |
51 | wxDC& dc, | |
52 | const wxRect& rect, | |
53 | int flags = 0, | |
54 | wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE, | |
55 | wxHeaderButtonParams* params=NULL); | |
56 | ||
57 | virtual void DrawSplitterBorder(wxWindow *win, | |
58 | wxDC& dc, | |
59 | const wxRect& rect, | |
60 | int flags = 0); | |
61 | virtual void DrawSplitterSash(wxWindow *win, | |
62 | wxDC& dc, | |
63 | const wxSize& size, | |
64 | wxCoord position, | |
65 | wxOrientation orient, | |
66 | int flags = 0); | |
67 | ||
68 | virtual void DrawComboBoxDropButton(wxWindow *win, | |
69 | wxDC& dc, | |
70 | const wxRect& rect, | |
71 | int flags = 0); | |
72 | ||
73 | virtual void DrawDropArrow(wxWindow *win, | |
74 | wxDC& dc, | |
75 | const wxRect& rect, | |
76 | int flags = 0); | |
77 | ||
78 | virtual wxSplitterRenderParams GetSplitterParams(const wxWindow *win); | |
79 | ||
80 | private: | |
81 | // FIXME: shouldn't we destroy these windows somewhere? | |
82 | ||
83 | // used by DrawHeaderButton and DrawComboBoxDropButton | |
84 | static GtkWidget *GetButtonWidget(); | |
85 | }; | |
86 | ||
87 | // ============================================================================ | |
88 | // implementation | |
89 | // ============================================================================ | |
90 | ||
91 | /* static */ | |
92 | wxRendererNative& wxRendererNative::GetDefault() | |
93 | { | |
94 | static wxRendererGTK s_rendererGTK; | |
95 | ||
96 | return s_rendererGTK; | |
97 | } | |
98 | ||
99 | // ---------------------------------------------------------------------------- | |
100 | // helper functions | |
101 | // ---------------------------------------------------------------------------- | |
102 | ||
103 | GtkWidget * | |
104 | wxRendererGTK::GetButtonWidget() | |
105 | { | |
106 | static GtkWidget *s_button = NULL; | |
107 | static GtkWidget *s_window = NULL; | |
108 | ||
109 | if ( !s_button ) | |
110 | { | |
111 | s_window = gtk_window_new( GTK_WINDOW_POPUP ); | |
112 | gtk_widget_realize( s_window ); | |
113 | s_button = gtk_button_new(); | |
114 | gtk_container_add( GTK_CONTAINER(s_window), s_button ); | |
115 | gtk_widget_realize( s_button ); | |
116 | } | |
117 | ||
118 | return s_button; | |
119 | } | |
120 | ||
121 | // ---------------------------------------------------------------------------- | |
122 | // list/tree controls drawing | |
123 | // ---------------------------------------------------------------------------- | |
124 | ||
125 | int | |
126 | wxRendererGTK::DrawHeaderButton(wxWindow *win, | |
127 | wxDC& dc, | |
128 | const wxRect& rect, | |
129 | int flags, | |
130 | wxHeaderSortIconType WXUNUSED(sortArrow), | |
131 | wxHeaderButtonParams* WXUNUSED(params)) | |
132 | { | |
133 | ||
134 | GtkWidget *button = GetButtonWidget(); | |
135 | ||
136 | gtk_paint_box | |
137 | ( | |
138 | button->style, | |
139 | // FIXME: I suppose GTK_PIZZA(win->m_wxwindow)->bin_window doesn't work with wxMemoryDC. | |
140 | // Maybe use code similar as in DrawComboBoxDropButton below? | |
141 | GTK_PIZZA(win->m_wxwindow)->bin_window, | |
142 | flags & wxCONTROL_DISABLED ? GTK_STATE_INSENSITIVE : GTK_STATE_NORMAL, | |
143 | GTK_SHADOW_OUT, | |
144 | NULL, | |
145 | button, | |
146 | "button", | |
147 | dc.LogicalToDeviceX(rect.x) -1, rect.y -1, rect.width +2, rect.height +2 | |
148 | ); | |
149 | ||
150 | return rect.width + 2; | |
151 | } | |
152 | ||
153 | // ---------------------------------------------------------------------------- | |
154 | // splitter sash drawing | |
155 | // ---------------------------------------------------------------------------- | |
156 | ||
157 | // the full sash width (should be even) | |
158 | static const wxCoord SASH_SIZE = 8; | |
159 | ||
160 | // margin around the sash | |
161 | static const wxCoord SASH_MARGIN = 2; | |
162 | ||
163 | static int GetGtkSplitterFullSize() | |
164 | { | |
165 | return SASH_SIZE + SASH_MARGIN; | |
166 | } | |
167 | ||
168 | wxSplitterRenderParams | |
169 | wxRendererGTK::GetSplitterParams(const wxWindow *WXUNUSED(win)) | |
170 | { | |
171 | // we don't draw any border, hence 0 for the second field | |
172 | return wxSplitterRenderParams | |
173 | ( | |
174 | GetGtkSplitterFullSize(), | |
175 | 0, | |
176 | false // not | |
177 | ); | |
178 | } | |
179 | ||
180 | void | |
181 | wxRendererGTK::DrawSplitterBorder(wxWindow * WXUNUSED(win), | |
182 | wxDC& WXUNUSED(dc), | |
183 | const wxRect& WXUNUSED(rect), | |
184 | int WXUNUSED(flags)) | |
185 | { | |
186 | // nothing to do | |
187 | } | |
188 | ||
189 | void | |
190 | wxRendererGTK::DrawSplitterSash(wxWindow *win, | |
191 | wxDC& WXUNUSED(dc), | |
192 | const wxSize& size, | |
193 | wxCoord position, | |
194 | wxOrientation orient, | |
195 | int WXUNUSED(flags)) | |
196 | { | |
197 | if ( !win->m_wxwindow->window ) | |
198 | { | |
199 | // window not realized yet | |
200 | return; | |
201 | } | |
202 | ||
203 | wxCoord full_size = GetGtkSplitterFullSize(); | |
204 | ||
205 | // are we drawing vertical or horizontal splitter? | |
206 | const bool isVert = orient == wxVERTICAL; | |
207 | ||
208 | GdkRectangle rect; | |
209 | #if USE_ERASE_RECT | |
210 | GdkRectangle erase_rect; | |
211 | #endif | |
212 | ||
213 | if ( isVert ) | |
214 | { | |
215 | int h = win->GetClientSize().GetHeight(); | |
216 | ||
217 | rect.x = position; | |
218 | rect.y = 0; | |
219 | rect.width = full_size; | |
220 | rect.height = h; | |
221 | ||
222 | #if USE_ERASE_RECT | |
223 | erase_rect.x = position; | |
224 | erase_rect.y = 0; | |
225 | erase_rect.width = full_size; | |
226 | erase_rect.height = h; | |
227 | #endif | |
228 | } | |
229 | else // horz | |
230 | { | |
231 | int w = win->GetClientSize().GetWidth(); | |
232 | ||
233 | rect.x = 0; | |
234 | rect.y = position; | |
235 | rect.height = full_size; | |
236 | rect.width = w; | |
237 | ||
238 | #if USE_ERASE_RECT | |
239 | erase_rect.y = position; | |
240 | erase_rect.x = 0; | |
241 | erase_rect.height = full_size; | |
242 | erase_rect.width = w; | |
243 | #endif | |
244 | } | |
245 | ||
246 | #if USE_ERASE_RECT | |
247 | // we must erase everything first, otherwise the garbage | |
248 | // from the old sash is left when dragging it | |
249 | gtk_paint_flat_box | |
250 | ( | |
251 | win->m_wxwindow->style, | |
252 | GTK_PIZZA(win->m_wxwindow)->bin_window, | |
253 | GTK_STATE_NORMAL, | |
254 | GTK_SHADOW_NONE, | |
255 | NULL, | |
256 | win->m_wxwindow, | |
257 | (char *)"viewportbin", // const_cast | |
258 | erase_rect.x, | |
259 | erase_rect.y, | |
260 | erase_rect.width, | |
261 | erase_rect.height | |
262 | ); | |
263 | #endif | |
264 | ||
265 | ||
266 | // leave some margin before sash itself | |
267 | position += SASH_MARGIN / 2; | |
268 | ||
269 | // and finally draw it using GTK paint functions | |
270 | typedef void (*GtkPaintLineFunc)(GtkStyle *, GdkWindow *, | |
271 | GtkStateType, | |
272 | GdkRectangle *, GtkWidget *, | |
273 | gchar *, | |
274 | gint, gint, gint); | |
275 | ||
276 | GtkPaintLineFunc func = isVert ? gtk_paint_vline : gtk_paint_hline; | |
277 | ||
278 | (*func) | |
279 | ( | |
280 | win->m_wxwindow->style, | |
281 | GTK_PIZZA(win->m_wxwindow)->bin_window, | |
282 | GTK_STATE_NORMAL, | |
283 | NULL, | |
284 | win->m_wxwindow, | |
285 | (char *)"paned", // const_cast | |
286 | 0, isVert ? size.y : size.x, position + SASH_SIZE / 2 - 1 | |
287 | ); | |
288 | ||
289 | gtk_paint_box | |
290 | ( | |
291 | win->m_wxwindow->style, | |
292 | GTK_PIZZA(win->m_wxwindow)->bin_window, | |
293 | GTK_STATE_NORMAL, | |
294 | GTK_SHADOW_OUT, | |
295 | NULL, | |
296 | win->m_wxwindow, | |
297 | (char *)"paned", // const_cast | |
298 | isVert ? position : size.x - 2*SASH_SIZE, | |
299 | isVert ? size.y - 2*SASH_SIZE : position, | |
300 | SASH_SIZE, SASH_SIZE | |
301 | ); | |
302 | } | |
303 | ||
304 | void | |
305 | wxRendererGTK::DrawDropArrow(wxWindow *WXUNUSED(win), | |
306 | wxDC& dc, | |
307 | const wxRect& rect, | |
308 | int flags) | |
309 | { | |
310 | GtkWidget *button = GetButtonWidget(); | |
311 | ||
312 | // If we give GTK_PIZZA(win->m_wxwindow)->bin_window as | |
313 | // a window for gtk_paint_xxx function, then it won't | |
314 | // work for wxMemoryDC. So that is why we assume wxDC | |
315 | // is wxWindowDC (wxClientDC, wxMemoryDC and wxPaintDC | |
316 | // are derived from it) and use its m_window. | |
317 | wxWindowDCImpl * const impl = wxDynamicCast(dc.GetImpl(), wxWindowDCImpl); | |
318 | wxCHECK_RET( impl, "must have a window DC" ); | |
319 | ||
320 | GdkWindow* gdk_window = impl->GetGDKWindow(); | |
321 | ||
322 | // draw arrow so that there is even space horizontally | |
323 | // on both sides | |
324 | int arrowX = rect.width/4 + 1; | |
325 | int arrowWidth = rect.width - (arrowX*2); | |
326 | ||
327 | // scale arrow's height accoording to the width | |
328 | int arrowHeight = rect.width/3; | |
329 | int arrowY = (rect.height-arrowHeight)/2 + | |
330 | ((rect.height-arrowHeight) & 1); | |
331 | ||
332 | GtkStateType state; | |
333 | ||
334 | if ( flags & wxCONTROL_PRESSED ) | |
335 | state = GTK_STATE_ACTIVE; | |
336 | else if ( flags & wxCONTROL_DISABLED ) | |
337 | state = GTK_STATE_INSENSITIVE; | |
338 | else if ( flags & wxCONTROL_CURRENT ) | |
339 | state = GTK_STATE_PRELIGHT; | |
340 | else | |
341 | state = GTK_STATE_NORMAL; | |
342 | ||
343 | // draw arrow on button | |
344 | gtk_paint_arrow | |
345 | ( | |
346 | button->style, | |
347 | gdk_window, | |
348 | state, | |
349 | flags & wxCONTROL_PRESSED ? GTK_SHADOW_IN : GTK_SHADOW_OUT, | |
350 | NULL, | |
351 | button, | |
352 | "arrow", | |
353 | GTK_ARROW_DOWN, | |
354 | FALSE, | |
355 | rect.x + arrowX, | |
356 | rect.y + arrowY, | |
357 | arrowWidth, | |
358 | arrowHeight | |
359 | ); | |
360 | } | |
361 | ||
362 | void | |
363 | wxRendererGTK::DrawComboBoxDropButton(wxWindow *win, | |
364 | wxDC& dc, | |
365 | const wxRect& rect, | |
366 | int flags) | |
367 | { | |
368 | GtkWidget *button = GetButtonWidget(); | |
369 | ||
370 | // for reason why we do this, see DrawDropArrow | |
371 | wxWindowDCImpl * const impl = wxDynamicCast(dc.GetImpl(), wxWindowDCImpl); | |
372 | wxCHECK_RET( impl, "must have a window DC" ); | |
373 | ||
374 | GdkWindow* gdk_window = impl->GetGDKWindow(); | |
375 | ||
376 | // draw button | |
377 | GtkStateType state; | |
378 | ||
379 | if ( flags & wxCONTROL_PRESSED ) | |
380 | state = GTK_STATE_ACTIVE; | |
381 | else if ( flags & wxCONTROL_DISABLED ) | |
382 | state = GTK_STATE_INSENSITIVE; | |
383 | else if ( flags & wxCONTROL_CURRENT ) | |
384 | state = GTK_STATE_PRELIGHT; | |
385 | else | |
386 | state = GTK_STATE_NORMAL; | |
387 | ||
388 | gtk_paint_box | |
389 | ( | |
390 | button->style, | |
391 | gdk_window, | |
392 | state, | |
393 | flags & wxCONTROL_PRESSED ? GTK_SHADOW_IN : GTK_SHADOW_OUT, | |
394 | NULL, | |
395 | button, | |
396 | "button", | |
397 | rect.x, rect.y, rect.width, rect.height | |
398 | ); | |
399 | ||
400 | // draw arrow on button | |
401 | DrawDropArrow(win,dc,rect,flags); | |
402 | ||
403 | } |