]>
Commit | Line | Data |
---|---|---|
1 | /////////////////////////////////////////////////////////////////////////////// | |
2 | // Name: src/gtk/renderer.cpp | |
3 | // Purpose: implementation of wxRendererNative for wxGTK | |
4 | // Author: Vadim Zeitlin | |
5 | // Modified by: | |
6 | // Created: 20.07.2003 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) 2003 Vadim Zeitlin <vadim@wxwindows.org> | |
9 | // Licence: wxWindows licence | |
10 | /////////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | // ============================================================================ | |
13 | // declarations | |
14 | // ============================================================================ | |
15 | ||
16 | // ---------------------------------------------------------------------------- | |
17 | // headers | |
18 | // ---------------------------------------------------------------------------- | |
19 | ||
20 | // for compilers that support precompilation, includes "wx.h". | |
21 | #include "wx/wxprec.h" | |
22 | ||
23 | #ifdef __BORLANDC__ | |
24 | #pragma hdrstop | |
25 | #endif | |
26 | ||
27 | #include "wx/renderer.h" | |
28 | ||
29 | #ifndef WX_PRECOMP | |
30 | #include "wx/window.h" | |
31 | #include "wx/dcclient.h" | |
32 | #include "wx/settings.h" | |
33 | #include "wx/module.h" | |
34 | #endif | |
35 | ||
36 | #include "wx/dcgraph.h" | |
37 | #include "wx/gtk/dc.h" | |
38 | #include "wx/gtk/private.h" | |
39 | ||
40 | #include <gtk/gtk.h> | |
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 int GetHeaderButtonHeight(wxWindow *win); | |
58 | ||
59 | virtual int GetHeaderButtonMargin(wxWindow *win); | |
60 | ||
61 | ||
62 | // draw the expanded/collapsed icon for a tree control item | |
63 | virtual void DrawTreeItemButton(wxWindow *win, | |
64 | wxDC& dc, | |
65 | const wxRect& rect, | |
66 | int flags = 0); | |
67 | ||
68 | virtual void DrawSplitterBorder(wxWindow *win, | |
69 | wxDC& dc, | |
70 | const wxRect& rect, | |
71 | int flags = 0); | |
72 | virtual void DrawSplitterSash(wxWindow *win, | |
73 | wxDC& dc, | |
74 | const wxSize& size, | |
75 | wxCoord position, | |
76 | wxOrientation orient, | |
77 | int flags = 0); | |
78 | ||
79 | virtual void DrawComboBoxDropButton(wxWindow *win, | |
80 | wxDC& dc, | |
81 | const wxRect& rect, | |
82 | int flags = 0); | |
83 | ||
84 | virtual void DrawDropArrow(wxWindow *win, | |
85 | wxDC& dc, | |
86 | const wxRect& rect, | |
87 | int flags = 0); | |
88 | ||
89 | virtual void DrawCheckBox(wxWindow *win, | |
90 | wxDC& dc, | |
91 | const wxRect& rect, | |
92 | int flags = 0); | |
93 | ||
94 | virtual void DrawPushButton(wxWindow *win, | |
95 | wxDC& dc, | |
96 | const wxRect& rect, | |
97 | int flags = 0); | |
98 | ||
99 | virtual void DrawItemSelectionRect(wxWindow *win, | |
100 | wxDC& dc, | |
101 | const wxRect& rect, | |
102 | int flags = 0); | |
103 | ||
104 | virtual void DrawChoice(wxWindow* win, | |
105 | wxDC& dc, | |
106 | const wxRect& rect, | |
107 | int flags=0); | |
108 | ||
109 | virtual void DrawComboBox(wxWindow* win, | |
110 | wxDC& dc, | |
111 | const wxRect& rect, | |
112 | int flags=0); | |
113 | ||
114 | virtual void DrawTextCtrl(wxWindow* win, | |
115 | wxDC& dc, | |
116 | const wxRect& rect, | |
117 | int flags=0); | |
118 | ||
119 | virtual void DrawRadioBitmap(wxWindow* win, | |
120 | wxDC& dc, | |
121 | const wxRect& rect, | |
122 | int flags=0); | |
123 | ||
124 | virtual void DrawFocusRect(wxWindow* win, wxDC& dc, const wxRect& rect, int flags = 0); | |
125 | ||
126 | virtual wxSize GetCheckBoxSize(wxWindow *win); | |
127 | ||
128 | virtual wxSplitterRenderParams GetSplitterParams(const wxWindow *win); | |
129 | }; | |
130 | ||
131 | // ============================================================================ | |
132 | // implementation | |
133 | // ============================================================================ | |
134 | ||
135 | /* static */ | |
136 | wxRendererNative& wxRendererNative::GetDefault() | |
137 | { | |
138 | static wxRendererGTK s_rendererGTK; | |
139 | ||
140 | return s_rendererGTK; | |
141 | } | |
142 | ||
143 | static GdkWindow* wxGetGdkWindowForDC(wxWindow* win, wxDC& dc) | |
144 | { | |
145 | GdkWindow* gdk_window = NULL; | |
146 | ||
147 | #if wxUSE_GRAPHICS_CONTEXT | |
148 | if ( dc.IsKindOf( CLASSINFO(wxGCDC) ) ) | |
149 | gdk_window = win->GTKGetDrawingWindow(); | |
150 | else | |
151 | #endif | |
152 | { | |
153 | #if wxUSE_NEW_DC | |
154 | wxDCImpl *impl = dc.GetImpl(); | |
155 | wxGTKDCImpl *gtk_impl = wxDynamicCast( impl, wxGTKDCImpl ); | |
156 | if (gtk_impl) | |
157 | gdk_window = gtk_impl->GetGDKWindow(); | |
158 | #else | |
159 | gdk_window = dc.GetGDKWindow(); | |
160 | #endif | |
161 | } | |
162 | ||
163 | #if !wxUSE_GRAPHICS_CONTEXT | |
164 | wxUnusedVar(win); | |
165 | #endif | |
166 | ||
167 | return gdk_window; | |
168 | } | |
169 | ||
170 | // ---------------------------------------------------------------------------- | |
171 | // list/tree controls drawing | |
172 | // ---------------------------------------------------------------------------- | |
173 | ||
174 | int | |
175 | wxRendererGTK::DrawHeaderButton(wxWindow *win, | |
176 | wxDC& dc, | |
177 | const wxRect& rect, | |
178 | int flags, | |
179 | wxHeaderSortIconType sortArrow, | |
180 | wxHeaderButtonParams* params) | |
181 | { | |
182 | ||
183 | GtkWidget *button = wxGTKPrivate::GetHeaderButtonWidget(); | |
184 | if (flags & wxCONTROL_SPECIAL) | |
185 | button = wxGTKPrivate::GetHeaderButtonWidgetFirst(); | |
186 | if (flags & wxCONTROL_DIRTY) | |
187 | button = wxGTKPrivate::GetHeaderButtonWidgetLast(); | |
188 | ||
189 | GdkWindow* gdk_window = wxGetGdkWindowForDC(win, dc); | |
190 | wxASSERT_MSG( gdk_window, | |
191 | wxT("cannot use wxRendererNative on wxDC of this type") ); | |
192 | ||
193 | int x_diff = 0; | |
194 | if (win->GetLayoutDirection() == wxLayout_RightToLeft) | |
195 | x_diff = rect.width; | |
196 | ||
197 | GtkStateType state = GTK_STATE_NORMAL; | |
198 | if (flags & wxCONTROL_DISABLED) | |
199 | state = GTK_STATE_INSENSITIVE; | |
200 | else | |
201 | { | |
202 | if (flags & wxCONTROL_CURRENT) | |
203 | state = GTK_STATE_PRELIGHT; | |
204 | } | |
205 | ||
206 | gtk_paint_box | |
207 | ( | |
208 | button->style, | |
209 | gdk_window, | |
210 | state, | |
211 | GTK_SHADOW_OUT, | |
212 | NULL, | |
213 | button, | |
214 | "button", | |
215 | dc.LogicalToDeviceX(rect.x) - x_diff, rect.y, rect.width, rect.height | |
216 | ); | |
217 | ||
218 | return DrawHeaderButtonContents(win, dc, rect, flags, sortArrow, params); | |
219 | } | |
220 | ||
221 | int wxRendererGTK::GetHeaderButtonHeight(wxWindow *WXUNUSED(win)) | |
222 | { | |
223 | GtkWidget *button = wxGTKPrivate::GetHeaderButtonWidget(); | |
224 | ||
225 | GtkRequisition req; | |
226 | GTK_WIDGET_GET_CLASS(button)->size_request(button, &req); | |
227 | ||
228 | return req.height; | |
229 | } | |
230 | ||
231 | int wxRendererGTK::GetHeaderButtonMargin(wxWindow *WXUNUSED(win)) | |
232 | { | |
233 | wxFAIL_MSG( "GetHeaderButtonMargin() not implemented" ); | |
234 | return -1; | |
235 | } | |
236 | ||
237 | ||
238 | // draw a ">" or "v" button | |
239 | void | |
240 | wxRendererGTK::DrawTreeItemButton(wxWindow* win, | |
241 | wxDC& dc, const wxRect& rect, int flags) | |
242 | { | |
243 | GtkWidget *tree = wxGTKPrivate::GetTreeWidget(); | |
244 | ||
245 | GdkWindow* gdk_window = wxGetGdkWindowForDC(win, dc); | |
246 | wxASSERT_MSG( gdk_window, | |
247 | wxT("cannot use wxRendererNative on wxDC of this type") ); | |
248 | ||
249 | GtkStateType state; | |
250 | if ( flags & wxCONTROL_CURRENT ) | |
251 | state = GTK_STATE_PRELIGHT; | |
252 | else | |
253 | state = GTK_STATE_NORMAL; | |
254 | ||
255 | int x_diff = 0; | |
256 | if (win->GetLayoutDirection() == wxLayout_RightToLeft) | |
257 | x_diff = rect.width; | |
258 | ||
259 | // VZ: I don't know how to get the size of the expander so as to centre it | |
260 | // in the given rectangle, +2/3 below is just what looks good here... | |
261 | gtk_paint_expander | |
262 | ( | |
263 | tree->style, | |
264 | gdk_window, | |
265 | state, | |
266 | NULL, | |
267 | tree, | |
268 | "treeview", | |
269 | dc.LogicalToDeviceX(rect.x) + 6 - x_diff, | |
270 | dc.LogicalToDeviceY(rect.y) + 3, | |
271 | flags & wxCONTROL_EXPANDED ? GTK_EXPANDER_EXPANDED | |
272 | : GTK_EXPANDER_COLLAPSED | |
273 | ); | |
274 | } | |
275 | ||
276 | ||
277 | // ---------------------------------------------------------------------------- | |
278 | // splitter sash drawing | |
279 | // ---------------------------------------------------------------------------- | |
280 | ||
281 | static int GetGtkSplitterFullSize(GtkWidget* widget) | |
282 | { | |
283 | gint handle_size; | |
284 | gtk_widget_style_get(widget, "handle_size", &handle_size, NULL); | |
285 | ||
286 | return handle_size; | |
287 | } | |
288 | ||
289 | wxSplitterRenderParams | |
290 | wxRendererGTK::GetSplitterParams(const wxWindow *WXUNUSED(win)) | |
291 | { | |
292 | // we don't draw any border, hence 0 for the second field | |
293 | return wxSplitterRenderParams | |
294 | ( | |
295 | GetGtkSplitterFullSize(wxGTKPrivate::GetSplitterWidget()), | |
296 | 0, | |
297 | true // hot sensitive | |
298 | ); | |
299 | } | |
300 | ||
301 | void | |
302 | wxRendererGTK::DrawSplitterBorder(wxWindow * WXUNUSED(win), | |
303 | wxDC& WXUNUSED(dc), | |
304 | const wxRect& WXUNUSED(rect), | |
305 | int WXUNUSED(flags)) | |
306 | { | |
307 | // nothing to do | |
308 | } | |
309 | ||
310 | void | |
311 | wxRendererGTK::DrawSplitterSash(wxWindow* win, | |
312 | wxDC& dc, | |
313 | const wxSize& size, | |
314 | wxCoord position, | |
315 | wxOrientation orient, | |
316 | int flags) | |
317 | { | |
318 | if ( !win->m_wxwindow->window ) | |
319 | { | |
320 | // window not realized yet | |
321 | return; | |
322 | } | |
323 | ||
324 | GdkWindow* gdk_window = wxGetGdkWindowForDC(win, dc); | |
325 | wxASSERT_MSG( gdk_window, | |
326 | wxT("cannot use wxRendererNative on wxDC of this type") ); | |
327 | ||
328 | wxCoord full_size = GetGtkSplitterFullSize(wxGTKPrivate::GetSplitterWidget()); | |
329 | ||
330 | // are we drawing vertical or horizontal splitter? | |
331 | const bool isVert = orient == wxVERTICAL; | |
332 | ||
333 | GdkRectangle rect; | |
334 | ||
335 | if ( isVert ) | |
336 | { | |
337 | rect.x = position; | |
338 | rect.y = 0; | |
339 | rect.width = full_size; | |
340 | rect.height = size.y; | |
341 | } | |
342 | else // horz | |
343 | { | |
344 | rect.x = 0; | |
345 | rect.y = position; | |
346 | rect.height = full_size; | |
347 | rect.width = size.x; | |
348 | } | |
349 | ||
350 | int x_diff = 0; | |
351 | if (win->GetLayoutDirection() == wxLayout_RightToLeft) | |
352 | x_diff = rect.width; | |
353 | ||
354 | gtk_paint_handle | |
355 | ( | |
356 | win->m_wxwindow->style, | |
357 | gdk_window, | |
358 | flags & wxCONTROL_CURRENT ? GTK_STATE_PRELIGHT : GTK_STATE_NORMAL, | |
359 | GTK_SHADOW_NONE, | |
360 | NULL /* no clipping */, | |
361 | win->m_wxwindow, | |
362 | "paned", | |
363 | dc.LogicalToDeviceX(rect.x) - x_diff, | |
364 | dc.LogicalToDeviceY(rect.y), | |
365 | rect.width, | |
366 | rect.height, | |
367 | isVert ? GTK_ORIENTATION_VERTICAL : GTK_ORIENTATION_HORIZONTAL | |
368 | ); | |
369 | } | |
370 | ||
371 | void | |
372 | wxRendererGTK::DrawDropArrow(wxWindow* win, | |
373 | wxDC& dc, | |
374 | const wxRect& rect, | |
375 | int flags) | |
376 | { | |
377 | GtkWidget *button = wxGTKPrivate::GetButtonWidget(); | |
378 | ||
379 | // If we give WX_PIZZA(win->m_wxwindow)->bin_window as | |
380 | // a window for gtk_paint_xxx function, then it won't | |
381 | // work for wxMemoryDC. So that is why we assume wxDC | |
382 | // is wxWindowDC (wxClientDC, wxMemoryDC and wxPaintDC | |
383 | // are derived from it) and use its m_window. | |
384 | GdkWindow* gdk_window = wxGetGdkWindowForDC(win, dc); | |
385 | wxASSERT_MSG( gdk_window, | |
386 | wxT("cannot use wxRendererNative on wxDC of this type") ); | |
387 | ||
388 | // draw arrow so that there is even space horizontally | |
389 | // on both sides | |
390 | int arrowX = rect.width/4 + 1; | |
391 | int arrowWidth = rect.width - (arrowX*2); | |
392 | ||
393 | // scale arrow's height accoording to the width | |
394 | int arrowHeight = rect.width/3; | |
395 | int arrowY = (rect.height-arrowHeight)/2 + | |
396 | ((rect.height-arrowHeight) & 1); | |
397 | ||
398 | GtkStateType state; | |
399 | ||
400 | if ( flags & wxCONTROL_PRESSED ) | |
401 | state = GTK_STATE_ACTIVE; | |
402 | else if ( flags & wxCONTROL_DISABLED ) | |
403 | state = GTK_STATE_INSENSITIVE; | |
404 | else if ( flags & wxCONTROL_CURRENT ) | |
405 | state = GTK_STATE_PRELIGHT; | |
406 | else | |
407 | state = GTK_STATE_NORMAL; | |
408 | ||
409 | // draw arrow on button | |
410 | gtk_paint_arrow | |
411 | ( | |
412 | button->style, | |
413 | gdk_window, | |
414 | state, | |
415 | flags & wxCONTROL_PRESSED ? GTK_SHADOW_IN : GTK_SHADOW_OUT, | |
416 | NULL, | |
417 | button, | |
418 | "arrow", | |
419 | GTK_ARROW_DOWN, | |
420 | FALSE, | |
421 | rect.x + arrowX, | |
422 | rect.y + arrowY, | |
423 | arrowWidth, | |
424 | arrowHeight | |
425 | ); | |
426 | } | |
427 | ||
428 | void | |
429 | wxRendererGTK::DrawComboBoxDropButton(wxWindow *win, | |
430 | wxDC& dc, | |
431 | const wxRect& rect, | |
432 | int flags) | |
433 | { | |
434 | DrawPushButton(win,dc,rect,flags); | |
435 | DrawDropArrow(win,dc,rect); | |
436 | } | |
437 | ||
438 | wxSize | |
439 | wxRendererGTK::GetCheckBoxSize(wxWindow *WXUNUSED(win)) | |
440 | { | |
441 | gint indicator_size, indicator_spacing; | |
442 | gtk_widget_style_get(wxGTKPrivate::GetCheckButtonWidget(), | |
443 | "indicator_size", &indicator_size, | |
444 | "indicator_spacing", &indicator_spacing, | |
445 | NULL); | |
446 | ||
447 | int size = indicator_size + indicator_spacing * 2; | |
448 | return wxSize(size, size); | |
449 | } | |
450 | ||
451 | void | |
452 | wxRendererGTK::DrawCheckBox(wxWindow* win, | |
453 | wxDC& dc, | |
454 | const wxRect& rect, | |
455 | int flags ) | |
456 | { | |
457 | GtkWidget *button = wxGTKPrivate::GetCheckButtonWidget(); | |
458 | ||
459 | GdkWindow* gdk_window = wxGetGdkWindowForDC(win, dc); | |
460 | wxASSERT_MSG( gdk_window, | |
461 | wxT("cannot use wxRendererNative on wxDC of this type") ); | |
462 | ||
463 | gint indicator_size, indicator_spacing; | |
464 | gtk_widget_style_get(button, | |
465 | "indicator_size", &indicator_size, | |
466 | "indicator_spacing", &indicator_spacing, | |
467 | NULL); | |
468 | ||
469 | GtkStateType state; | |
470 | ||
471 | if ( flags & wxCONTROL_PRESSED ) | |
472 | state = GTK_STATE_ACTIVE; | |
473 | else if ( flags & wxCONTROL_DISABLED ) | |
474 | state = GTK_STATE_INSENSITIVE; | |
475 | else if ( flags & wxCONTROL_CURRENT ) | |
476 | state = GTK_STATE_PRELIGHT; | |
477 | else | |
478 | state = GTK_STATE_NORMAL; | |
479 | ||
480 | GtkShadowType shadow_type; | |
481 | ||
482 | if ( flags & wxCONTROL_UNDETERMINED ) | |
483 | shadow_type = GTK_SHADOW_ETCHED_IN; | |
484 | else if ( flags & wxCONTROL_CHECKED ) | |
485 | shadow_type = GTK_SHADOW_IN; | |
486 | else | |
487 | shadow_type = GTK_SHADOW_OUT; | |
488 | ||
489 | gtk_paint_check | |
490 | ( | |
491 | button->style, | |
492 | gdk_window, | |
493 | state, | |
494 | shadow_type, | |
495 | NULL, | |
496 | button, | |
497 | "cellcheck", | |
498 | dc.LogicalToDeviceX(rect.x) + indicator_spacing, | |
499 | dc.LogicalToDeviceY(rect.y) + indicator_spacing, | |
500 | indicator_size, indicator_size | |
501 | ); | |
502 | } | |
503 | ||
504 | void | |
505 | wxRendererGTK::DrawPushButton(wxWindow* win, | |
506 | wxDC& dc, | |
507 | const wxRect& rect, | |
508 | int flags) | |
509 | { | |
510 | GtkWidget *button = wxGTKPrivate::GetButtonWidget(); | |
511 | ||
512 | GdkWindow* gdk_window = wxGetGdkWindowForDC(win, dc); | |
513 | wxASSERT_MSG( gdk_window, | |
514 | wxT("cannot use wxRendererNative on wxDC of this type") ); | |
515 | ||
516 | // draw button | |
517 | GtkStateType state; | |
518 | ||
519 | if ( flags & wxCONTROL_PRESSED ) | |
520 | state = GTK_STATE_ACTIVE; | |
521 | else if ( flags & wxCONTROL_DISABLED ) | |
522 | state = GTK_STATE_INSENSITIVE; | |
523 | else if ( flags & wxCONTROL_CURRENT ) | |
524 | state = GTK_STATE_PRELIGHT; | |
525 | else | |
526 | state = GTK_STATE_NORMAL; | |
527 | ||
528 | gtk_paint_box | |
529 | ( | |
530 | button->style, | |
531 | gdk_window, | |
532 | state, | |
533 | flags & wxCONTROL_PRESSED ? GTK_SHADOW_IN : GTK_SHADOW_OUT, | |
534 | NULL, | |
535 | button, | |
536 | "button", | |
537 | dc.LogicalToDeviceX(rect.x), | |
538 | dc.LogicalToDeviceY(rect.y), | |
539 | rect.width, | |
540 | rect.height | |
541 | ); | |
542 | } | |
543 | ||
544 | void | |
545 | wxRendererGTK::DrawItemSelectionRect(wxWindow* win, | |
546 | wxDC& dc, | |
547 | const wxRect& rect, | |
548 | int flags ) | |
549 | { | |
550 | GdkWindow* gdk_window = wxGetGdkWindowForDC(win, dc); | |
551 | wxASSERT_MSG( gdk_window, | |
552 | wxT("cannot use wxRendererNative on wxDC of this type") ); | |
553 | ||
554 | if (flags & wxCONTROL_SELECTED) | |
555 | { | |
556 | int x_diff = 0; | |
557 | if (win->GetLayoutDirection() == wxLayout_RightToLeft) | |
558 | x_diff = rect.width; | |
559 | ||
560 | // the wxCONTROL_FOCUSED state is deduced | |
561 | // directly from the m_wxwindow by GTK+ | |
562 | gtk_paint_flat_box(wxGTKPrivate::GetTreeWidget()->style, | |
563 | gdk_window, | |
564 | GTK_STATE_SELECTED, | |
565 | GTK_SHADOW_NONE, | |
566 | NULL, | |
567 | win->m_wxwindow, | |
568 | "cell_even", | |
569 | dc.LogicalToDeviceX(rect.x) - x_diff, | |
570 | dc.LogicalToDeviceY(rect.y), | |
571 | rect.width, | |
572 | rect.height ); | |
573 | } | |
574 | ||
575 | if ((flags & wxCONTROL_CURRENT) && (flags & wxCONTROL_FOCUSED)) | |
576 | DrawFocusRect(win, dc, rect, flags); | |
577 | } | |
578 | ||
579 | void wxRendererGTK::DrawFocusRect(wxWindow* win, wxDC& dc, const wxRect& rect, int flags) | |
580 | { | |
581 | GdkWindow* gdk_window = wxGetGdkWindowForDC(win, dc); | |
582 | wxASSERT_MSG( gdk_window, | |
583 | wxT("cannot use wxRendererNative on wxDC of this type") ); | |
584 | ||
585 | GtkStateType state; | |
586 | if (flags & wxCONTROL_SELECTED) | |
587 | state = GTK_STATE_SELECTED; | |
588 | else | |
589 | state = GTK_STATE_NORMAL; | |
590 | ||
591 | gtk_paint_focus( win->m_widget->style, | |
592 | gdk_window, | |
593 | state, | |
594 | NULL, | |
595 | win->m_wxwindow, | |
596 | NULL, | |
597 | dc.LogicalToDeviceX(rect.x), | |
598 | dc.LogicalToDeviceY(rect.y), | |
599 | rect.width, | |
600 | rect.height ); | |
601 | } | |
602 | ||
603 | // Uses the theme to draw the border and fill for something like a wxTextCtrl | |
604 | void wxRendererGTK::DrawTextCtrl(wxWindow* win, wxDC& dc, const wxRect& rect, int flags) | |
605 | { | |
606 | GtkWidget *entry = wxGTKPrivate::GetTextEntryWidget(); | |
607 | ||
608 | GdkWindow* gdk_window = wxGetGdkWindowForDC(win, dc); | |
609 | ||
610 | GtkStateType state = GTK_STATE_NORMAL; | |
611 | if ( flags & wxCONTROL_DISABLED ) | |
612 | state = GTK_STATE_INSENSITIVE; | |
613 | ||
614 | if (flags & wxCONTROL_CURRENT ) | |
615 | GTK_WIDGET_SET_FLAGS( entry, GTK_HAS_FOCUS ); | |
616 | else | |
617 | GTK_WIDGET_UNSET_FLAGS( entry, GTK_HAS_FOCUS ); | |
618 | ||
619 | gtk_paint_shadow | |
620 | ( | |
621 | entry->style, | |
622 | gdk_window, | |
623 | state, | |
624 | GTK_SHADOW_OUT, | |
625 | NULL, | |
626 | entry, | |
627 | "entry", | |
628 | dc.LogicalToDeviceX(rect.x), | |
629 | dc.LogicalToDeviceY(rect.y), | |
630 | rect.width, | |
631 | rect.height | |
632 | ); | |
633 | } | |
634 | ||
635 | // Draw the equivallent of a wxComboBox | |
636 | void wxRendererGTK::DrawComboBox(wxWindow* win, wxDC& dc, const wxRect& rect, int flags) | |
637 | { | |
638 | GtkWidget *combo = wxGTKPrivate::GetComboBoxWidget(); | |
639 | ||
640 | GdkWindow* gdk_window = wxGetGdkWindowForDC(win, dc); | |
641 | ||
642 | GtkStateType state = GTK_STATE_NORMAL; | |
643 | if ( flags & wxCONTROL_DISABLED ) | |
644 | state = GTK_STATE_INSENSITIVE; | |
645 | ||
646 | if (flags & wxCONTROL_CURRENT ) | |
647 | GTK_WIDGET_SET_FLAGS( combo, GTK_HAS_FOCUS ); | |
648 | else | |
649 | GTK_WIDGET_UNSET_FLAGS( combo, GTK_HAS_FOCUS ); | |
650 | ||
651 | gtk_paint_shadow | |
652 | ( | |
653 | combo->style, | |
654 | gdk_window, | |
655 | state, | |
656 | GTK_SHADOW_OUT, | |
657 | NULL, | |
658 | combo, | |
659 | "combobox", | |
660 | dc.LogicalToDeviceX(rect.x), | |
661 | dc.LogicalToDeviceY(rect.y), | |
662 | rect.width, | |
663 | rect.height | |
664 | ); | |
665 | ||
666 | wxRect r = rect; | |
667 | int extent = rect.height / 2; | |
668 | r.x += rect.width - extent - extent/2; | |
669 | r.y += extent/2; | |
670 | r.width = extent; | |
671 | r.height = extent; | |
672 | ||
673 | gtk_paint_arrow | |
674 | ( | |
675 | combo->style, | |
676 | gdk_window, | |
677 | state, | |
678 | GTK_SHADOW_OUT, | |
679 | NULL, | |
680 | combo, | |
681 | "arrow", | |
682 | GTK_ARROW_DOWN, | |
683 | TRUE, | |
684 | dc.LogicalToDeviceX(r.x), | |
685 | dc.LogicalToDeviceY(r.y), | |
686 | r.width, | |
687 | r.height | |
688 | ); | |
689 | ||
690 | r = rect; | |
691 | r.x += rect.width - 2*extent; | |
692 | r.width = 2; | |
693 | ||
694 | gtk_paint_box | |
695 | ( | |
696 | combo->style, | |
697 | gdk_window, | |
698 | state, | |
699 | GTK_SHADOW_ETCHED_OUT, | |
700 | NULL, | |
701 | combo, | |
702 | "vseparator", | |
703 | dc.LogicalToDeviceX(r.x), | |
704 | dc.LogicalToDeviceY(r.y+1), | |
705 | r.width, | |
706 | r.height-2 | |
707 | ); | |
708 | } | |
709 | ||
710 | ||
711 | void wxRendererGTK::DrawChoice(wxWindow* win, wxDC& dc, | |
712 | const wxRect& rect, int flags) | |
713 | { | |
714 | DrawComboBox( win, dc, rect, flags ); | |
715 | } | |
716 | ||
717 | ||
718 | // Draw a themed radio button | |
719 | void wxRendererGTK::DrawRadioBitmap(wxWindow* win, wxDC& dc, const wxRect& rect, int flags) | |
720 | { | |
721 | GtkWidget *button = wxGTKPrivate::GetRadioButtonWidget(); | |
722 | ||
723 | GdkWindow* gdk_window = wxGetGdkWindowForDC(win, dc); | |
724 | ||
725 | GtkShadowType shadow_type = GTK_SHADOW_OUT; | |
726 | if ( flags & wxCONTROL_CHECKED ) | |
727 | shadow_type = GTK_SHADOW_IN; | |
728 | else if ( flags & wxCONTROL_UNDETERMINED ) | |
729 | shadow_type = GTK_SHADOW_ETCHED_IN; | |
730 | ||
731 | GtkStateType state = GTK_STATE_NORMAL; | |
732 | if ( flags & wxCONTROL_DISABLED ) | |
733 | state = GTK_STATE_INSENSITIVE; | |
734 | if ( flags & wxCONTROL_PRESSED ) | |
735 | state = GTK_STATE_ACTIVE; | |
736 | /* | |
737 | Don't know when to set this | |
738 | state_type = GTK_STATE_PRELIGHT; | |
739 | */ | |
740 | ||
741 | gtk_paint_option | |
742 | ( | |
743 | button->style, | |
744 | gdk_window, | |
745 | state, | |
746 | shadow_type, | |
747 | NULL, | |
748 | button, | |
749 | "radiobutton", | |
750 | dc.LogicalToDeviceX(rect.x), | |
751 | dc.LogicalToDeviceY(rect.y), | |
752 | rect.width, rect.height | |
753 | ); | |
754 | } |