]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/renderer.cpp
Remove all lines containing cvs/svn "$Id$" keyword.
[wxWidgets.git] / src / gtk / renderer.cpp
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 // 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/dcclient.h"
31 #include "wx/settings.h"
32 #include "wx/module.h"
33 #endif
34
35 #include "wx/dcgraph.h"
36 #ifndef __WXGTK3__
37 #include "wx/gtk/dc.h"
38 #endif
39
40 #include <gtk/gtk.h>
41 #include "wx/gtk/private.h"
42 #include "wx/gtk/private/gtk2-compat.h"
43
44 // ----------------------------------------------------------------------------
45 // wxRendererGTK: our wxRendererNative implementation
46 // ----------------------------------------------------------------------------
47
48 class WXDLLEXPORT wxRendererGTK : public wxDelegateRendererNative
49 {
50 public:
51 // draw the header control button (used by wxListCtrl)
52 virtual int DrawHeaderButton(wxWindow *win,
53 wxDC& dc,
54 const wxRect& rect,
55 int flags = 0,
56 wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE,
57 wxHeaderButtonParams* params = NULL);
58
59 virtual int GetHeaderButtonHeight(wxWindow *win);
60
61 virtual int GetHeaderButtonMargin(wxWindow *win);
62
63
64 // draw the expanded/collapsed icon for a tree control item
65 virtual void DrawTreeItemButton(wxWindow *win,
66 wxDC& dc,
67 const wxRect& rect,
68 int flags = 0);
69
70 virtual void DrawSplitterBorder(wxWindow *win,
71 wxDC& dc,
72 const wxRect& rect,
73 int flags = 0);
74 virtual void DrawSplitterSash(wxWindow *win,
75 wxDC& dc,
76 const wxSize& size,
77 wxCoord position,
78 wxOrientation orient,
79 int flags = 0);
80
81 virtual void DrawComboBoxDropButton(wxWindow *win,
82 wxDC& dc,
83 const wxRect& rect,
84 int flags = 0);
85
86 virtual void DrawDropArrow(wxWindow *win,
87 wxDC& dc,
88 const wxRect& rect,
89 int flags = 0);
90
91 virtual void DrawCheckBox(wxWindow *win,
92 wxDC& dc,
93 const wxRect& rect,
94 int flags = 0);
95
96 virtual void DrawPushButton(wxWindow *win,
97 wxDC& dc,
98 const wxRect& rect,
99 int flags = 0);
100
101 virtual void DrawItemSelectionRect(wxWindow *win,
102 wxDC& dc,
103 const wxRect& rect,
104 int flags = 0);
105
106 virtual void DrawChoice(wxWindow* win,
107 wxDC& dc,
108 const wxRect& rect,
109 int flags=0);
110
111 virtual void DrawComboBox(wxWindow* win,
112 wxDC& dc,
113 const wxRect& rect,
114 int flags=0);
115
116 virtual void DrawTextCtrl(wxWindow* win,
117 wxDC& dc,
118 const wxRect& rect,
119 int flags=0);
120
121 virtual void DrawRadioBitmap(wxWindow* win,
122 wxDC& dc,
123 const wxRect& rect,
124 int flags=0);
125
126 virtual void DrawFocusRect(wxWindow* win, wxDC& dc, const wxRect& rect, int flags = 0);
127
128 virtual wxSize GetCheckBoxSize(wxWindow *win);
129
130 virtual wxSplitterRenderParams GetSplitterParams(const wxWindow *win);
131 };
132
133 // ============================================================================
134 // implementation
135 // ============================================================================
136
137 /* static */
138 wxRendererNative& wxRendererNative::GetDefault()
139 {
140 static wxRendererGTK s_rendererGTK;
141
142 return s_rendererGTK;
143 }
144
145 #ifdef __WXGTK3__
146 #define NULL_RECT
147 typedef cairo_t wxGTKDrawable;
148
149 static cairo_t* wxGetGTKDrawable(wxWindow*, const wxDC& dc)
150 {
151 wxGraphicsContext* gc = dc.GetGraphicsContext();
152 wxCHECK_MSG(gc, NULL, "cannot use wxRendererNative on wxDC of this type");
153 return static_cast<cairo_t*>(gc->GetNativeContext());
154 }
155
156 static const GtkStateFlags stateTypeToFlags[] = {
157 GTK_STATE_FLAG_NORMAL, GTK_STATE_FLAG_ACTIVE, GTK_STATE_FLAG_PRELIGHT,
158 GTK_STATE_FLAG_SELECTED, GTK_STATE_FLAG_INSENSITIVE, GTK_STATE_FLAG_INCONSISTENT,
159 GTK_STATE_FLAG_FOCUSED
160 };
161
162 #else
163 #define NULL_RECT NULL,
164 typedef GdkWindow wxGTKDrawable;
165
166 static GdkWindow* wxGetGTKDrawable(wxWindow* win, wxDC& dc)
167 {
168 GdkWindow* gdk_window = NULL;
169
170 #if wxUSE_GRAPHICS_CONTEXT
171 if ( wxDynamicCast(&dc, wxGCDC) )
172 gdk_window = win->GTKGetDrawingWindow();
173 else
174 #endif
175 {
176 wxDCImpl *impl = dc.GetImpl();
177 wxGTKDCImpl *gtk_impl = wxDynamicCast( impl, wxGTKDCImpl );
178 if (gtk_impl)
179 gdk_window = gtk_impl->GetGDKWindow();
180 else
181 wxFAIL_MSG("cannot use wxRendererNative on wxDC of this type");
182 }
183
184 #if !wxUSE_GRAPHICS_CONTEXT
185 wxUnusedVar(win);
186 #endif
187
188 return gdk_window;
189 }
190 #endif
191
192 // ----------------------------------------------------------------------------
193 // list/tree controls drawing
194 // ----------------------------------------------------------------------------
195
196 int
197 wxRendererGTK::DrawHeaderButton(wxWindow *win,
198 wxDC& dc,
199 const wxRect& rect,
200 int flags,
201 wxHeaderSortIconType sortArrow,
202 wxHeaderButtonParams* params)
203 {
204 GtkWidget *button = wxGTKPrivate::GetHeaderButtonWidget();
205 if (flags & wxCONTROL_SPECIAL)
206 button = wxGTKPrivate::GetHeaderButtonWidgetFirst();
207 if (flags & wxCONTROL_DIRTY)
208 button = wxGTKPrivate::GetHeaderButtonWidgetLast();
209
210 int x_diff = 0;
211 if (win->GetLayoutDirection() == wxLayout_RightToLeft)
212 x_diff = rect.width;
213
214 GtkStateType state = GTK_STATE_NORMAL;
215 if (flags & wxCONTROL_DISABLED)
216 state = GTK_STATE_INSENSITIVE;
217 else
218 {
219 if (flags & wxCONTROL_CURRENT)
220 state = GTK_STATE_PRELIGHT;
221 }
222
223 #ifdef __WXGTK3__
224 cairo_t* cr = wxGetGTKDrawable(win, dc);
225 if (cr)
226 {
227 GtkStyleContext* sc = gtk_widget_get_style_context(button);
228 gtk_style_context_save(sc);
229 gtk_style_context_set_state(sc, stateTypeToFlags[state]);
230 gtk_render_background(sc, cr, rect.x - x_diff+4, rect.y+4, rect.width-8, rect.height-8);
231 gtk_render_frame(sc, cr, rect.x - x_diff+4, rect.y+4, rect.width-8, rect.height-8);
232 gtk_style_context_restore(sc);
233 }
234 #else
235 GdkWindow* gdk_window = wxGetGTKDrawable(win, dc);
236 gtk_paint_box
237 (
238 gtk_widget_get_style(button),
239 gdk_window,
240 state,
241 GTK_SHADOW_OUT,
242 NULL,
243 button,
244 "button",
245 dc.LogicalToDeviceX(rect.x) - x_diff, rect.y, rect.width, rect.height
246 );
247 #endif
248
249 return DrawHeaderButtonContents(win, dc, rect, flags, sortArrow, params);
250 }
251
252 int wxRendererGTK::GetHeaderButtonHeight(wxWindow *WXUNUSED(win))
253 {
254 GtkWidget *button = wxGTKPrivate::GetHeaderButtonWidget();
255
256 GtkRequisition req;
257 #ifdef __WXGTK3__
258 gtk_widget_get_preferred_height(button, NULL, &req.height);
259 #else
260 GTK_WIDGET_GET_CLASS(button)->size_request(button, &req);
261 #endif
262
263 return req.height;
264 }
265
266 int wxRendererGTK::GetHeaderButtonMargin(wxWindow *WXUNUSED(win))
267 {
268 wxFAIL_MSG( "GetHeaderButtonMargin() not implemented" );
269 return -1;
270 }
271
272
273 // draw a ">" or "v" button
274 void
275 wxRendererGTK::DrawTreeItemButton(wxWindow* win,
276 wxDC& dc, const wxRect& rect, int flags)
277 {
278 GtkWidget *tree = wxGTKPrivate::GetTreeWidget();
279
280 GtkStateType state;
281 if ( flags & wxCONTROL_CURRENT )
282 state = GTK_STATE_PRELIGHT;
283 else
284 state = GTK_STATE_NORMAL;
285
286 int x_diff = 0;
287 if (win->GetLayoutDirection() == wxLayout_RightToLeft)
288 x_diff = rect.width;
289
290 #ifdef __WXGTK3__
291 cairo_t* cr = wxGetGTKDrawable(win, dc);
292 if (cr)
293 {
294 gtk_widget_set_state_flags(tree, stateTypeToFlags[state], true);
295 GtkStyleContext* sc = gtk_widget_get_style_context(tree);
296 gtk_render_expander(sc, cr, rect.x - x_diff, rect.y, rect.width, rect.height);
297 }
298 #else
299 // x and y parameters specify the center of the expander
300 GdkWindow* gdk_window = wxGetGTKDrawable(win, dc);
301 if (gdk_window == NULL)
302 return;
303 gtk_paint_expander
304 (
305 gtk_widget_get_style(tree),
306 gdk_window,
307 state,
308 NULL,
309 tree,
310 "treeview",
311 dc.LogicalToDeviceX(rect.x) + rect.width / 2 - x_diff,
312 dc.LogicalToDeviceY(rect.y) + rect.height / 2,
313 flags & wxCONTROL_EXPANDED ? GTK_EXPANDER_EXPANDED
314 : GTK_EXPANDER_COLLAPSED
315 );
316 #endif
317 }
318
319
320 // ----------------------------------------------------------------------------
321 // splitter sash drawing
322 // ----------------------------------------------------------------------------
323
324 static int GetGtkSplitterFullSize(GtkWidget* widget)
325 {
326 gint handle_size;
327 gtk_widget_style_get(widget, "handle_size", &handle_size, NULL);
328
329 return handle_size;
330 }
331
332 wxSplitterRenderParams
333 wxRendererGTK::GetSplitterParams(const wxWindow *WXUNUSED(win))
334 {
335 // we don't draw any border, hence 0 for the second field
336 return wxSplitterRenderParams
337 (
338 GetGtkSplitterFullSize(wxGTKPrivate::GetSplitterWidget()),
339 0,
340 true // hot sensitive
341 );
342 }
343
344 void
345 wxRendererGTK::DrawSplitterBorder(wxWindow * WXUNUSED(win),
346 wxDC& WXUNUSED(dc),
347 const wxRect& WXUNUSED(rect),
348 int WXUNUSED(flags))
349 {
350 // nothing to do
351 }
352
353 void
354 wxRendererGTK::DrawSplitterSash(wxWindow* win,
355 wxDC& dc,
356 const wxSize& size,
357 wxCoord position,
358 wxOrientation orient,
359 int flags)
360 {
361 if (gtk_widget_get_window(win->m_wxwindow) == NULL)
362 {
363 // window not realized yet
364 return;
365 }
366
367 wxGTKDrawable* drawable = wxGetGTKDrawable(win, dc);
368 if (drawable == NULL)
369 return;
370
371 // are we drawing vertical or horizontal splitter?
372 const bool isVert = orient == wxVERTICAL;
373
374 GtkWidget* widget = wxGTKPrivate::GetSplitterWidget(orient);
375 const int full_size = GetGtkSplitterFullSize(widget);
376
377 GdkRectangle rect;
378
379 if ( isVert )
380 {
381 rect.x = position;
382 rect.y = 0;
383 rect.width = full_size;
384 rect.height = size.y;
385 }
386 else // horz
387 {
388 rect.x = 0;
389 rect.y = position;
390 rect.height = full_size;
391 rect.width = size.x;
392 }
393
394 int x_diff = 0;
395 if (win->GetLayoutDirection() == wxLayout_RightToLeft)
396 x_diff = rect.width;
397
398 #ifdef __WXGTK3__
399 cairo_t* cr = wxGetGTKDrawable(win, dc);
400 if (cr)
401 {
402 gtk_widget_set_state_flags(widget, stateTypeToFlags[flags & wxCONTROL_CURRENT ? GTK_STATE_PRELIGHT : GTK_STATE_NORMAL], true);
403 GtkStyleContext* sc = gtk_widget_get_style_context(widget);
404 gtk_render_handle(sc, cr, rect.x - x_diff, rect.y, rect.width, rect.height);
405 }
406 #else
407 GdkWindow* gdk_window = wxGetGTKDrawable(win, dc);
408 if (gdk_window == NULL)
409 return;
410 gtk_paint_handle
411 (
412 gtk_widget_get_style(win->m_wxwindow),
413 gdk_window,
414 flags & wxCONTROL_CURRENT ? GTK_STATE_PRELIGHT : GTK_STATE_NORMAL,
415 GTK_SHADOW_NONE,
416 NULL /* no clipping */,
417 win->m_wxwindow,
418 "paned",
419 dc.LogicalToDeviceX(rect.x) - x_diff,
420 dc.LogicalToDeviceY(rect.y),
421 rect.width,
422 rect.height,
423 isVert ? GTK_ORIENTATION_VERTICAL : GTK_ORIENTATION_HORIZONTAL
424 );
425 #endif
426 }
427
428 void
429 wxRendererGTK::DrawDropArrow(wxWindow* win,
430 wxDC& dc,
431 const wxRect& rect,
432 int flags)
433 {
434 GtkWidget *button = wxGTKPrivate::GetButtonWidget();
435
436 // If we give WX_PIZZA(win->m_wxwindow)->bin_window as
437 // a window for gtk_paint_xxx function, then it won't
438 // work for wxMemoryDC. So that is why we assume wxDC
439 // is wxWindowDC (wxClientDC, wxMemoryDC and wxPaintDC
440 // are derived from it) and use its m_window.
441
442 // draw arrow so that there is even space horizontally
443 // on both sides
444 const int size = rect.width / 2;
445 const int x = rect.x + (size + 1) / 2;
446 const int y = rect.y + (rect.height - size + 1) / 2;
447
448 GtkStateType state;
449
450 if ( flags & wxCONTROL_PRESSED )
451 state = GTK_STATE_ACTIVE;
452 else if ( flags & wxCONTROL_DISABLED )
453 state = GTK_STATE_INSENSITIVE;
454 else if ( flags & wxCONTROL_CURRENT )
455 state = GTK_STATE_PRELIGHT;
456 else
457 state = GTK_STATE_NORMAL;
458
459 #ifdef __WXGTK3__
460 cairo_t* cr = wxGetGTKDrawable(win, dc);
461 if (cr)
462 {
463 gtk_widget_set_state_flags(button, stateTypeToFlags[state], true);
464 GtkStyleContext* sc = gtk_widget_get_style_context(button);
465 gtk_render_arrow(sc, cr, G_PI, x, y, size);
466 }
467 #else
468 GdkWindow* gdk_window = wxGetGTKDrawable(win, dc);
469 if (gdk_window == NULL)
470 return;
471 // draw arrow on button
472 gtk_paint_arrow
473 (
474 gtk_widget_get_style(button),
475 gdk_window,
476 state,
477 flags & wxCONTROL_PRESSED ? GTK_SHADOW_IN : GTK_SHADOW_OUT,
478 NULL,
479 button,
480 "arrow",
481 GTK_ARROW_DOWN,
482 FALSE,
483 x, y,
484 size, size
485 );
486 #endif
487 }
488
489 void
490 wxRendererGTK::DrawComboBoxDropButton(wxWindow *win,
491 wxDC& dc,
492 const wxRect& rect,
493 int flags)
494 {
495 DrawPushButton(win,dc,rect,flags);
496 DrawDropArrow(win,dc,rect);
497 }
498
499 wxSize
500 wxRendererGTK::GetCheckBoxSize(wxWindow *WXUNUSED(win))
501 {
502 gint indicator_size, indicator_spacing;
503 gtk_widget_style_get(wxGTKPrivate::GetCheckButtonWidget(),
504 "indicator_size", &indicator_size,
505 "indicator_spacing", &indicator_spacing,
506 NULL);
507
508 int size = indicator_size + indicator_spacing * 2;
509 return wxSize(size, size);
510 }
511
512 void
513 wxRendererGTK::DrawCheckBox(wxWindow* win,
514 wxDC& dc,
515 const wxRect& rect,
516 int flags )
517 {
518 GtkWidget *button = wxGTKPrivate::GetCheckButtonWidget();
519
520 gint indicator_size, indicator_spacing;
521 gtk_widget_style_get(button,
522 "indicator_size", &indicator_size,
523 "indicator_spacing", &indicator_spacing,
524 NULL);
525
526 #ifndef __WXGTK3__
527 GtkStateType state;
528
529 if ( flags & wxCONTROL_PRESSED )
530 state = GTK_STATE_ACTIVE;
531 else if ( flags & wxCONTROL_DISABLED )
532 state = GTK_STATE_INSENSITIVE;
533 else if ( flags & wxCONTROL_CURRENT )
534 state = GTK_STATE_PRELIGHT;
535 else
536 state = GTK_STATE_NORMAL;
537
538 GtkShadowType shadow_type;
539
540 if ( flags & wxCONTROL_UNDETERMINED )
541 shadow_type = GTK_SHADOW_ETCHED_IN;
542 else if ( flags & wxCONTROL_CHECKED )
543 shadow_type = GTK_SHADOW_IN;
544 else
545 shadow_type = GTK_SHADOW_OUT;
546 #endif
547
548 #ifdef __WXGTK3__
549 cairo_t* cr = wxGetGTKDrawable(win, dc);
550 if (cr)
551 {
552 int stateFlags = GTK_STATE_FLAG_NORMAL;
553 if (flags & wxCONTROL_CHECKED)
554 stateFlags = GTK_STATE_FLAG_ACTIVE;
555 if (flags & wxCONTROL_DISABLED)
556 stateFlags |= GTK_STATE_FLAG_INSENSITIVE;
557 if (flags & wxCONTROL_UNDETERMINED)
558 stateFlags |= GTK_STATE_FLAG_INCONSISTENT;
559 if (flags & wxCONTROL_CURRENT)
560 stateFlags |= GTK_STATE_FLAG_PRELIGHT;
561 GtkStyleContext* sc = gtk_widget_get_style_context(button);
562 gtk_style_context_save(sc);
563 gtk_style_context_set_state(sc, GtkStateFlags(stateFlags));
564 gtk_style_context_add_class(sc, GTK_STYLE_CLASS_CHECK);
565 gtk_render_check(sc, cr,
566 rect.x + (rect.width - indicator_size) / 2,
567 rect.y + (rect.height - indicator_size) / 2,
568 indicator_size, indicator_size);
569 gtk_style_context_restore(sc);
570 }
571 #else
572 GdkWindow* gdk_window = wxGetGTKDrawable(win, dc);
573 if (gdk_window == NULL)
574 return;
575
576 gtk_paint_check
577 (
578 gtk_widget_get_style(button),
579 gdk_window,
580 state,
581 shadow_type,
582 NULL,
583 button,
584 "cellcheck",
585 dc.LogicalToDeviceX(rect.x) + indicator_spacing,
586 dc.LogicalToDeviceY(rect.y) + indicator_spacing,
587 indicator_size, indicator_size
588 );
589 #endif
590 }
591
592 void
593 wxRendererGTK::DrawPushButton(wxWindow* win,
594 wxDC& dc,
595 const wxRect& rect,
596 int flags)
597 {
598 GtkWidget *button = wxGTKPrivate::GetButtonWidget();
599
600 // draw button
601 GtkStateType state;
602
603 if ( flags & wxCONTROL_PRESSED )
604 state = GTK_STATE_ACTIVE;
605 else if ( flags & wxCONTROL_DISABLED )
606 state = GTK_STATE_INSENSITIVE;
607 else if ( flags & wxCONTROL_CURRENT )
608 state = GTK_STATE_PRELIGHT;
609 else
610 state = GTK_STATE_NORMAL;
611
612 #ifdef __WXGTK3__
613 cairo_t* cr = wxGetGTKDrawable(win, dc);
614 if (cr)
615 {
616 GtkStyleContext* sc = gtk_widget_get_style_context(button);
617 gtk_style_context_save(sc);
618 gtk_style_context_set_state(sc, stateTypeToFlags[state]);
619 gtk_render_background(sc, cr, rect.x, rect.y, rect.width, rect.height);
620 gtk_render_frame(sc, cr, rect.x, rect.y, rect.width, rect.height);
621 gtk_style_context_restore(sc);
622 }
623 #else
624 GdkWindow* gdk_window = wxGetGTKDrawable(win, dc);
625 if (gdk_window == NULL)
626 return;
627
628 gtk_paint_box
629 (
630 gtk_widget_get_style(button),
631 gdk_window,
632 state,
633 flags & wxCONTROL_PRESSED ? GTK_SHADOW_IN : GTK_SHADOW_OUT,
634 NULL,
635 button,
636 "button",
637 dc.LogicalToDeviceX(rect.x),
638 dc.LogicalToDeviceY(rect.y),
639 rect.width,
640 rect.height
641 );
642 #endif
643 }
644
645 void
646 wxRendererGTK::DrawItemSelectionRect(wxWindow* win,
647 wxDC& dc,
648 const wxRect& rect,
649 int flags )
650 {
651 wxGTKDrawable* drawable = wxGetGTKDrawable(win, dc);
652 if (drawable == NULL)
653 return;
654
655 if (flags & wxCONTROL_SELECTED)
656 {
657 int x_diff = 0;
658 if (win->GetLayoutDirection() == wxLayout_RightToLeft)
659 x_diff = rect.width;
660
661 GtkWidget* treeWidget = wxGTKPrivate::GetTreeWidget();
662
663 #ifdef __WXGTK3__
664 GtkStyleContext* sc = gtk_widget_get_style_context(treeWidget);
665 gtk_style_context_save(sc);
666 gtk_style_context_set_state(sc, GTK_STATE_FLAG_SELECTED);
667 gtk_style_context_add_class(sc, GTK_STYLE_CLASS_CELL);
668 gtk_render_background(sc, drawable, rect.x - x_diff, rect.y, rect.width, rect.height);
669 gtk_style_context_restore(sc);
670 #else
671 // the wxCONTROL_FOCUSED state is deduced
672 // directly from the m_wxwindow by GTK+
673 gtk_paint_flat_box(gtk_widget_get_style(treeWidget),
674 drawable,
675 GTK_STATE_SELECTED,
676 GTK_SHADOW_NONE,
677 NULL_RECT
678 win->m_wxwindow,
679 "cell_even",
680 dc.LogicalToDeviceX(rect.x) - x_diff,
681 dc.LogicalToDeviceY(rect.y),
682 rect.width,
683 rect.height );
684 #endif
685 }
686
687 if ((flags & wxCONTROL_CURRENT) && (flags & wxCONTROL_FOCUSED))
688 DrawFocusRect(win, dc, rect, flags);
689 }
690
691 void wxRendererGTK::DrawFocusRect(wxWindow* win, wxDC& dc, const wxRect& rect, int flags)
692 {
693 wxGTKDrawable* drawable = wxGetGTKDrawable(win, dc);
694 if (drawable == NULL)
695 return;
696
697 GtkStateType state;
698 if (flags & wxCONTROL_SELECTED)
699 state = GTK_STATE_SELECTED;
700 else
701 state = GTK_STATE_NORMAL;
702
703 #ifdef __WXGTK3__
704 GtkStyleContext* sc = gtk_widget_get_style_context(win->m_widget);
705 gtk_style_context_save(sc);
706 gtk_style_context_set_state(sc, stateTypeToFlags[state]);
707 gtk_render_focus(sc, drawable, rect.x, rect.y, rect.width, rect.height);
708 gtk_style_context_restore(sc);
709 #else
710 gtk_paint_focus( gtk_widget_get_style(win->m_widget),
711 drawable,
712 state,
713 NULL_RECT
714 win->m_wxwindow,
715 NULL,
716 dc.LogicalToDeviceX(rect.x),
717 dc.LogicalToDeviceY(rect.y),
718 rect.width,
719 rect.height );
720 #endif
721 }
722
723 // Uses the theme to draw the border and fill for something like a wxTextCtrl
724 void wxRendererGTK::DrawTextCtrl(wxWindow* win, wxDC& dc, const wxRect& rect, int flags)
725 {
726 wxGTKDrawable* drawable = wxGetGTKDrawable(win, dc);
727 if (drawable == NULL)
728 return;
729
730 GtkWidget* entry = wxGTKPrivate::GetTextEntryWidget();
731
732 GtkStateType state = GTK_STATE_NORMAL;
733 if ( flags & wxCONTROL_DISABLED )
734 state = GTK_STATE_INSENSITIVE;
735
736 gtk_widget_set_can_focus(entry, (flags & wxCONTROL_CURRENT) != 0);
737
738 #ifdef __WXGTK3__
739 GtkStyleContext* sc = gtk_widget_get_style_context(entry);
740 gtk_style_context_save(sc);
741 gtk_style_context_set_state(sc, stateTypeToFlags[state]);
742 gtk_render_background(sc, drawable, rect.x, rect.y, rect.width, rect.height);
743 gtk_render_frame(sc, drawable, rect.x, rect.y, rect.width, rect.height);
744 gtk_style_context_restore(sc);
745 #else
746 gtk_paint_shadow
747 (
748 gtk_widget_get_style(entry),
749 drawable,
750 state,
751 GTK_SHADOW_OUT,
752 NULL_RECT
753 entry,
754 "entry",
755 dc.LogicalToDeviceX(rect.x),
756 dc.LogicalToDeviceY(rect.y),
757 rect.width,
758 rect.height
759 );
760 #endif
761 }
762
763 // Draw the equivalent of a wxComboBox
764 void wxRendererGTK::DrawComboBox(wxWindow* win, wxDC& dc, const wxRect& rect, int flags)
765 {
766 wxGTKDrawable* drawable = wxGetGTKDrawable(win, dc);
767 if (drawable == NULL)
768 return;
769
770 GtkWidget* combo = wxGTKPrivate::GetComboBoxWidget();
771
772 GtkStateType state = GTK_STATE_NORMAL;
773 if ( flags & wxCONTROL_DISABLED )
774 state = GTK_STATE_INSENSITIVE;
775
776 gtk_widget_set_can_focus(combo, (flags & wxCONTROL_CURRENT) != 0);
777
778 #ifdef __WXGTK3__
779 GtkStyleContext* sc = gtk_widget_get_style_context(combo);
780 gtk_style_context_save(sc);
781 gtk_style_context_set_state(sc, stateTypeToFlags[state]);
782 gtk_render_background(sc, drawable, rect.x, rect.y, rect.width, rect.height);
783 gtk_render_frame(sc, drawable, rect.x, rect.y, rect.width, rect.height);
784 gtk_style_context_restore(sc);
785 wxRect r = rect;
786 r.x += r.width - r.height;
787 r.width = r.height;
788 DrawComboBoxDropButton(win, dc, r, flags);
789 #else
790 gtk_paint_shadow
791 (
792 gtk_widget_get_style(combo),
793 drawable,
794 state,
795 GTK_SHADOW_OUT,
796 NULL_RECT
797 combo,
798 "combobox",
799 dc.LogicalToDeviceX(rect.x),
800 dc.LogicalToDeviceY(rect.y),
801 rect.width,
802 rect.height
803 );
804
805 wxRect r = rect;
806 int extent = rect.height / 2;
807 r.x += rect.width - extent - extent/2;
808 r.y += extent/2;
809 r.width = extent;
810 r.height = extent;
811
812 gtk_paint_arrow
813 (
814 gtk_widget_get_style(combo),
815 drawable,
816 state,
817 GTK_SHADOW_OUT,
818 NULL_RECT
819 combo,
820 "arrow",
821 GTK_ARROW_DOWN,
822 TRUE,
823 dc.LogicalToDeviceX(r.x),
824 dc.LogicalToDeviceY(r.y),
825 r.width,
826 r.height
827 );
828
829 r = rect;
830 r.x += rect.width - 2*extent;
831 r.width = 2;
832
833 gtk_paint_box
834 (
835 gtk_widget_get_style(combo),
836 drawable,
837 state,
838 GTK_SHADOW_ETCHED_OUT,
839 NULL_RECT
840 combo,
841 "vseparator",
842 dc.LogicalToDeviceX(r.x),
843 dc.LogicalToDeviceY(r.y+1),
844 r.width,
845 r.height-2
846 );
847 #endif
848 }
849
850 void wxRendererGTK::DrawChoice(wxWindow* win, wxDC& dc,
851 const wxRect& rect, int flags)
852 {
853 DrawComboBox( win, dc, rect, flags );
854 }
855
856
857 // Draw a themed radio button
858 void wxRendererGTK::DrawRadioBitmap(wxWindow* win, wxDC& dc, const wxRect& rect, int flags)
859 {
860 wxGTKDrawable* drawable = wxGetGTKDrawable(win, dc);
861 if (drawable == NULL)
862 return;
863
864 GtkWidget* button = wxGTKPrivate::GetRadioButtonWidget();
865
866 #ifdef __WXGTK3__
867 int state = GTK_STATE_FLAG_NORMAL;
868 if (flags & wxCONTROL_CHECKED)
869 state = GTK_STATE_FLAG_ACTIVE;
870 else if (flags & wxCONTROL_UNDETERMINED)
871 state = GTK_STATE_FLAG_INCONSISTENT;
872 if (flags & wxCONTROL_DISABLED)
873 state |= GTK_STATE_FLAG_INSENSITIVE;
874
875 GtkStyleContext* sc = gtk_widget_get_style_context(button);
876 gtk_style_context_save(sc);
877 gtk_style_context_add_class(sc, GTK_STYLE_CLASS_RADIO);
878 gtk_style_context_set_state(sc, GtkStateFlags(state));
879 gtk_render_option(sc, drawable, rect.x, rect.y, rect.width, rect.height);
880 gtk_style_context_restore(sc);
881 #else
882 GtkShadowType shadow_type = GTK_SHADOW_OUT;
883 if ( flags & wxCONTROL_CHECKED )
884 shadow_type = GTK_SHADOW_IN;
885 else if ( flags & wxCONTROL_UNDETERMINED )
886 shadow_type = GTK_SHADOW_ETCHED_IN;
887
888 GtkStateType state = GTK_STATE_NORMAL;
889 if ( flags & wxCONTROL_DISABLED )
890 state = GTK_STATE_INSENSITIVE;
891 if ( flags & wxCONTROL_PRESSED )
892 state = GTK_STATE_ACTIVE;
893 /*
894 Don't know when to set this
895 state_type = GTK_STATE_PRELIGHT;
896 */
897
898 gtk_paint_option
899 (
900 gtk_widget_get_style(button),
901 drawable,
902 state,
903 shadow_type,
904 NULL_RECT
905 button,
906 "radiobutton",
907 dc.LogicalToDeviceX(rect.x),
908 dc.LogicalToDeviceY(rect.y),
909 rect.width, rect.height
910 );
911 #endif
912 }