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 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2003 Vadim Zeitlin <vadim@wxwindows.org>
   9 // License:     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 #endif
  34
  35 #include <gtk/gtk.h>
  36 #include "wx/gtk/win_gtk.h"
  37
  38 // ----------------------------------------------------------------------------
  39 // wxRendererGTK: our wxRendererNative implementation
  40 // ----------------------------------------------------------------------------
  41
  42 class WXDLLEXPORT wxRendererGTK : public wxDelegateRendererNative
  43 {
  44 public:
  45     // draw the header control button (used by wxListCtrl)
  46     virtual int  DrawHeaderButton(wxWindow *win,
  47                                   wxDC& dc,
  48                                   const wxRect& rect,
  49                                   int flags = 0,
  50                                   wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE,
  51                                   wxHeaderButtonParams* params = NULL);
  52
  53     // draw the expanded/collapsed icon for a tree control item
  54     virtual void DrawTreeItemButton(wxWindow *win,
  55                                     wxDC& dc,
  56                                     const wxRect& rect,
  57                                     int flags = 0);
  58
  59     virtual void DrawSplitterBorder(wxWindow *win,
  60                                     wxDC& dc,
  61                                     const wxRect& rect,
  62                                     int flags = 0);
  63     virtual void DrawSplitterSash(wxWindow *win,
  64                                   wxDC& dc,
  65                                   const wxSize& size,
  66                                   wxCoord position,
  67                                   wxOrientation orient,
  68                                   int flags = 0);
  69
  70     virtual void DrawComboBoxDropButton(wxWindow *win,
  71                                         wxDC& dc,
  72                                         const wxRect& rect,
  73                                         int flags = 0);
  74
  75     virtual void DrawDropArrow(wxWindow *win,
  76                                wxDC& dc,
  77                                const wxRect& rect,
  78                                int flags = 0);
  79
  80     virtual void DrawCheckBox(wxWindow *win,
  81                               wxDC& dc,
  82                               const wxRect& rect,
  83                               int flags = 0);
  84
  85     virtual void DrawPushButton(wxWindow *win,
  86                                 wxDC& dc,
  87                                 const wxRect& rect,
  88                                 int flags = 0);
  89
  90     virtual void DrawItemSelectionRect(wxWindow *win,
  91                                        wxDC& dc,
  92                                        const wxRect& rect,
  93                                        int flags = 0);
  94
  95     virtual wxSplitterRenderParams GetSplitterParams(const wxWindow *win);
  96
  97 private:
  98     // FIXME: shouldn't we destroy these windows somewhere?
  99
 100     // used by DrawPushButton and DrawDropArrow
 101     static GtkWidget *GetButtonWidget();
 102
 103     // used by DrawTreeItemButton()
 104     static GtkWidget *GetTreeWidget();
 105
 106     // used by DrawCheckBox()
 107     static GtkWidget *GetCheckButtonWidget();
 108
 109     // Used by DrawHeaderButton
 110     static GtkWidget *GetHeaderButtonWidget();
 111 };
 112
 113 // ============================================================================
 114 // implementation
 115 // ============================================================================
 116
 117 /* static */
 118 wxRendererNative& wxRendererNative::GetDefault()
 119 {
 120     static wxRendererGTK s_rendererGTK;
 121
 122     return s_rendererGTK;
 123 }
 124
 125 // ----------------------------------------------------------------------------
 126 // helper functions
 127 // ----------------------------------------------------------------------------
 128
 129 GtkWidget *
 130 wxRendererGTK::GetButtonWidget()
 131 {
 132     static GtkWidget *s_button = NULL;
 133     static GtkWidget *s_window = NULL;
 134
 135     if ( !s_button )
 136     {
 137         s_window = gtk_window_new( GTK_WINDOW_POPUP );
 138         gtk_widget_realize( s_window );
 139         s_button = gtk_button_new();
 140         gtk_container_add( GTK_CONTAINER(s_window), s_button );
 141         gtk_widget_realize( s_button );
 142     }
 143
 144     return s_button;
 145 }
 146
 147 GtkWidget *
 148 wxRendererGTK::GetCheckButtonWidget()
 149 {
 150     static GtkWidget *s_button = NULL;
 151     static GtkWidget *s_window = NULL;
 152
 153     if ( !s_button )
 154     {
 155         s_window = gtk_window_new( GTK_WINDOW_POPUP );
 156         gtk_widget_realize( s_window );
 157         s_button = gtk_check_button_new();
 158         gtk_container_add( GTK_CONTAINER(s_window), s_button );
 159         gtk_widget_realize( s_button );
 160     }
 161
 162     return s_button;
 163 }
 164
 165 GtkWidget *
 166 wxRendererGTK::GetTreeWidget()
 167 {
 168     static GtkWidget *s_tree = NULL;
 169     static GtkWidget *s_window = NULL;
 170
 171     if ( !s_tree )
 172     {
 173         s_tree = gtk_tree_view_new();
 174         s_window = gtk_window_new( GTK_WINDOW_POPUP );
 175         gtk_widget_realize( s_window );
 176         gtk_container_add( GTK_CONTAINER(s_window), s_tree );
 177         gtk_widget_realize( s_tree );
 178     }
 179
 180     return s_tree;
 181 }
 182
 183
 184 // This one just makes a button be a child of a tree widget.  This is
 185 // apparently how gtk themes decide to draw column headers differently than
 186 // normal buttons.
 187 GtkWidget *
 188 wxRendererGTK::GetHeaderButtonWidget()
 189 {
 190     static GtkWidget *s_button = NULL;
 191
 192     if ( !s_button )
 193     {
 194         GtkWidget* treewidget = GetTreeWidget();
 195         s_button = gtk_button_new();
 196         gtk_widget_set_parent( s_button, treewidget );
 197         gtk_widget_realize( s_button );
 198     }
 199
 200     return s_button;
 201 }
 202
 203 // ----------------------------------------------------------------------------
 204 // list/tree controls drawing
 205 // ----------------------------------------------------------------------------
 206
 207 int
 208 wxRendererGTK::DrawHeaderButton(wxWindow *win,
 209                                 wxDC& dc,
 210                                 const wxRect& rect,
 211                                 int flags,
 212                                 wxHeaderSortIconType sortArrow,
 213                                 wxHeaderButtonParams* params)
 214 {
 215
 216     GtkWidget *button = GetHeaderButtonWidget();
 217
 218     GdkWindow* gdk_window = dc.GetGDKWindow();
 219     wxASSERT_MSG( gdk_window,
 220                   wxT("cannot use wxRendererNative on wxDC of this type") );
 221
 222     int x_diff = 0;
 223     if (win->GetLayoutDirection() == wxLayout_RightToLeft)
 224         x_diff = rect.width;
 225
 226     gtk_paint_box
 227     (
 228         button->style,
 229         gdk_window,
 230         flags & wxCONTROL_DISABLED ? GTK_STATE_INSENSITIVE : GTK_STATE_NORMAL,
 231         GTK_SHADOW_OUT,
 232         NULL,
 233         button,
 234         "button",
 235         dc.LogicalToDeviceX(rect.x) - x_diff, rect.y, rect.width, rect.height
 236     );
 237
 238     return DrawHeaderButtonContents(win, dc, rect, flags, sortArrow, params);
 239 }
 240
 241 // draw a ">" or "v" button
 242 void
 243 wxRendererGTK::DrawTreeItemButton(wxWindow* win,
 244                                   wxDC& dc, const wxRect& rect, int flags)
 245 {
 246     GtkWidget *tree = GetTreeWidget();
 247
 248     GdkWindow* gdk_window = dc.GetGDKWindow();
 249     wxASSERT_MSG( gdk_window,
 250                   wxT("cannot use wxRendererNative on wxDC of this type") );
 251
 252     GtkStateType state;
 253     if ( flags & wxCONTROL_CURRENT )
 254         state = GTK_STATE_PRELIGHT;
 255     else
 256         state = GTK_STATE_NORMAL;
 257
 258     int x_diff = 0;
 259     if (win->GetLayoutDirection() == wxLayout_RightToLeft)
 260         x_diff = rect.width;
 261
 262     // VZ: I don't know how to get the size of the expander so as to centre it
 263     //     in the given rectangle, +2/3 below is just what looks good here...
 264     gtk_paint_expander
 265     (
 266         tree->style,
 267         gdk_window,
 268         state,
 269         NULL,
 270         tree,
 271         "treeview",
 272         dc.LogicalToDeviceX(rect.x) + 6 - x_diff,
 273         dc.LogicalToDeviceY(rect.y) + 3,
 274         flags & wxCONTROL_EXPANDED ? GTK_EXPANDER_EXPANDED
 275                                    : GTK_EXPANDER_COLLAPSED
 276     );
 277 }
 278
 279
 280 // ----------------------------------------------------------------------------
 281 // splitter sash drawing
 282 // ----------------------------------------------------------------------------
 283
 284 static int GetGtkSplitterFullSize()
 285 {
 286     static GtkWidget *s_paned = NULL;
 287     if (s_paned == NULL)
 288         s_paned = gtk_vpaned_new();
 289
 290     gint handle_size;
 291     gtk_widget_style_get (s_paned, "handle_size", &handle_size, NULL);
 292
 293     return handle_size;
 294 }
 295
 296 wxSplitterRenderParams
 297 wxRendererGTK::GetSplitterParams(const wxWindow *WXUNUSED(win))
 298 {
 299     // we don't draw any border, hence 0 for the second field
 300     return wxSplitterRenderParams
 301            (
 302                GetGtkSplitterFullSize(),
 303                0,
 304                true     // hot sensitive
 305            );
 306 }
 307
 308 void
 309 wxRendererGTK::DrawSplitterBorder(wxWindow * WXUNUSED(win),
 310                                   wxDC& WXUNUSED(dc),
 311                                   const wxRect& WXUNUSED(rect),
 312                                   int WXUNUSED(flags))
 313 {
 314     // nothing to do
 315 }
 316
 317 void
 318 wxRendererGTK::DrawSplitterSash(wxWindow *win,
 319                                 wxDC& dc,
 320                                 const wxSize& size,
 321                                 wxCoord position,
 322                                 wxOrientation orient,
 323                                 int flags)
 324 {
 325     if ( !win->m_wxwindow->window )
 326     {
 327         // window not realized yet
 328         return;
 329     }
 330
 331     GdkWindow* gdk_window = dc.GetGDKWindow();
 332     wxASSERT_MSG( gdk_window,
 333                   wxT("cannot use wxRendererNative on wxDC of this type") );
 334
 335     wxCoord full_size = GetGtkSplitterFullSize();
 336
 337     // are we drawing vertical or horizontal splitter?
 338     const bool isVert = orient == wxVERTICAL;
 339
 340     GdkRectangle rect;
 341
 342     if ( isVert )
 343     {
 344         int h = win->GetClientSize().GetHeight();
 345
 346         rect.x = position;
 347         rect.y = 0;
 348         rect.width = full_size;
 349         rect.height = h;
 350     }
 351     else // horz
 352     {
 353         int w = win->GetClientSize().GetWidth();
 354
 355         rect.x = 0;
 356         rect.y = position;
 357         rect.height = full_size;
 358         rect.width = w;
 359     }
 360
 361     int x_diff = 0;
 362     if (win->GetLayoutDirection() == wxLayout_RightToLeft)
 363         x_diff = rect.width;
 364
 365     gtk_paint_handle
 366     (
 367         win->m_wxwindow->style,
 368         gdk_window,
 369         flags & wxCONTROL_CURRENT ? GTK_STATE_PRELIGHT : GTK_STATE_NORMAL,
 370         GTK_SHADOW_NONE,
 371         NULL /* no clipping */,
 372         win->m_wxwindow,
 373         "paned",
 374         dc.LogicalToDeviceX(rect.x) - x_diff,
 375         dc.LogicalToDeviceY(rect.y),
 376         rect.width,
 377         rect.height,
 378         isVert ? GTK_ORIENTATION_VERTICAL : GTK_ORIENTATION_HORIZONTAL
 379     );
 380 }
 381
 382 void
 383 wxRendererGTK::DrawDropArrow(wxWindow *WXUNUSED(win),
 384                              wxDC& dc,
 385                              const wxRect& rect,
 386                              int flags)
 387 {
 388     GtkWidget *button = GetButtonWidget();
 389
 390     // If we give GTK_PIZZA(win->m_wxwindow)->bin_window as
 391     // a window for gtk_paint_xxx function, then it won't
 392     // work for wxMemoryDC. So that is why we assume wxDC
 393     // is wxWindowDC (wxClientDC, wxMemoryDC and wxPaintDC
 394     // are derived from it) and use its m_window.
 395     GdkWindow* gdk_window = dc.GetGDKWindow();
 396     wxASSERT_MSG( gdk_window,
 397                   wxT("cannot use wxRendererNative on wxDC of this type") );
 398
 399     // draw arrow so that there is even space horizontally
 400     // on both sides
 401     int arrowX = rect.width/4 + 1;
 402     int arrowWidth = rect.width - (arrowX*2);
 403
 404     // scale arrow's height accoording to the width
 405     int arrowHeight = rect.width/3;
 406     int arrowY = (rect.height-arrowHeight)/2 +
 407                  ((rect.height-arrowHeight) & 1);
 408
 409     GtkStateType state;
 410
 411     if ( flags & wxCONTROL_PRESSED )
 412         state = GTK_STATE_ACTIVE;
 413     else if ( flags & wxCONTROL_DISABLED )
 414         state = GTK_STATE_INSENSITIVE;
 415     else if ( flags & wxCONTROL_CURRENT )
 416         state = GTK_STATE_PRELIGHT;
 417     else
 418         state = GTK_STATE_NORMAL;
 419
 420     // draw arrow on button
 421     gtk_paint_arrow
 422     (
 423         button->style,
 424         gdk_window,
 425         state,
 426         flags & wxCONTROL_PRESSED ? GTK_SHADOW_IN : GTK_SHADOW_OUT,
 427         NULL,
 428         button,
 429         "arrow",
 430         GTK_ARROW_DOWN,
 431         FALSE,
 432         rect.x + arrowX,
 433         rect.y + arrowY,
 434         arrowWidth,
 435         arrowHeight
 436     );
 437 }
 438
 439 void
 440 wxRendererGTK::DrawComboBoxDropButton(wxWindow *win,
 441                                       wxDC& dc,
 442                                       const wxRect& rect,
 443                                       int flags)
 444 {
 445     DrawPushButton(win,dc,rect,flags);
 446     DrawDropArrow(win,dc,rect);
 447 }
 448
 449 void
 450 wxRendererGTK::DrawCheckBox(wxWindow *WXUNUSED(win),
 451                             wxDC& dc,
 452                             const wxRect& rect,
 453                             int flags )
 454 {
 455     GtkWidget *button = GetCheckButtonWidget();
 456
 457     // for reason why we do this, see DrawDropArrow
 458     GdkWindow* gdk_window = dc.GetGDKWindow();
 459     wxASSERT_MSG( gdk_window,
 460                   wxT("cannot use wxRendererNative on wxDC of this type") );
 461
 462     GtkStateType state;
 463
 464     if ( flags & wxCONTROL_PRESSED )
 465         state = GTK_STATE_ACTIVE;
 466     else if ( flags & wxCONTROL_DISABLED )
 467         state = GTK_STATE_INSENSITIVE;
 468     else if ( flags & wxCONTROL_CURRENT )
 469         state = GTK_STATE_PRELIGHT;
 470     else
 471         state = GTK_STATE_NORMAL;
 472
 473     gtk_paint_check
 474     (
 475         button->style,
 476         gdk_window,
 477         state,
 478         flags & wxCONTROL_CHECKED ? GTK_SHADOW_IN : GTK_SHADOW_OUT,
 479         NULL,
 480         button,
 481         "cellcheck",
 482         dc.LogicalToDeviceX(rect.x)+2,
 483         dc.LogicalToDeviceY(rect.y)+3,
 484         13, 13
 485     );
 486 }
 487
 488 void
 489 wxRendererGTK::DrawPushButton(wxWindow *WXUNUSED(win),
 490                               wxDC& dc,
 491                               const wxRect& rect,
 492                               int flags)
 493 {
 494     GtkWidget *button = GetButtonWidget();
 495
 496     // for reason why we do this, see DrawDropArrow
 497     GdkWindow* gdk_window = dc.GetGDKWindow();
 498     wxASSERT_MSG( gdk_window,
 499                   wxT("cannot use wxRendererNative on wxDC of this type") );
 500
 501     // draw button
 502     GtkStateType state;
 503
 504     if ( flags & wxCONTROL_PRESSED )
 505         state = GTK_STATE_ACTIVE;
 506     else if ( flags & wxCONTROL_DISABLED )
 507         state = GTK_STATE_INSENSITIVE;
 508     else if ( flags & wxCONTROL_CURRENT )
 509         state = GTK_STATE_PRELIGHT;
 510     else
 511         state = GTK_STATE_NORMAL;
 512
 513     gtk_paint_box
 514     (
 515         button->style,
 516         gdk_window,
 517         state,
 518         flags & wxCONTROL_PRESSED ? GTK_SHADOW_IN : GTK_SHADOW_OUT,
 519         NULL,
 520         button,
 521         "button",
 522         rect.x, rect.y, rect.width, rect.height
 523     );
 524 }
 525
 526 void
 527 wxRendererGTK::DrawItemSelectionRect(wxWindow *win,
 528                                      wxDC& dc,
 529                                      const wxRect& rect,
 530                                      int flags )
 531 {
 532     GdkWindow* gdk_window = dc.GetGDKWindow();
 533     wxASSERT_MSG( gdk_window,
 534                   wxT("cannot use wxRendererNative on wxDC of this type") );
 535
 536     int x_diff = 0;
 537     if (win->GetLayoutDirection() == wxLayout_RightToLeft)
 538         x_diff = rect.width;
 539
 540     GtkStateType state;
 541     if (flags & wxCONTROL_SELECTED)
 542     {
 543         // the wxCONTROL_FOCUSED state is deduced
 544         // directly from the m_wxwindow by GTK+
 545         state = GTK_STATE_SELECTED;
 546
 547         gtk_paint_flat_box( win->m_widget->style,
 548                         gdk_window,
 549                         state,
 550                         GTK_SHADOW_NONE,
 551                         NULL,
 552                         win->m_wxwindow,
 553                         "cell_even",
 554                         dc.LogicalToDeviceX(rect.x) - x_diff,
 555                         dc.LogicalToDeviceY(rect.y),
 556                         rect.width,
 557                         rect.height );
 558     }
 559     else // !wxCONTROL_SELECTED
 560     {
 561         state = GTK_STATE_NORMAL;
 562     }
 563
 564     if (flags & wxCONTROL_CURRENT)
 565     {
 566         gtk_paint_focus( win->m_widget->style,
 567                          gdk_window,
 568                          state,
 569                          NULL,
 570                          win->m_wxwindow,
 571                          "treeview",
 572                          dc.LogicalToDeviceX(rect.x),
 573                          dc.LogicalToDeviceY(rect.y),
 574                          rect.width,
 575                          rect.height );
 576     }
 577 }