src/ribbon/art_aui.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/ribbon/art_aui.cpp
   3 // Purpose:     AUI style art provider for ribbon interface
   4 // Author:      Peter Cawley
   5 // Modified by:
   6 // Created:     2009-08-04
   7 // RCS-ID:      $Id$
   8 // Copyright:   (C) Peter Cawley
   9 // Licence:     wxWindows licence
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 #include "wx/wxprec.h"
  13
  14 #ifdef __BORLANDC__
  15     #pragma hdrstop
  16 #endif
  17
  18 #include "wx/dc.h"
  19 #include "wx/settings.h"
  20 #include "wx/ribbon/art.h"
  21
  22 #if wxUSE_RIBBON
  23
  24 #include "wx/ribbon/art_internal.h"
  25 #include "wx/ribbon/bar.h"
  26 #include "wx/ribbon/buttonbar.h"
  27 #include "wx/ribbon/gallery.h"
  28 #include "wx/ribbon/toolbar.h"
  29
  30 #ifndef WX_PRECOMP
  31 #endif
  32
  33 #ifdef __WXMSW__
  34 #include "wx/msw/private.h"
  35 #elif defined(__WXMAC__)
  36 #include "wx/osx/private.h"
  37 // only for kThemeBrushToolbarBackground
  38 #include <Carbon/Carbon.h>
  39 #endif
  40
  41 wxRibbonAUIArtProvider::wxRibbonAUIArtProvider()
  42     : wxRibbonMSWArtProvider(false)
  43 {
  44 #if defined( __WXMAC__ ) && wxOSX_USE_COCOA_OR_CARBON
  45     wxColor base_colour = wxColour( wxMacCreateCGColorFromHITheme(kThemeBrushToolbarBackground));
  46 #else
  47     wxColor base_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
  48 #endif
  49
  50     SetColourScheme(base_colour,
  51         wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT),
  52         wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT));
  53
  54     m_tab_active_label_font = m_tab_label_font;
  55     m_tab_active_label_font.SetWeight(wxFONTWEIGHT_BOLD);
  56
  57     m_page_border_left = 1;
  58     m_page_border_right = 1;
  59     m_page_border_top = 1;
  60     m_page_border_bottom = 2;
  61     m_tab_separation_size = 0;
  62
  63     m_gallery_bitmap_padding_left_size = 3;
  64     m_gallery_bitmap_padding_right_size = 3;
  65     m_gallery_bitmap_padding_top_size = 3;
  66     m_gallery_bitmap_padding_bottom_size = 3;
  67 }
  68
  69 wxRibbonAUIArtProvider::~wxRibbonAUIArtProvider()
  70 {
  71 }
  72
  73 wxRibbonArtProvider* wxRibbonAUIArtProvider::Clone() const
  74 {
  75     wxRibbonAUIArtProvider *copy = new wxRibbonAUIArtProvider();
  76     CloneTo(copy);
  77
  78     copy->m_tab_ctrl_background_colour = m_tab_ctrl_background_colour;
  79     copy->m_tab_ctrl_background_gradient_colour = m_tab_ctrl_background_gradient_colour;
  80     copy->m_panel_label_background_colour = m_panel_label_background_colour;
  81     copy->m_panel_label_background_gradient_colour = m_panel_label_background_gradient_colour;
  82     copy->m_panel_hover_label_background_colour = m_panel_hover_label_background_colour;
  83     copy->m_panel_hover_label_background_gradient_colour = m_panel_hover_label_background_gradient_colour;
  84
  85     copy->m_background_brush = m_background_brush;
  86     copy->m_tab_active_top_background_brush = m_tab_active_top_background_brush;
  87     copy->m_tab_hover_background_brush = m_tab_hover_background_brush;
  88     copy->m_button_bar_hover_background_brush = m_button_bar_hover_background_brush;
  89     copy->m_button_bar_active_background_brush = m_button_bar_active_background_brush;
  90     copy->m_gallery_button_active_background_brush = m_gallery_button_active_background_brush;
  91     copy->m_gallery_button_hover_background_brush = m_gallery_button_hover_background_brush;
  92     copy->m_gallery_button_disabled_background_brush = m_gallery_button_disabled_background_brush;
  93
  94     copy->m_toolbar_hover_borden_pen = m_toolbar_hover_borden_pen;
  95     copy->m_tool_hover_background_brush = m_tool_hover_background_brush;
  96     copy->m_tool_active_background_brush = m_tool_active_background_brush;
  97
  98     return copy;
  99 }
 100
 101 void wxRibbonAUIArtProvider::SetFont(int id, const wxFont& font)
 102 {
 103     wxRibbonMSWArtProvider::SetFont(id, font);
 104     if(id == wxRIBBON_ART_TAB_LABEL_FONT)
 105     {
 106         m_tab_active_label_font = m_tab_label_font;
 107         m_tab_active_label_font.SetWeight(wxFONTWEIGHT_BOLD);
 108     }
 109 }
 110
 111 wxColour wxRibbonAUIArtProvider::GetColour(int id) const
 112 {
 113     switch(id)
 114     {
 115     case wxRIBBON_ART_PAGE_BACKGROUND_COLOUR:
 116     case wxRIBBON_ART_PAGE_BACKGROUND_GRADIENT_COLOUR:
 117         return m_background_brush.GetColour();
 118     case wxRIBBON_ART_TAB_CTRL_BACKGROUND_COLOUR:
 119         return m_tab_ctrl_background_colour;
 120     case wxRIBBON_ART_TAB_CTRL_BACKGROUND_GRADIENT_COLOUR:
 121         return m_tab_ctrl_background_gradient_colour;
 122     case wxRIBBON_ART_TAB_ACTIVE_BACKGROUND_TOP_COLOUR:
 123     case wxRIBBON_ART_TAB_ACTIVE_BACKGROUND_TOP_GRADIENT_COLOUR:
 124         return m_tab_active_top_background_brush.GetColour();
 125     case wxRIBBON_ART_TAB_HOVER_BACKGROUND_COLOUR:
 126     case wxRIBBON_ART_TAB_HOVER_BACKGROUND_GRADIENT_COLOUR:
 127         return m_tab_hover_background_brush.GetColour();
 128     case wxRIBBON_ART_PANEL_LABEL_BACKGROUND_COLOUR:
 129         return m_panel_label_background_colour;
 130     case wxRIBBON_ART_PANEL_LABEL_BACKGROUND_GRADIENT_COLOUR:
 131         return m_panel_label_background_gradient_colour;
 132     case wxRIBBON_ART_PANEL_HOVER_LABEL_BACKGROUND_COLOUR:
 133         return m_panel_hover_label_background_colour;
 134     case wxRIBBON_ART_PANEL_HOVER_LABEL_BACKGROUND_GRADIENT_COLOUR:
 135         return m_panel_hover_label_background_gradient_colour;
 136     case wxRIBBON_ART_BUTTON_BAR_HOVER_BACKGROUND_COLOUR:
 137     case wxRIBBON_ART_BUTTON_BAR_HOVER_BACKGROUND_GRADIENT_COLOUR:
 138         return m_button_bar_hover_background_brush.GetColour();
 139     case wxRIBBON_ART_GALLERY_BUTTON_HOVER_BACKGROUND_COLOUR:
 140     case wxRIBBON_ART_GALLERY_BUTTON_HOVER_BACKGROUND_GRADIENT_COLOUR:
 141         return m_gallery_button_hover_background_brush.GetColour();
 142     case wxRIBBON_ART_GALLERY_BUTTON_ACTIVE_BACKGROUND_COLOUR:
 143     case wxRIBBON_ART_GALLERY_BUTTON_ACTIVE_BACKGROUND_GRADIENT_COLOUR:
 144         return m_gallery_button_active_background_brush.GetColour();
 145     case wxRIBBON_ART_GALLERY_BUTTON_DISABLED_BACKGROUND_COLOUR:
 146     case wxRIBBON_ART_GALLERY_BUTTON_DISABLED_BACKGROUND_GRADIENT_COLOUR:
 147         return m_gallery_button_disabled_background_brush.GetColour();
 148     default:
 149         return wxRibbonMSWArtProvider::GetColour(id);
 150     }
 151 }
 152
 153 void wxRibbonAUIArtProvider::SetColour(int id, const wxColor& colour)
 154 {
 155     switch(id)
 156     {
 157     case wxRIBBON_ART_PAGE_BACKGROUND_COLOUR:
 158     case wxRIBBON_ART_PAGE_BACKGROUND_GRADIENT_COLOUR:
 159         m_background_brush.SetColour(colour);
 160         break;
 161     case wxRIBBON_ART_TAB_CTRL_BACKGROUND_COLOUR:
 162         m_tab_ctrl_background_colour = colour;
 163         break;
 164     case wxRIBBON_ART_TAB_CTRL_BACKGROUND_GRADIENT_COLOUR:
 165         m_tab_ctrl_background_gradient_colour = colour;
 166         break;
 167     case wxRIBBON_ART_TAB_ACTIVE_BACKGROUND_TOP_COLOUR:
 168     case wxRIBBON_ART_TAB_ACTIVE_BACKGROUND_TOP_GRADIENT_COLOUR:
 169         m_tab_active_top_background_brush.SetColour(colour);
 170         break;
 171     case wxRIBBON_ART_TAB_HOVER_BACKGROUND_COLOUR:
 172     case wxRIBBON_ART_TAB_HOVER_BACKGROUND_GRADIENT_COLOUR:
 173         m_tab_hover_background_brush.SetColour(colour);
 174         break;
 175     case wxRIBBON_ART_PANEL_LABEL_BACKGROUND_COLOUR:
 176         m_panel_label_background_colour = colour;
 177         break;
 178     case wxRIBBON_ART_PANEL_LABEL_BACKGROUND_GRADIENT_COLOUR:
 179         m_panel_label_background_gradient_colour = colour;
 180         break;
 181     case wxRIBBON_ART_BUTTON_BAR_HOVER_BACKGROUND_COLOUR:
 182     case wxRIBBON_ART_BUTTON_BAR_HOVER_BACKGROUND_GRADIENT_COLOUR:
 183         m_button_bar_hover_background_brush.SetColour(colour);
 184         break;
 185     case wxRIBBON_ART_GALLERY_BUTTON_HOVER_BACKGROUND_COLOUR:
 186     case wxRIBBON_ART_GALLERY_BUTTON_HOVER_BACKGROUND_GRADIENT_COLOUR:
 187         m_gallery_button_hover_background_brush.SetColour(colour);
 188         break;
 189     case wxRIBBON_ART_GALLERY_BUTTON_ACTIVE_BACKGROUND_COLOUR:
 190     case wxRIBBON_ART_GALLERY_BUTTON_ACTIVE_BACKGROUND_GRADIENT_COLOUR:
 191         m_gallery_button_active_background_brush.SetColour(colour);
 192         break;
 193     case wxRIBBON_ART_GALLERY_BUTTON_DISABLED_BACKGROUND_COLOUR:
 194     case wxRIBBON_ART_GALLERY_BUTTON_DISABLED_BACKGROUND_GRADIENT_COLOUR:
 195         m_gallery_button_disabled_background_brush.SetColour(colour);
 196         break;
 197     default:
 198         wxRibbonMSWArtProvider::SetColour(id, colour);
 199         break;
 200     }
 201 }
 202
 203 void wxRibbonAUIArtProvider::SetColourScheme(
 204                          const wxColour& primary,
 205                          const wxColour& secondary,
 206                          const wxColour& tertiary)
 207 {
 208     wxRibbonHSLColour primary_hsl(primary);
 209     wxRibbonHSLColour secondary_hsl(secondary);
 210     wxRibbonHSLColour tertiary_hsl(tertiary);
 211
 212     // Map primary & secondary luminance from [0, 1] to [0.15, 0.85]
 213     primary_hsl.luminance = cos(primary_hsl.luminance * M_PI) * -0.35 + 0.5;
 214     secondary_hsl.luminance = cos(secondary_hsl.luminance * M_PI) * -0.35 + 0.5;
 215
 216     // TODO: Remove next line once this provider stops piggybacking MSW
 217     wxRibbonMSWArtProvider::SetColourScheme(primary, secondary, tertiary);
 218
 219 #define LikePrimary(luminance) \
 220     wxRibbonShiftLuminance(primary_hsl, luminance ## f).ToRGB()
 221 #define LikeSecondary(luminance) \
 222     wxRibbonShiftLuminance(secondary_hsl, luminance ## f).ToRGB()
 223
 224     m_tab_ctrl_background_colour = LikePrimary(0.9);
 225     m_tab_ctrl_background_gradient_colour = LikePrimary(1.7);
 226     m_tab_border_pen = LikePrimary(0.75);
 227     m_tab_label_colour = LikePrimary(0.1);
 228     m_tab_hover_background_top_colour =  primary_hsl.ToRGB();
 229     m_tab_hover_background_top_gradient_colour = LikePrimary(1.6);
 230     m_tab_hover_background_brush = m_tab_hover_background_top_colour;
 231     m_tab_active_background_colour = m_tab_ctrl_background_gradient_colour;
 232     m_tab_active_background_gradient_colour = primary_hsl.ToRGB();
 233     m_tab_active_top_background_brush = m_tab_active_background_colour;
 234     m_panel_label_colour = m_tab_label_colour;
 235     m_panel_minimised_label_colour = m_panel_label_colour;
 236     m_panel_hover_label_colour = tertiary_hsl.ToRGB();
 237     m_page_border_pen = m_tab_border_pen;
 238     m_panel_border_pen = m_tab_border_pen;
 239     m_background_brush = primary_hsl.ToRGB();
 240     m_page_hover_background_colour = LikePrimary(1.5);
 241     m_page_hover_background_gradient_colour = LikePrimary(0.9);
 242     m_panel_label_background_colour = LikePrimary(0.85);
 243     m_panel_label_background_gradient_colour = LikePrimary(0.97);
 244     m_panel_hover_label_background_gradient_colour = secondary_hsl.ToRGB();
 245     m_panel_hover_label_background_colour = secondary_hsl.Lighter(0.2f).ToRGB();
 246     m_button_bar_hover_border_pen = secondary_hsl.ToRGB();
 247     m_button_bar_hover_background_brush = LikeSecondary(1.7);
 248     m_button_bar_active_background_brush = LikeSecondary(1.4);
 249     m_button_bar_label_colour = m_tab_label_colour;
 250     m_gallery_border_pen = m_tab_border_pen;
 251     m_gallery_item_border_pen = m_button_bar_hover_border_pen;
 252     m_gallery_hover_background_brush = LikePrimary(1.2);
 253     m_gallery_button_background_colour = m_page_hover_background_colour;
 254     m_gallery_button_background_gradient_colour = m_page_hover_background_gradient_colour;
 255     m_gallery_button_hover_background_brush = m_button_bar_hover_background_brush;
 256     m_gallery_button_active_background_brush = m_button_bar_active_background_brush;
 257     m_gallery_button_disabled_background_brush = primary_hsl.Desaturated(0.15f).ToRGB();
 258     SetColour(wxRIBBON_ART_GALLERY_BUTTON_FACE_COLOUR, LikePrimary(0.1));
 259     SetColour(wxRIBBON_ART_GALLERY_BUTTON_DISABLED_FACE_COLOUR, wxColour(128, 128, 128));
 260     SetColour(wxRIBBON_ART_GALLERY_BUTTON_ACTIVE_FACE_COLOUR, LikeSecondary(0.1));
 261     SetColour(wxRIBBON_ART_GALLERY_BUTTON_HOVER_FACE_COLOUR, LikeSecondary(0.1));
 262     m_toolbar_border_pen = m_tab_border_pen;
 263     SetColour(wxRIBBON_ART_TOOLBAR_FACE_COLOUR, LikePrimary(0.1));
 264     m_tool_background_colour = m_page_hover_background_colour;
 265     m_tool_background_gradient_colour = m_page_hover_background_gradient_colour;
 266     m_toolbar_hover_borden_pen = m_button_bar_hover_border_pen;
 267     m_tool_hover_background_brush = m_button_bar_hover_background_brush;
 268     m_tool_active_background_brush = m_button_bar_active_background_brush;
 269
 270 #undef LikeSecondary
 271 #undef LikePrimary
 272 }
 273
 274 void wxRibbonAUIArtProvider::DrawTabCtrlBackground(
 275                         wxDC& dc,
 276                         wxWindow* WXUNUSED(wnd),
 277                         const wxRect& rect)
 278 {
 279     wxRect gradient_rect(rect);
 280     gradient_rect.height--;
 281     dc.GradientFillLinear(gradient_rect, m_tab_ctrl_background_colour,
 282         m_tab_ctrl_background_gradient_colour, wxSOUTH);
 283     dc.SetPen(m_tab_border_pen);
 284     dc.DrawLine(rect.x, rect.GetBottom(), rect.GetRight()+1, rect.GetBottom());
 285 }
 286
 287 int wxRibbonAUIArtProvider::GetTabCtrlHeight(
 288                         wxDC& dc,
 289                         wxWindow* WXUNUSED(wnd),
 290                         const wxRibbonPageTabInfoArray& pages)
 291 {
 292     int text_height = 0;
 293     int icon_height = 0;
 294
 295     if(pages.GetCount() <= 1 && (m_flags & wxRIBBON_BAR_ALWAYS_SHOW_TABS) == 0)
 296     {
 297         // To preserve space, a single tab need not be displayed. We still need
 298         // one pixel of border though.
 299         return 1;
 300     }
 301
 302     if(m_flags & wxRIBBON_BAR_SHOW_PAGE_LABELS)
 303     {
 304         dc.SetFont(m_tab_active_label_font);
 305         text_height = dc.GetTextExtent(wxT("ABCDEFXj")).GetHeight();
 306     }
 307     if(m_flags & wxRIBBON_BAR_SHOW_PAGE_ICONS)
 308     {
 309         size_t numpages = pages.GetCount();
 310         for(size_t i = 0; i < numpages; ++i)
 311         {
 312             const wxRibbonPageTabInfo& info = pages.Item(i);
 313             if(info.page->GetIcon().IsOk())
 314             {
 315                 icon_height = wxMax(icon_height, info.page->GetIcon().GetHeight());
 316             }
 317         }
 318     }
 319
 320     return wxMax(text_height, icon_height) + 10;
 321 }
 322
 323 void wxRibbonAUIArtProvider::DrawTab(wxDC& dc,
 324                  wxWindow* WXUNUSED(wnd),
 325                  const wxRibbonPageTabInfo& tab)
 326 {
 327     if(tab.rect.height <= 1)
 328         return;
 329
 330     dc.SetFont(m_tab_label_font);
 331     dc.SetPen(*wxTRANSPARENT_PEN);
 332     if(tab.active || tab.hovered)
 333     {
 334         if(tab.active)
 335         {
 336             dc.SetFont(m_tab_active_label_font);
 337             dc.SetBrush(m_background_brush);
 338             dc.DrawRectangle(tab.rect.x, tab.rect.y + tab.rect.height - 1,
 339                 tab.rect.width - 1, 1);
 340         }
 341         wxRect grad_rect(tab.rect);
 342         grad_rect.height -= 4;
 343         grad_rect.width -= 1;
 344         grad_rect.height /= 2;
 345         grad_rect.y = grad_rect.y + tab.rect.height - grad_rect.height - 1;
 346         dc.SetBrush(m_tab_active_top_background_brush);
 347         dc.DrawRectangle(tab.rect.x, tab.rect.y + 3, tab.rect.width - 1,
 348             grad_rect.y - tab.rect.y - 3);
 349         dc.GradientFillLinear(grad_rect, m_tab_active_background_colour,
 350             m_tab_active_background_gradient_colour, wxSOUTH);
 351     }
 352     else
 353     {
 354         wxRect btm_rect(tab.rect);
 355         btm_rect.height -= 4;
 356         btm_rect.width -= 1;
 357         btm_rect.height /= 2;
 358         btm_rect.y = btm_rect.y + tab.rect.height - btm_rect.height - 1;
 359         dc.SetBrush(m_tab_hover_background_brush);
 360         dc.DrawRectangle(btm_rect.x, btm_rect.y, btm_rect.width,
 361             btm_rect.height);
 362         wxRect grad_rect(tab.rect);
 363         grad_rect.width -= 1;
 364         grad_rect.y += 3;
 365         grad_rect.height = btm_rect.y - grad_rect.y;
 366         dc.GradientFillLinear(grad_rect, m_tab_hover_background_top_colour,
 367             m_tab_hover_background_top_gradient_colour, wxSOUTH);
 368     }
 369
 370     wxPoint border_points[5];
 371     border_points[0] = wxPoint(0, 3);
 372     border_points[1] = wxPoint(1, 2);
 373     border_points[2] = wxPoint(tab.rect.width - 3, 2);
 374     border_points[3] = wxPoint(tab.rect.width - 1, 4);
 375     border_points[4] = wxPoint(tab.rect.width - 1, tab.rect.height - 1);
 376
 377     dc.SetPen(m_tab_border_pen);
 378     dc.DrawLines(sizeof(border_points)/sizeof(wxPoint), border_points, tab.rect.x, tab.rect.y);
 379
 380     wxRect old_clip;
 381     dc.GetClippingBox(old_clip);
 382     bool is_first_tab = false;
 383     wxRibbonBar* bar = wxDynamicCast(tab.page->GetParent(), wxRibbonBar);
 384     if(bar && bar->GetPage(0) == tab.page)
 385         is_first_tab = true;
 386
 387     wxBitmap icon;
 388     if(m_flags & wxRIBBON_BAR_SHOW_PAGE_ICONS)
 389     {
 390         icon = tab.page->GetIcon();
 391         if((m_flags & wxRIBBON_BAR_SHOW_PAGE_LABELS) == 0)
 392         {
 393             int x = tab.rect.x + (tab.rect.width - icon.GetWidth()) / 2;
 394             dc.DrawBitmap(icon, x, tab.rect.y + 1 + (tab.rect.height - 1 -
 395                 icon.GetHeight()) / 2, true);
 396         }
 397     }
 398     if(m_flags & wxRIBBON_BAR_SHOW_PAGE_LABELS)
 399     {
 400         wxString label = tab.page->GetLabel();
 401         if(!label.IsEmpty())
 402         {
 403             dc.SetTextForeground(m_tab_label_colour);
 404             dc.SetBackgroundMode(wxTRANSPARENT);
 405
 406             int offset = 0;
 407             if(icon.IsOk())
 408                 offset += icon.GetWidth() + 2;
 409             int text_height;
 410             int text_width;
 411             dc.GetTextExtent(label, &text_width, &text_height);
 412             int x = (tab.rect.width - 2 - text_width - offset) / 2;
 413             if(x > 8)
 414                 x = 8;
 415             else if(x < 1)
 416                 x = 1;
 417             int width = tab.rect.width - x - 2;
 418             x += tab.rect.x + offset;
 419             int y = tab.rect.y + (tab.rect.height - text_height) / 2;
 420             if(icon.IsOk())
 421             {
 422                 dc.DrawBitmap(icon, x - offset, tab.rect.y + (tab.rect.height -
 423                     icon.GetHeight()) / 2, true);
 424             }
 425             dc.SetClippingRegion(x, tab.rect.y, width, tab.rect.height);
 426             dc.DrawText(label, x, y);
 427         }
 428     }
 429
 430     // Draw the left hand edge of the tab only for the first tab (subsequent
 431     // tabs use the right edge of the prior tab as their left edge). As this is
 432     // outside the rectangle for the tab, only draw it if the leftmost part of
 433     // the tab is within the clip rectangle (the clip region has to be cleared
 434     // to draw outside the tab).
 435     if(is_first_tab && old_clip.x <= tab.rect.x
 436         && tab.rect.x < old_clip.x + old_clip.width)
 437     {
 438         dc.DestroyClippingRegion();
 439         dc.DrawLine(tab.rect.x - 1, tab.rect.y + 4, tab.rect.x - 1,
 440             tab.rect.y + tab.rect.height - 1);
 441     }
 442 }
 443
 444 void wxRibbonAUIArtProvider::GetBarTabWidth(
 445                         wxDC& dc,
 446                         wxWindow* WXUNUSED(wnd),
 447                         const wxString& label,
 448                         const wxBitmap& bitmap,
 449                         int* ideal,
 450                         int* small_begin_need_separator,
 451                         int* small_must_have_separator,
 452                         int* minimum)
 453 {
 454     int width = 0;
 455     int min = 0;
 456     if((m_flags & wxRIBBON_BAR_SHOW_PAGE_LABELS) && !label.IsEmpty())
 457     {
 458         dc.SetFont(m_tab_active_label_font);
 459         width += dc.GetTextExtent(label).GetWidth();
 460         min += wxMin(30, width); // enough for a few chars
 461         if(bitmap.IsOk())
 462         {
 463             // gap between label and bitmap
 464             width += 4;
 465             min += 2;
 466         }
 467     }
 468     if((m_flags & wxRIBBON_BAR_SHOW_PAGE_ICONS) && bitmap.IsOk())
 469     {
 470         width += bitmap.GetWidth();
 471         min += bitmap.GetWidth();
 472     }
 473
 474     if(ideal != NULL)
 475     {
 476         *ideal = width + 16;
 477     }
 478     if(small_begin_need_separator != NULL)
 479     {
 480         *small_begin_need_separator = min;
 481     }
 482     if(small_must_have_separator != NULL)
 483     {
 484         *small_must_have_separator = min;
 485     }
 486     if(minimum != NULL)
 487     {
 488         *minimum = min;
 489     }
 490 }
 491
 492 void wxRibbonAUIArtProvider::DrawTabSeparator(
 493                     wxDC& WXUNUSED(dc),
 494                     wxWindow* WXUNUSED(wnd),
 495                     const wxRect& WXUNUSED(rect),
 496                     double WXUNUSED(visibility))
 497 {
 498     // No explicit separators between tabs
 499 }
 500
 501 void wxRibbonAUIArtProvider::DrawPageBackground(
 502                         wxDC& dc,
 503                         wxWindow* WXUNUSED(wnd),
 504                         const wxRect& rect)
 505 {
 506     dc.SetPen(*wxTRANSPARENT_PEN);
 507     dc.SetBrush(m_background_brush);
 508     dc.DrawRectangle(rect.x + 1, rect.y, rect.width - 2, rect.height - 1);
 509
 510     dc.SetPen(m_page_border_pen);
 511     dc.DrawLine(rect.x, rect.y, rect.x, rect.y + rect.height);
 512     dc.DrawLine(rect.GetRight(), rect.y, rect.GetRight(), rect.y +rect.height);
 513     dc.DrawLine(rect.x, rect.GetBottom(), rect.GetRight()+1, rect.GetBottom());
 514 }
 515
 516 wxSize wxRibbonAUIArtProvider::GetScrollButtonMinimumSize(
 517                         wxDC& WXUNUSED(dc),
 518                         wxWindow* WXUNUSED(wnd),
 519                         long WXUNUSED(style))
 520 {
 521     return wxSize(11, 11);
 522 }
 523
 524 void wxRibbonAUIArtProvider::DrawScrollButton(
 525                         wxDC& dc,
 526                         wxWindow* WXUNUSED(wnd),
 527                         const wxRect& rect,
 528                         long style)
 529 {
 530     wxRect true_rect(rect);
 531     wxPoint arrow_points[3];
 532
 533     if((style & wxRIBBON_SCROLL_BTN_FOR_MASK) == wxRIBBON_SCROLL_BTN_FOR_TABS)
 534     {
 535         true_rect.y += 2;
 536         true_rect.height -= 2;
 537         dc.SetPen(m_tab_border_pen);
 538     }
 539     else
 540     {
 541         dc.SetPen(*wxTRANSPARENT_PEN);
 542         dc.SetBrush(m_background_brush);
 543         dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
 544         dc.SetPen(m_page_border_pen);
 545     }
 546
 547     switch(style & wxRIBBON_SCROLL_BTN_DIRECTION_MASK)
 548     {
 549     case wxRIBBON_SCROLL_BTN_LEFT:
 550         dc.DrawLine(true_rect.GetRight(), true_rect.y, true_rect.GetRight(),
 551             true_rect.y + true_rect.height);
 552         arrow_points[0] = wxPoint(rect.width / 2 - 2, rect.height / 2);
 553         arrow_points[1] = arrow_points[0] + wxPoint(5, -5);
 554         arrow_points[2] = arrow_points[0] + wxPoint(5,  5);
 555         break;
 556     case wxRIBBON_SCROLL_BTN_RIGHT:
 557         dc.DrawLine(true_rect.x, true_rect.y, true_rect.x,
 558             true_rect.y + true_rect.height);
 559         arrow_points[0] = wxPoint(rect.width / 2 + 3, rect.height / 2);
 560         arrow_points[1] = arrow_points[0] - wxPoint(5, -5);
 561         arrow_points[2] = arrow_points[0] - wxPoint(5,  5);
 562         break;
 563     case wxRIBBON_SCROLL_BTN_DOWN:
 564         dc.DrawLine(true_rect.x, true_rect.y, true_rect.x + true_rect.width,
 565             true_rect.y);
 566         arrow_points[0] = wxPoint(rect.width / 2, rect.height / 2 + 3);
 567         arrow_points[1] = arrow_points[0] - wxPoint( 5, 5);
 568         arrow_points[2] = arrow_points[0] - wxPoint(-5, 5);
 569         break;
 570     case wxRIBBON_SCROLL_BTN_UP:
 571         dc.DrawLine(true_rect.x, true_rect.GetBottom(),
 572             true_rect.x + true_rect.width, true_rect.GetBottom());
 573         arrow_points[0] = wxPoint(rect.width / 2, rect.height / 2 - 2);
 574         arrow_points[1] = arrow_points[0] + wxPoint( 5, 5);
 575         arrow_points[2] = arrow_points[0] + wxPoint(-5, 5);
 576         break;
 577     default:
 578         return;
 579     }
 580
 581     int x = rect.x;
 582     int y = rect.y;
 583     if(style & wxRIBBON_SCROLL_BTN_ACTIVE)
 584     {
 585         ++x;
 586         ++y;
 587     }
 588
 589     dc.SetPen(*wxTRANSPARENT_PEN);
 590     wxBrush B(m_tab_label_colour);
 591     dc.SetBrush(B);
 592     dc.DrawPolygon(sizeof(arrow_points)/sizeof(wxPoint), arrow_points, x, y);
 593 }
 594
 595 wxSize wxRibbonAUIArtProvider::GetPanelSize(
 596                         wxDC& dc,
 597                         const wxRibbonPanel* wnd,
 598                         wxSize client_size,
 599                         wxPoint* client_offset)
 600 {
 601     dc.SetFont(m_panel_label_font);
 602     wxSize label_size = dc.GetTextExtent(wnd->GetLabel());
 603     int label_height = label_size.GetHeight() + 5;
 604     if(m_flags & wxRIBBON_BAR_FLOW_VERTICAL)
 605     {
 606         client_size.IncBy(4, label_height + 6);
 607         if(client_offset)
 608             *client_offset = wxPoint(2, label_height + 3);
 609     }
 610     else
 611     {
 612         client_size.IncBy(6, label_height + 4);
 613         if(client_offset)
 614             *client_offset = wxPoint(3, label_height + 2);
 615     }
 616     return client_size;
 617 }
 618
 619 wxSize wxRibbonAUIArtProvider::GetPanelClientSize(
 620                         wxDC& dc,
 621                         const wxRibbonPanel* wnd,
 622                         wxSize size,
 623                         wxPoint* client_offset)
 624 {
 625     dc.SetFont(m_panel_label_font);
 626     wxSize label_size = dc.GetTextExtent(wnd->GetLabel());
 627     int label_height = label_size.GetHeight() + 5;
 628     if(m_flags & wxRIBBON_BAR_FLOW_VERTICAL)
 629     {
 630         size.DecBy(4, label_height + 6);
 631         if(client_offset)
 632             *client_offset = wxPoint(2, label_height + 3);
 633     }
 634     else
 635     {
 636         size.DecBy(6, label_height + 4);
 637         if(client_offset)
 638             *client_offset = wxPoint(3, label_height + 2);
 639     }
 640     if (size.x < 0) size.x = 0;
 641     if (size.y < 0) size.y = 0;
 642     return size;
 643 }
 644
 645 void wxRibbonAUIArtProvider::DrawPanelBackground(
 646                         wxDC& dc,
 647                         wxRibbonPanel* wnd,
 648                         const wxRect& rect)
 649 {
 650     dc.SetPen(*wxTRANSPARENT_PEN);
 651     dc.SetBrush(m_background_brush);
 652     dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
 653
 654     wxRect true_rect(rect);
 655     RemovePanelPadding(&true_rect);
 656
 657     dc.SetPen(m_panel_border_pen);
 658     dc.SetBrush(*wxTRANSPARENT_BRUSH);
 659     dc.DrawRectangle(true_rect.x, true_rect.y, true_rect.width, true_rect.height);
 660
 661     true_rect.x++;
 662     true_rect.width -= 2;
 663     true_rect.y++;
 664
 665     dc.SetFont(m_panel_label_font);
 666     wxSize label_size = dc.GetTextExtent(wnd->GetLabel());
 667     int label_height = label_size.GetHeight() + 5;
 668     wxRect label_rect(true_rect);
 669     label_rect.height = label_height - 1;
 670     dc.DrawLine(label_rect.x, label_rect.y + label_rect.height,
 671         label_rect.x + label_rect.width, label_rect.y + label_rect.height);
 672
 673     wxColour label_bg_colour = m_panel_label_background_colour;
 674     wxColour label_bg_grad_colour = m_panel_label_background_gradient_colour;
 675     if(wnd->IsHovered())
 676     {
 677         label_bg_colour = m_panel_hover_label_background_colour;
 678         label_bg_grad_colour = m_panel_hover_label_background_gradient_colour;
 679         dc.SetTextForeground(m_panel_hover_label_colour);
 680     }
 681     else
 682     {
 683         dc.SetTextForeground(m_panel_label_colour);
 684     }
 685     dc.GradientFillLinear(label_rect,
 686 #ifdef __WXMAC__
 687         label_bg_grad_colour, label_bg_colour, wxSOUTH);
 688 #else
 689         label_bg_colour, label_bg_grad_colour, wxSOUTH);
 690 #endif
 691     dc.SetFont(m_panel_label_font);
 692     dc.DrawText(wnd->GetLabel(), label_rect.x + 3, label_rect.y + 2);
 693
 694     if(wnd->IsHovered())
 695     {
 696         wxRect gradient_rect(true_rect);
 697         gradient_rect.y += label_rect.height + 1;
 698         gradient_rect.height = true_rect.height - label_rect.height - 3;
 699 #ifdef __WXMAC__
 700         wxColour colour = m_page_hover_background_gradient_colour;
 701         wxColour gradient = m_page_hover_background_colour;
 702 #else
 703         wxColour colour = m_page_hover_background_colour;
 704         wxColour gradient = m_page_hover_background_gradient_colour;
 705 #endif
 706         dc.GradientFillLinear(gradient_rect, colour, gradient, wxSOUTH);
 707     }
 708 }
 709
 710 void wxRibbonAUIArtProvider::DrawMinimisedPanel(
 711                         wxDC& dc,
 712                         wxRibbonPanel* wnd,
 713                         const wxRect& rect,
 714                         wxBitmap& bitmap)
 715 {
 716     dc.SetPen(*wxTRANSPARENT_PEN);
 717     dc.SetBrush(m_background_brush);
 718     dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
 719
 720     wxRect true_rect(rect);
 721     RemovePanelPadding(&true_rect);
 722
 723     dc.SetPen(m_panel_border_pen);
 724     dc.SetBrush(*wxTRANSPARENT_BRUSH);
 725     dc.DrawRectangle(true_rect.x, true_rect.y, true_rect.width, true_rect.height);
 726     true_rect.Deflate(1);
 727
 728     if(wnd->IsHovered() || wnd->GetExpandedPanel())
 729     {
 730         wxColour colour = m_page_hover_background_colour;
 731         wxColour gradient = m_page_hover_background_gradient_colour;
 732 #ifdef __WXMAC__
 733         if(!wnd->GetExpandedPanel())
 734 #else
 735         if(wnd->GetExpandedPanel())
 736 #endif
 737         {
 738             wxColour temp = colour;
 739             colour = gradient;
 740             gradient = temp;
 741         }
 742         dc.GradientFillLinear(true_rect, colour, gradient, wxSOUTH);
 743     }
 744
 745     wxRect preview;
 746     DrawMinimisedPanelCommon(dc, wnd, true_rect, &preview);
 747
 748     dc.SetPen(m_panel_border_pen);
 749     dc.SetBrush(*wxTRANSPARENT_BRUSH);
 750     dc.DrawRectangle(preview.x, preview.y, preview.width, preview.height);
 751     preview.Deflate(1);
 752     wxRect preview_caption_rect(preview);
 753     preview_caption_rect.height = 7;
 754     preview.y += preview_caption_rect.height;
 755     preview.height -= preview_caption_rect.height;
 756 #ifdef __WXMAC__
 757     dc.GradientFillLinear(preview_caption_rect,
 758         m_panel_hover_label_background_gradient_colour,
 759         m_panel_hover_label_background_colour, wxSOUTH);
 760     dc.GradientFillLinear(preview,
 761         m_page_hover_background_gradient_colour,
 762         m_page_hover_background_colour, wxSOUTH);
 763 #else
 764     dc.GradientFillLinear(preview_caption_rect,
 765         m_panel_hover_label_background_colour,
 766         m_panel_hover_label_background_gradient_colour, wxSOUTH);
 767     dc.GradientFillLinear(preview,
 768         m_page_hover_background_colour,
 769         m_page_hover_background_gradient_colour, wxSOUTH);
 770 #endif
 771
 772     if(bitmap.IsOk())
 773     {
 774         dc.DrawBitmap(bitmap, preview.x + (preview.width - bitmap.GetWidth()) / 2,
 775             preview.y + (preview.height - bitmap.GetHeight()) / 2, true);
 776     }
 777 }
 778
 779 void wxRibbonAUIArtProvider::DrawPartialPanelBackground(wxDC& dc,
 780         wxWindow* wnd, const wxRect& rect)
 781 {
 782     dc.SetPen(*wxTRANSPARENT_PEN);
 783     dc.SetBrush(m_background_brush);
 784     dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
 785
 786     wxPoint offset(wnd->GetPosition());
 787     wxWindow* parent = wnd->GetParent();
 788     wxRibbonPanel* panel = NULL;
 789
 790     for(; parent; parent = parent->GetParent())
 791     {
 792         panel = wxDynamicCast(parent, wxRibbonPanel);
 793         if(panel != NULL)
 794         {
 795             if(!panel->IsHovered())
 796                 return;
 797             break;
 798         }
 799         offset += parent->GetPosition();
 800     }
 801     if(panel == NULL)
 802         return;
 803
 804     wxRect background(panel->GetSize());
 805     RemovePanelPadding(&background);
 806     background.x++;
 807     background.width -= 2;
 808     dc.SetFont(m_panel_label_font);
 809     int caption_height = dc.GetTextExtent(panel->GetLabel()).GetHeight() + 7;
 810     background.y += caption_height - 1;
 811     background.height -= caption_height;
 812
 813     wxRect paint_rect(rect);
 814     paint_rect.x += offset.x;
 815     paint_rect.y += offset.y;
 816
 817     wxColour bg_clr, bg_grad_clr;
 818 #ifdef __WXMAC__
 819     bg_grad_clr = m_page_hover_background_colour;
 820     bg_clr = m_page_hover_background_gradient_colour;
 821 #else
 822     bg_clr = m_page_hover_background_colour;
 823     bg_grad_clr = m_page_hover_background_gradient_colour;
 824 #endif
 825
 826     paint_rect.Intersect(background);
 827     if(!paint_rect.IsEmpty())
 828     {
 829         wxColour starting_colour(wxRibbonInterpolateColour(bg_clr, bg_grad_clr,
 830             paint_rect.y, background.y, background.y + background.height));
 831         wxColour ending_colour(wxRibbonInterpolateColour(bg_clr, bg_grad_clr,
 832             paint_rect.y + paint_rect.height, background.y,
 833             background.y + background.height));
 834         paint_rect.x -= offset.x;
 835         paint_rect.y -= offset.y;
 836         dc.GradientFillLinear(paint_rect, starting_colour, ending_colour
 837             , wxSOUTH);
 838     }
 839 }
 840
 841 void wxRibbonAUIArtProvider::DrawGalleryBackground(
 842                         wxDC& dc,
 843                         wxRibbonGallery* wnd,
 844                         const wxRect& rect)
 845 {
 846     DrawPartialPanelBackground(dc, wnd, rect);
 847
 848     if(wnd->IsHovered())
 849     {
 850         dc.SetPen(*wxTRANSPARENT_PEN);
 851         dc.SetBrush(m_gallery_hover_background_brush);
 852         if(m_flags & wxRIBBON_BAR_FLOW_VERTICAL)
 853         {
 854             dc.DrawRectangle(rect.x + 1, rect.y + 1, rect.width - 2,
 855                 rect.height - 16);
 856         }
 857         else
 858         {
 859             dc.DrawRectangle(rect.x + 1, rect.y + 1, rect.width - 16,
 860                 rect.height - 2);
 861         }
 862     }
 863
 864     dc.SetPen(m_gallery_border_pen);
 865     dc.SetBrush(*wxTRANSPARENT_BRUSH);
 866     dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
 867
 868     DrawGalleryBackgroundCommon(dc, wnd, rect);
 869 }
 870
 871 void wxRibbonAUIArtProvider::DrawGalleryButton(wxDC& dc, wxRect rect,
 872         wxRibbonGalleryButtonState state, wxBitmap* bitmaps)
 873 {
 874     int extra_height = 0;
 875     int extra_width = 0;
 876     wxRect reduced_rect(rect);
 877     reduced_rect.Deflate(1);
 878     if(m_flags & wxRIBBON_BAR_FLOW_VERTICAL)
 879     {
 880         reduced_rect.width++;
 881         extra_width = 1;
 882     }
 883     else
 884     {
 885         reduced_rect.height++;
 886         extra_height = 1;
 887     }
 888
 889     wxBitmap btn_bitmap;
 890     switch(state)
 891     {
 892     case wxRIBBON_GALLERY_BUTTON_NORMAL:
 893         dc.GradientFillLinear(reduced_rect,
 894             m_gallery_button_background_colour,
 895             m_gallery_button_background_gradient_colour, wxSOUTH);
 896         btn_bitmap = bitmaps[0];
 897         break;
 898     case wxRIBBON_GALLERY_BUTTON_HOVERED:
 899         dc.SetPen(m_gallery_item_border_pen);
 900         dc.SetBrush(m_gallery_button_hover_background_brush);
 901         dc.DrawRectangle(rect.x, rect.y, rect.width + extra_width,
 902             rect.height + extra_height);
 903         btn_bitmap = bitmaps[1];
 904         break;
 905     case wxRIBBON_GALLERY_BUTTON_ACTIVE:
 906         dc.SetPen(m_gallery_item_border_pen);
 907         dc.SetBrush(m_gallery_button_active_background_brush);
 908         dc.DrawRectangle(rect.x, rect.y, rect.width + extra_width,
 909             rect.height + extra_height);
 910         btn_bitmap = bitmaps[2];
 911         break;
 912     case wxRIBBON_GALLERY_BUTTON_DISABLED:
 913         dc.SetPen(*wxTRANSPARENT_PEN);
 914         dc.SetBrush(m_gallery_button_disabled_background_brush);
 915         dc.DrawRectangle(reduced_rect.x, reduced_rect.y, reduced_rect.width,
 916             reduced_rect.height);
 917         btn_bitmap = bitmaps[3];
 918         break;
 919     }
 920
 921     dc.DrawBitmap(btn_bitmap, reduced_rect.x + reduced_rect.width / 2 - 2,
 922         (rect.y + rect.height / 2) - 2, true);
 923 }
 924
 925 void wxRibbonAUIArtProvider::DrawGalleryItemBackground(
 926                         wxDC& dc,
 927                         wxRibbonGallery* wnd,
 928                         const wxRect& rect,
 929                         wxRibbonGalleryItem* item)
 930 {
 931     if(wnd->GetHoveredItem() != item && wnd->GetActiveItem() != item &&
 932         wnd->GetSelection() != item)
 933         return;
 934
 935     dc.SetPen(m_gallery_item_border_pen);
 936     if(wnd->GetActiveItem() == item || wnd->GetSelection() == item)
 937         dc.SetBrush(m_gallery_button_active_background_brush);
 938     else
 939         dc.SetBrush(m_gallery_button_hover_background_brush);
 940
 941     dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
 942 }
 943
 944 void wxRibbonAUIArtProvider::DrawButtonBarBackground(
 945                         wxDC& dc,
 946                         wxWindow* wnd,
 947                         const wxRect& rect)
 948 {
 949     DrawPartialPanelBackground(dc, wnd, rect);
 950 }
 951
 952 void wxRibbonAUIArtProvider::DrawButtonBarButton(
 953                         wxDC& dc,
 954                         wxWindow* WXUNUSED(wnd),
 955                         const wxRect& rect,
 956                         wxRibbonButtonKind kind,
 957                         long state,
 958                         const wxString& label,
 959                         const wxBitmap& bitmap_large,
 960                         const wxBitmap& bitmap_small)
 961 {
 962     if(state & (wxRIBBON_BUTTONBAR_BUTTON_HOVER_MASK
 963         | wxRIBBON_BUTTONBAR_BUTTON_ACTIVE_MASK))
 964     {
 965         dc.SetPen(m_button_bar_hover_border_pen);
 966
 967         wxRect bg_rect(rect);
 968         bg_rect.Deflate(1);
 969
 970         if(kind == wxRIBBON_BUTTON_HYBRID)
 971         {
 972             switch(state & wxRIBBON_BUTTONBAR_BUTTON_SIZE_MASK)
 973             {
 974             case wxRIBBON_BUTTONBAR_BUTTON_LARGE:
 975                 {
 976                     int iYBorder = rect.y + bitmap_large.GetHeight() + 4;
 977                     wxRect partial_bg(rect);
 978                     if(state & wxRIBBON_BUTTONBAR_BUTTON_NORMAL_HOVERED)
 979                     {
 980                         partial_bg.SetBottom(iYBorder - 1);
 981                     }
 982                     else
 983                     {
 984                         partial_bg.height -= (iYBorder - partial_bg.y + 1);
 985                         partial_bg.y = iYBorder + 1;
 986                     }
 987                     dc.DrawLine(rect.x, iYBorder, rect.x + rect.width, iYBorder);
 988                     bg_rect.Intersect(partial_bg);
 989                 }
 990                 break;
 991             case wxRIBBON_BUTTONBAR_BUTTON_MEDIUM:
 992                 {
 993                     int iArrowWidth = 9;
 994                     if(state & wxRIBBON_BUTTONBAR_BUTTON_NORMAL_HOVERED)
 995                     {
 996                         bg_rect.width -= iArrowWidth;
 997                         dc.DrawLine(bg_rect.x + bg_rect.width,
 998                             rect.y, bg_rect.x + bg_rect.width,
 999                             rect.y + rect.height);
1000                     }
1001                     else
1002                     {
1003                         --iArrowWidth;
1004                         bg_rect.x += bg_rect.width - iArrowWidth;
1005                         bg_rect.width = iArrowWidth;
1006                         dc.DrawLine(bg_rect.x - 1, rect.y,
1007                             bg_rect.x - 1, rect.y + rect.height);
1008                     }
1009                 }
1010                 break;
1011             case wxRIBBON_BUTTONBAR_BUTTON_SMALL:
1012                 break;
1013             }
1014         }
1015
1016         dc.SetBrush(*wxTRANSPARENT_BRUSH);
1017         dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
1018
1019         dc.SetPen(*wxTRANSPARENT_PEN);
1020         if(state & wxRIBBON_BUTTONBAR_BUTTON_ACTIVE_MASK)
1021             dc.SetBrush(m_button_bar_active_background_brush);
1022         else
1023             dc.SetBrush(m_button_bar_hover_background_brush);
1024         dc.DrawRectangle(bg_rect.x, bg_rect.y, bg_rect.width, bg_rect.height);
1025     }
1026
1027     dc.SetFont(m_button_bar_label_font);
1028     dc.SetTextForeground(m_button_bar_label_colour);
1029     DrawButtonBarButtonForeground(dc, rect, kind, state, label, bitmap_large,
1030         bitmap_small);
1031 }
1032
1033 void wxRibbonAUIArtProvider::DrawToolBarBackground(
1034                         wxDC& dc,
1035                         wxWindow* wnd,
1036                         const wxRect& rect)
1037 {
1038     DrawPartialPanelBackground(dc, wnd, rect);
1039 }
1040
1041 void wxRibbonAUIArtProvider::DrawToolGroupBackground(
1042                     wxDC& dc,
1043                     wxWindow* WXUNUSED(wnd),
1044                     const wxRect& rect)
1045 {
1046     dc.SetPen(m_toolbar_border_pen);
1047     dc.SetBrush(*wxTRANSPARENT_BRUSH);
1048     dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
1049     wxRect bg_rect(rect);
1050     bg_rect.Deflate(1);
1051     dc.GradientFillLinear(bg_rect, m_tool_background_colour,
1052         m_tool_background_gradient_colour, wxSOUTH);
1053 }
1054
1055 void wxRibbonAUIArtProvider::DrawTool(
1056             wxDC& dc,
1057             wxWindow* WXUNUSED(wnd),
1058             const wxRect& rect,
1059             const wxBitmap& bitmap,
1060             wxRibbonButtonKind kind,
1061             long state)
1062 {
1063     wxRect bg_rect(rect);
1064     bg_rect.Deflate(1);
1065     if((state & wxRIBBON_TOOLBAR_TOOL_LAST) == 0)
1066         bg_rect.width++;
1067     bool is_custom_bg = (state & (wxRIBBON_TOOLBAR_TOOL_HOVER_MASK |
1068         wxRIBBON_TOOLBAR_TOOL_ACTIVE_MASK)) != 0;
1069     bool is_split_hybrid = kind == wxRIBBON_BUTTON_HYBRID && is_custom_bg;
1070
1071     // Background
1072     if(is_custom_bg)
1073     {
1074         dc.SetPen(*wxTRANSPARENT_PEN);
1075         dc.SetBrush(m_tool_hover_background_brush);
1076         dc.DrawRectangle(bg_rect.x, bg_rect.y, bg_rect.width, bg_rect.height);
1077         if(state & wxRIBBON_TOOLBAR_TOOL_ACTIVE_MASK)
1078         {
1079             wxRect active_rect(bg_rect);
1080             if(kind == wxRIBBON_BUTTON_HYBRID)
1081             {
1082                 active_rect.width -= 8;
1083                 if(state & wxRIBBON_TOOLBAR_TOOL_DROPDOWN_ACTIVE)
1084                 {
1085                     active_rect.x += active_rect.width;
1086                     active_rect.width = 8;
1087                 }
1088             }
1089             dc.SetBrush(m_tool_active_background_brush);
1090             dc.DrawRectangle(active_rect.x, active_rect.y, active_rect.width,
1091                 active_rect.height);
1092         }
1093     }
1094
1095     // Border
1096     if(is_custom_bg)
1097         dc.SetPen(m_toolbar_hover_borden_pen);
1098     else
1099         dc.SetPen(m_toolbar_border_pen);
1100     if((state & wxRIBBON_TOOLBAR_TOOL_FIRST) == 0)
1101     {
1102         wxColour existing;
1103         if(!dc.GetPixel(rect.x, rect.y + 1, &existing) ||
1104             existing != m_toolbar_hover_borden_pen.GetColour())
1105         {
1106             dc.DrawLine(rect.x, rect.y + 1, rect.x, rect.y + rect.height - 1);
1107         }
1108     }
1109     if(is_custom_bg)
1110     {
1111         wxRect border_rect(bg_rect);
1112         border_rect.Inflate(1);
1113         dc.SetBrush(*wxTRANSPARENT_BRUSH);
1114         dc.DrawRectangle(border_rect.x, border_rect.y, border_rect.width,
1115             border_rect.height);
1116     }
1117
1118     // Foreground
1119     int avail_width = bg_rect.GetWidth();
1120     if(kind != wxRIBBON_BUTTON_NORMAL)
1121     {
1122         avail_width -= 8;
1123         if(is_split_hybrid)
1124         {
1125             dc.DrawLine(rect.x + avail_width + 1, rect.y,
1126                 rect.x + avail_width + 1, rect.y + rect.height);
1127         }
1128         dc.DrawBitmap(m_toolbar_drop_bitmap, bg_rect.x + avail_width + 2,
1129             bg_rect.y + (bg_rect.height / 2) - 2, true);
1130     }
1131     dc.DrawBitmap(bitmap, bg_rect.x + (avail_width - bitmap.GetWidth()) / 2,
1132         bg_rect.y + (bg_rect.height - bitmap.GetHeight()) / 2, true);
1133 }
1134
1135 #endif // wxUSE_RIBBON