src/ribbon/bar.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/ribbon/bar.cpp
   3 // Purpose:     Top-level component of the ribbon-bar-style interface
   4 // Author:      Peter Cawley
   5 // Modified by:
   6 // Created:     2009-05-23
   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 #if wxUSE_RIBBON
  19
  20 #include "wx/ribbon/bar.h"
  21 #include "wx/ribbon/art.h"
  22 #include "wx/dcbuffer.h"
  23 #include "wx/app.h"
  24 #include "wx/vector.h"
  25
  26 #ifndef WX_PRECOMP
  27 #endif
  28
  29 #ifdef __WXMSW__
  30 #include "wx/msw/private.h"
  31 #endif
  32
  33 #include "wx/arrimpl.cpp"
  34
  35 WX_DEFINE_USER_EXPORTED_OBJARRAY(wxRibbonPageTabInfoArray)
  36
  37 wxDEFINE_EVENT(wxEVT_COMMAND_RIBBONBAR_PAGE_CHANGED, wxRibbonBarEvent);
  38 wxDEFINE_EVENT(wxEVT_COMMAND_RIBBONBAR_PAGE_CHANGING, wxRibbonBarEvent);
  39 wxDEFINE_EVENT(wxEVT_COMMAND_RIBBONBAR_TAB_MIDDLE_DOWN, wxRibbonBarEvent);
  40 wxDEFINE_EVENT(wxEVT_COMMAND_RIBBONBAR_TAB_MIDDLE_UP, wxRibbonBarEvent);
  41 wxDEFINE_EVENT(wxEVT_COMMAND_RIBBONBAR_TAB_RIGHT_DOWN, wxRibbonBarEvent);
  42 wxDEFINE_EVENT(wxEVT_COMMAND_RIBBONBAR_TAB_RIGHT_UP, wxRibbonBarEvent);
  43 wxDEFINE_EVENT(wxEVT_COMMAND_RIBBONBAR_TAB_LEFT_DCLICK, wxRibbonBarEvent);
  44 wxDEFINE_EVENT(wxEVT_COMMAND_RIBBONBAR_TOGGLED, wxRibbonBarEvent);
  45 wxDEFINE_EVENT(wxEVT_COMMAND_RIBBONBAR_HELP_CLICKED, wxRibbonBarEvent);
  46
  47 IMPLEMENT_CLASS(wxRibbonBar, wxRibbonControl)
  48 IMPLEMENT_DYNAMIC_CLASS(wxRibbonBarEvent, wxNotifyEvent)
  49
  50 BEGIN_EVENT_TABLE(wxRibbonBar, wxRibbonControl)
  51   EVT_ERASE_BACKGROUND(wxRibbonBar::OnEraseBackground)
  52   EVT_LEAVE_WINDOW(wxRibbonBar::OnMouseLeave)
  53   EVT_LEFT_DOWN(wxRibbonBar::OnMouseLeftDown)
  54   EVT_LEFT_UP(wxRibbonBar::OnMouseLeftUp)
  55   EVT_MIDDLE_DOWN(wxRibbonBar::OnMouseMiddleDown)
  56   EVT_MIDDLE_UP(wxRibbonBar::OnMouseMiddleUp)
  57   EVT_MOTION(wxRibbonBar::OnMouseMove)
  58   EVT_PAINT(wxRibbonBar::OnPaint)
  59   EVT_RIGHT_DOWN(wxRibbonBar::OnMouseRightDown)
  60   EVT_RIGHT_UP(wxRibbonBar::OnMouseRightUp)
  61   EVT_LEFT_DCLICK(wxRibbonBar::OnMouseDoubleClick)
  62   EVT_SIZE(wxRibbonBar::OnSize)
  63   EVT_KILL_FOCUS(wxRibbonBar::OnKillFocus)
  64 END_EVENT_TABLE()
  65
  66 void wxRibbonBar::AddPage(wxRibbonPage *page)
  67 {
  68     wxRibbonPageTabInfo info;
  69
  70     info.page = page;
  71     info.active = false;
  72     info.hovered = false;
  73     info.highlight = false;
  74     info.shown = true;
  75     // info.rect not set (intentional)
  76
  77     wxClientDC dcTemp(this);
  78     wxString label = wxEmptyString;
  79     if(m_flags & wxRIBBON_BAR_SHOW_PAGE_LABELS)
  80         label = page->GetLabel();
  81     wxBitmap icon = wxNullBitmap;
  82     if(m_flags & wxRIBBON_BAR_SHOW_PAGE_ICONS)
  83         icon = page->GetIcon();
  84     m_art->GetBarTabWidth(dcTemp, this, label, icon,
  85                           &info.ideal_width,
  86                           &info.small_begin_need_separator_width,
  87                           &info.small_must_have_separator_width,
  88                           &info.minimum_width);
  89
  90     if(m_pages.IsEmpty())
  91     {
  92         m_tabs_total_width_ideal = info.ideal_width;
  93         m_tabs_total_width_minimum = info.minimum_width;
  94     }
  95     else
  96     {
  97         int sep = m_art->GetMetric(wxRIBBON_ART_TAB_SEPARATION_SIZE);
  98         m_tabs_total_width_ideal += sep + info.ideal_width;
  99         m_tabs_total_width_minimum += sep + info.minimum_width;
 100     }
 101     m_pages.Add(info);
 102
 103     page->Hide(); // Most likely case is that this new page is not the active tab
 104     page->SetArtProvider(m_art);
 105
 106     if(m_pages.GetCount() == 1)
 107     {
 108         SetActivePage((size_t)0);
 109     }
 110 }
 111
 112 bool wxRibbonBar::DismissExpandedPanel()
 113 {
 114     if(m_current_page == -1)
 115         return false;
 116     return m_pages.Item(m_current_page).page->DismissExpandedPanel();
 117 }
 118
 119 void wxRibbonBar::ShowPanels(bool show)
 120 {
 121     m_arePanelsShown = show;
 122     SetMinSize(wxSize(GetSize().GetWidth(), DoGetBestSize().GetHeight()));
 123     Realise();
 124     GetParent()->Layout();
 125 }
 126
 127 void wxRibbonBar::SetWindowStyleFlag(long style)
 128 {
 129     m_flags = style;
 130     if(m_art)
 131         m_art->SetFlags(style);
 132 }
 133
 134 long wxRibbonBar::GetWindowStyleFlag() const
 135 {
 136     return m_flags;
 137 }
 138
 139 bool wxRibbonBar::Realize()
 140 {
 141     bool status = true;
 142
 143     wxClientDC dcTemp(this);
 144     int sep = m_art->GetMetric(wxRIBBON_ART_TAB_SEPARATION_SIZE);
 145     size_t numtabs = m_pages.GetCount();
 146     size_t i;
 147     for(i = 0; i < numtabs; ++i)
 148     {
 149         wxRibbonPageTabInfo& info = m_pages.Item(i);
 150         if (!info.shown)
 151             continue;
 152         RepositionPage(info.page);
 153         if(!info.page->Realize())
 154         {
 155             status = false;
 156         }
 157         wxString label = wxEmptyString;
 158         if(m_flags & wxRIBBON_BAR_SHOW_PAGE_LABELS)
 159             label = info.page->GetLabel();
 160         wxBitmap icon = wxNullBitmap;
 161         if(m_flags & wxRIBBON_BAR_SHOW_PAGE_ICONS)
 162             icon = info.page->GetIcon();
 163         m_art->GetBarTabWidth(dcTemp, this, label, icon,
 164                               &info.ideal_width,
 165                               &info.small_begin_need_separator_width,
 166                               &info.small_must_have_separator_width,
 167                               &info.minimum_width);
 168
 169         if(i == 0)
 170         {
 171             m_tabs_total_width_ideal = info.ideal_width;
 172             m_tabs_total_width_minimum = info.minimum_width;
 173         }
 174         else
 175         {
 176             m_tabs_total_width_ideal += sep + info.ideal_width;
 177             m_tabs_total_width_minimum += sep + info.minimum_width;
 178         }
 179     }
 180     m_tab_height = m_art->GetTabCtrlHeight(dcTemp, this, m_pages);
 181
 182     RecalculateMinSize();
 183     RecalculateTabSizes();
 184     Refresh();
 185
 186     return status;
 187 }
 188
 189 void wxRibbonBar::OnMouseMove(wxMouseEvent& evt)
 190 {
 191     int x = evt.GetX();
 192     int y = evt.GetY();
 193     int hovered_page = -1;
 194     bool refresh_tabs = false;
 195     if(y < m_tab_height)
 196     {
 197         // It is quite likely that the mouse moved a small amount and is still over the same tab
 198         if(m_current_hovered_page != -1 && m_pages.Item((size_t)m_current_hovered_page).rect.Contains(x, y))
 199         {
 200             hovered_page = m_current_hovered_page;
 201             // But be careful, if tabs can be scrolled, then parts of the tab rect may not be valid
 202             if(m_tab_scroll_buttons_shown)
 203             {
 204                 if(x >= m_tab_scroll_right_button_rect.GetX() || x < m_tab_scroll_left_button_rect.GetRight())
 205                 {
 206                     hovered_page = -1;
 207                 }
 208             }
 209         }
 210         else
 211         {
 212             HitTestTabs(evt.GetPosition(), &hovered_page);
 213         }
 214     }
 215     if(hovered_page != m_current_hovered_page)
 216     {
 217         if(m_current_hovered_page != -1)
 218         {
 219             m_pages.Item((int)m_current_hovered_page).hovered = false;
 220         }
 221         m_current_hovered_page = hovered_page;
 222         if(m_current_hovered_page != -1)
 223         {
 224             m_pages.Item((int)m_current_hovered_page).hovered = true;
 225         }
 226         refresh_tabs = true;
 227     }
 228     if(m_tab_scroll_buttons_shown)
 229     {
 230 #define SET_FLAG(variable, flag) \
 231     { if(((variable) & (flag)) != (flag)) { variable |= (flag); refresh_tabs = true; }}
 232 #define UNSET_FLAG(variable, flag) \
 233     { if((variable) & (flag)) { variable &= ~(flag); refresh_tabs = true; }}
 234
 235         if(m_tab_scroll_left_button_rect.Contains(x, y))
 236             SET_FLAG(m_tab_scroll_left_button_state, wxRIBBON_SCROLL_BTN_HOVERED)
 237         else
 238             UNSET_FLAG(m_tab_scroll_left_button_state, wxRIBBON_SCROLL_BTN_HOVERED)
 239
 240         if(m_tab_scroll_right_button_rect.Contains(x, y))
 241             SET_FLAG(m_tab_scroll_right_button_state, wxRIBBON_SCROLL_BTN_HOVERED)
 242         else
 243             UNSET_FLAG(m_tab_scroll_right_button_state, wxRIBBON_SCROLL_BTN_HOVERED)
 244 #undef SET_FLAG
 245 #undef UNSET_FLAG
 246     }
 247     if(refresh_tabs)
 248     {
 249         RefreshTabBar();
 250     }
 251     if ( m_flags & wxRIBBON_BAR_SHOW_TOGGLE_BUTTON )
 252         HitTestRibbonButton(m_toggle_button_rect, evt.GetPosition(), m_toggle_button_hovered);
 253     if ( m_flags & wxRIBBON_BAR_SHOW_HELP_BUTTON )
 254         HitTestRibbonButton(m_help_button_rect, evt.GetPosition(), m_help_button_hovered);
 255 }
 256
 257 void wxRibbonBar::OnMouseLeave(wxMouseEvent& WXUNUSED(evt))
 258 {
 259     // The ribbon bar is (usually) at the top of a window, and at least on MSW, the mouse
 260     // can leave the window quickly and leave a tab in the hovered state.
 261     bool refresh_tabs = false;
 262     if(m_current_hovered_page != -1)
 263     {
 264         m_pages.Item((int)m_current_hovered_page).hovered = false;
 265         m_current_hovered_page = -1;
 266         refresh_tabs = true;
 267     }
 268     if(m_tab_scroll_left_button_state & wxRIBBON_SCROLL_BTN_HOVERED)
 269     {
 270         m_tab_scroll_left_button_state &= ~wxRIBBON_SCROLL_BTN_HOVERED;
 271         refresh_tabs = true;
 272     }
 273     if(m_tab_scroll_right_button_state & wxRIBBON_SCROLL_BTN_HOVERED)
 274     {
 275         m_tab_scroll_right_button_state &= ~wxRIBBON_SCROLL_BTN_HOVERED;
 276         refresh_tabs = true;
 277     }
 278     if(refresh_tabs)
 279     {
 280         RefreshTabBar();
 281     }
 282     if(m_toggle_button_hovered)
 283     {
 284         m_bar_hovered = false;
 285         m_toggle_button_hovered = false;
 286         Refresh(false);
 287     }
 288     if ( m_help_button_hovered )
 289     {
 290         m_help_button_hovered = false;
 291         m_bar_hovered = false;
 292         Refresh(false);
 293     }
 294 }
 295
 296 wxRibbonPage* wxRibbonBar::GetPage(int n)
 297 {
 298     if(n < 0 || (size_t)n >= m_pages.GetCount())
 299         return 0;
 300     return m_pages.Item(n).page;
 301 }
 302
 303 size_t wxRibbonBar::GetPageCount() const
 304 {
 305     return m_pages.GetCount();
 306 }
 307
 308 bool wxRibbonBar::IsPageShown(size_t page) const
 309 {
 310     if (page >= m_pages.GetCount())
 311         return false;
 312     return m_pages.Item(page).shown;
 313 }
 314
 315 void wxRibbonBar::ShowPage(size_t page, bool show)
 316 {
 317     if(page >= m_pages.GetCount())
 318         return;
 319     m_pages.Item(page).shown = show;
 320 }
 321
 322 bool wxRibbonBar::IsPageHighlighted(size_t page) const
 323 {
 324     if (page >= m_pages.GetCount())
 325         return false;
 326     return m_pages.Item(page).highlight;
 327 }
 328
 329 void wxRibbonBar::AddPageHighlight(size_t page, bool highlight)
 330 {
 331     if(page >= m_pages.GetCount())
 332         return;
 333     m_pages.Item(page).highlight = highlight;
 334 }
 335
 336 void wxRibbonBar::DeletePage(size_t n)
 337 {
 338     if(n < m_pages.GetCount())
 339     {
 340         wxRibbonPage *page = m_pages.Item(n).page;
 341
 342         // Schedule page object for destruction and not destroying directly
 343         // as this function can be called in an event handler and page functions
 344         // can be called afeter removing.
 345         // Like in wxRibbonButtonBar::OnMouseUp
 346         if(!wxTheApp->IsScheduledForDestruction(page))
 347         {
 348             wxTheApp->ScheduleForDestruction(page);
 349         }
 350
 351         m_pages.RemoveAt(n);
 352
 353         if(m_current_page == static_cast<int>(n))
 354         {
 355             m_current_page = -1;
 356
 357             if(m_pages.GetCount() > 0)
 358             {
 359                 if(n >= m_pages.GetCount())
 360                 {
 361                     SetActivePage(m_pages.GetCount() - 1);
 362                 }
 363                 else
 364                 {
 365                     SetActivePage(n - 1);
 366                 }
 367             }
 368         }
 369         else if(m_current_page > static_cast<int>(n))
 370         {
 371             m_current_page--;
 372         }
 373     }
 374 }
 375
 376 void wxRibbonBar::ClearPages()
 377 {
 378     size_t i;
 379     for(i=0; i<m_pages.GetCount(); i++)
 380     {
 381         wxRibbonPage *page = m_pages.Item(i).page;
 382         // Schedule page object for destruction and not destroying directly
 383         // as this function can be called in an event handler and page functions
 384         // can be called afeter removing.
 385         // Like in wxRibbonButtonBar::OnMouseUp
 386         if(!wxTheApp->IsScheduledForDestruction(page))
 387         {
 388             wxTheApp->ScheduleForDestruction(page);
 389         }
 390     }
 391     m_pages.Empty();
 392     Realize();
 393     m_current_page = -1;
 394     Refresh();
 395 }
 396
 397 bool wxRibbonBar::SetActivePage(size_t page)
 398 {
 399     if(m_current_page == (int)page)
 400     {
 401         return true;
 402     }
 403
 404     if(page >= m_pages.GetCount())
 405     {
 406         return false;
 407     }
 408
 409     if(m_current_page != -1)
 410     {
 411         m_pages.Item((size_t)m_current_page).active = false;
 412         m_pages.Item((size_t)m_current_page).page->Hide();
 413     }
 414     m_current_page = (int)page;
 415     m_pages.Item(page).active = true;
 416     m_pages.Item(page).shown = true;
 417     {
 418         wxRibbonPage* wnd = m_pages.Item(page).page;
 419         RepositionPage(wnd);
 420         wnd->Layout();
 421         wnd->Show();
 422     }
 423     Refresh();
 424
 425     return true;
 426 }
 427
 428 bool wxRibbonBar::SetActivePage(wxRibbonPage* page)
 429 {
 430     size_t numpages = m_pages.GetCount();
 431     size_t i;
 432     for(i = 0; i < numpages; ++i)
 433     {
 434         if(m_pages.Item(i).page == page)
 435         {
 436             return SetActivePage(i);
 437         }
 438     }
 439     return false;
 440 }
 441
 442 int wxRibbonBar::GetPageNumber(wxRibbonPage* page) const
 443 {
 444     size_t numpages = m_pages.GetCount();
 445     for(size_t i = 0; i < numpages; ++i)
 446     {
 447         if(m_pages.Item(i).page == page)
 448         {
 449             return i;
 450         }
 451     }
 452     return wxNOT_FOUND;
 453 }
 454
 455
 456 int wxRibbonBar::GetActivePage() const
 457 {
 458     return m_current_page;
 459 }
 460
 461 void wxRibbonBar::SetTabCtrlMargins(int left, int right)
 462 {
 463     m_tab_margin_left = left;
 464     m_tab_margin_right = right;
 465
 466     RecalculateTabSizes();
 467 }
 468
 469 struct PageComparedBySmallWidthAsc
 470 {
 471     wxEXPLICIT PageComparedBySmallWidthAsc(wxRibbonPageTabInfo* page)
 472         : m_page(page)
 473     {
 474     }
 475
 476     bool operator<(const PageComparedBySmallWidthAsc& other) const
 477     {
 478         return m_page->small_must_have_separator_width
 479                 < other.m_page->small_must_have_separator_width;
 480     }
 481
 482     wxRibbonPageTabInfo *m_page;
 483 };
 484
 485 void wxRibbonBar::RecalculateTabSizes()
 486 {
 487     size_t numtabs = m_pages.GetCount();
 488
 489     if(numtabs == 0)
 490         return;
 491
 492     int width = GetSize().GetWidth() - m_tab_margin_left - m_tab_margin_right;
 493     int tabsep = m_art->GetMetric(wxRIBBON_ART_TAB_SEPARATION_SIZE);
 494     int x = m_tab_margin_left;
 495     const int y = 0;
 496
 497     if(width >= m_tabs_total_width_ideal)
 498     {
 499         // Simple case: everything at ideal width
 500         size_t i;
 501         for(i = 0; i < numtabs; ++i)
 502         {
 503             wxRibbonPageTabInfo& info = m_pages.Item(i);
 504             if (!info.shown)
 505                 continue;
 506             info.rect.x = x;
 507             info.rect.y = y;
 508             info.rect.width = info.ideal_width;
 509             info.rect.height = m_tab_height;
 510             x += info.rect.width + tabsep;
 511         }
 512         m_tab_scroll_buttons_shown = false;
 513         m_tab_scroll_left_button_rect.SetWidth(0);
 514         m_tab_scroll_right_button_rect.SetWidth(0);
 515     }
 516     else if(width < m_tabs_total_width_minimum)
 517     {
 518         // Simple case: everything minimum with scrollbar
 519         size_t i;
 520         for(i = 0; i < numtabs; ++i)
 521         {
 522             wxRibbonPageTabInfo& info = m_pages.Item(i);
 523             if (!info.shown)
 524                 continue;
 525             info.rect.x = x;
 526             info.rect.y = y;
 527             info.rect.width = info.minimum_width;
 528             info.rect.height = m_tab_height;
 529             x += info.rect.width + tabsep;
 530         }
 531         if(!m_tab_scroll_buttons_shown)
 532         {
 533             m_tab_scroll_left_button_state = wxRIBBON_SCROLL_BTN_NORMAL;
 534             m_tab_scroll_right_button_state = wxRIBBON_SCROLL_BTN_NORMAL;
 535             m_tab_scroll_buttons_shown = true;
 536         }
 537         {
 538             wxClientDC temp_dc(this);
 539             int right_button_pos = GetClientSize().GetWidth() - m_tab_margin_right - m_tab_scroll_right_button_rect.GetWidth();
 540             if ( right_button_pos < m_tab_margin_left )
 541                 right_button_pos = m_tab_margin_left;
 542
 543             m_tab_scroll_left_button_rect.SetWidth(m_art->GetScrollButtonMinimumSize(temp_dc, this, wxRIBBON_SCROLL_BTN_LEFT | wxRIBBON_SCROLL_BTN_NORMAL | wxRIBBON_SCROLL_BTN_FOR_TABS).GetWidth());
 544             m_tab_scroll_left_button_rect.SetHeight(m_tab_height);
 545             m_tab_scroll_left_button_rect.SetX(m_tab_margin_left);
 546             m_tab_scroll_left_button_rect.SetY(0);
 547             m_tab_scroll_right_button_rect.SetWidth(m_art->GetScrollButtonMinimumSize(temp_dc, this, wxRIBBON_SCROLL_BTN_RIGHT | wxRIBBON_SCROLL_BTN_NORMAL | wxRIBBON_SCROLL_BTN_FOR_TABS).GetWidth());
 548             m_tab_scroll_right_button_rect.SetHeight(m_tab_height);
 549             m_tab_scroll_right_button_rect.SetX(right_button_pos);
 550             m_tab_scroll_right_button_rect.SetY(0);
 551         }
 552         if(m_tab_scroll_amount == 0)
 553         {
 554             m_tab_scroll_left_button_rect.SetWidth(0);
 555         }
 556         else if(m_tab_scroll_amount + width >= m_tabs_total_width_minimum)
 557         {
 558             m_tab_scroll_amount = m_tabs_total_width_minimum - width;
 559             m_tab_scroll_right_button_rect.SetX(m_tab_scroll_right_button_rect.GetX() + m_tab_scroll_right_button_rect.GetWidth());
 560             m_tab_scroll_right_button_rect.SetWidth(0);
 561         }
 562         for(i = 0; i < numtabs; ++i)
 563         {
 564             wxRibbonPageTabInfo& info = m_pages.Item(i);
 565             if (!info.shown)
 566                 continue;
 567             info.rect.x -= m_tab_scroll_amount;
 568         }
 569     }
 570     else
 571     {
 572         m_tab_scroll_buttons_shown = false;
 573         m_tab_scroll_left_button_rect.SetWidth(0);
 574         m_tab_scroll_right_button_rect.SetWidth(0);
 575         // Complex case: everything sized such that: minimum <= width < ideal
 576         /*
 577            Strategy:
 578              1) Uniformly reduce all tab widths from ideal to small_must_have_separator_width
 579              2) Reduce the largest tab by 1 pixel, repeating until all tabs are same width (or at minimum)
 580              3) Uniformly reduce all tabs down to their minimum width
 581         */
 582         int smallest_tab_width = INT_MAX;
 583         int total_small_width = tabsep * (numtabs - 1);
 584         size_t i;
 585         for(i = 0; i < numtabs; ++i)
 586         {
 587             wxRibbonPageTabInfo& info = m_pages.Item(i);
 588             if (!info.shown)
 589                 continue;
 590             if(info.small_must_have_separator_width < smallest_tab_width)
 591             {
 592                 smallest_tab_width = info.small_must_have_separator_width;
 593             }
 594             total_small_width += info.small_must_have_separator_width;
 595         }
 596         if(width >= total_small_width)
 597         {
 598             // Do (1)
 599             int total_delta = m_tabs_total_width_ideal - total_small_width;
 600             total_small_width -= tabsep * (numtabs - 1);
 601             width -= tabsep * (numtabs - 1);
 602             for(i = 0; i < numtabs; ++i)
 603             {
 604                 wxRibbonPageTabInfo& info = m_pages.Item(i);
 605                 if (!info.shown)
 606                     continue;
 607                 int delta = info.ideal_width - info.small_must_have_separator_width;
 608                 info.rect.x = x;
 609                 info.rect.y = y;
 610                 info.rect.width = info.small_must_have_separator_width + delta * (width - total_small_width) / total_delta;
 611                 info.rect.height = m_tab_height;
 612
 613                 x += info.rect.width + tabsep;
 614                 total_delta -= delta;
 615                 total_small_width -= info.small_must_have_separator_width;
 616                 width -= info.rect.width;
 617             }
 618         }
 619         else
 620         {
 621             total_small_width = tabsep * (numtabs - 1);
 622             for(i = 0; i < numtabs; ++i)
 623             {
 624                 wxRibbonPageTabInfo& info = m_pages.Item(i);
 625                 if (!info.shown)
 626                     continue;
 627                 if(info.minimum_width < smallest_tab_width)
 628                 {
 629                     total_small_width += smallest_tab_width;
 630                 }
 631                 else
 632                 {
 633                     total_small_width += info.minimum_width;
 634                 }
 635             }
 636             if(width >= total_small_width)
 637             {
 638                 // Do (2)
 639                 wxVector<PageComparedBySmallWidthAsc> sorted_pages;
 640                 sorted_pages.reserve(numtabs);
 641                 for ( i = 0; i < numtabs; ++i )
 642                     sorted_pages.push_back(PageComparedBySmallWidthAsc(&m_pages.Item(i)));
 643
 644                 wxVectorSort(sorted_pages);
 645                 width -= tabsep * (numtabs - 1);
 646                 for(i = 0; i < numtabs; ++i)
 647                 {
 648                     wxRibbonPageTabInfo* info = sorted_pages[i].m_page;
 649                     if (!info->shown)
 650                         continue;
 651                     if(info->small_must_have_separator_width * (int)(numtabs - i) <= width)
 652                     {
 653                         info->rect.width = info->small_must_have_separator_width;;
 654                     }
 655                     else
 656                     {
 657                         info->rect.width = width / (numtabs - i);
 658                     }
 659                     width -= info->rect.width;
 660                 }
 661                 for(i = 0; i < numtabs; ++i)
 662                 {
 663                     wxRibbonPageTabInfo& info = m_pages.Item(i);
 664                     if (!info.shown)
 665                         continue;
 666                     info.rect.x = x;
 667                     info.rect.y = y;
 668                     info.rect.height = m_tab_height;
 669                     x += info.rect.width + tabsep;
 670                 }
 671             }
 672             else
 673             {
 674                 // Do (3)
 675                 total_small_width = (smallest_tab_width + tabsep) * numtabs - tabsep;
 676                 int total_delta = total_small_width - m_tabs_total_width_minimum;
 677                 total_small_width = m_tabs_total_width_minimum - tabsep * (numtabs - 1);
 678                 width -= tabsep * (numtabs - 1);
 679                 for(i = 0; i < numtabs; ++i)
 680                 {
 681                     wxRibbonPageTabInfo& info = m_pages.Item(i);
 682                     if (!info.shown)
 683                         continue;
 684                     int delta = smallest_tab_width - info.minimum_width;
 685                     info.rect.x = x;
 686                     info.rect.y = y;
 687                     info.rect.width = info.minimum_width + delta * (width - total_small_width) / total_delta;
 688                     info.rect.height = m_tab_height;
 689
 690                     x += info.rect.width + tabsep;
 691                     total_delta -= delta;
 692                     total_small_width -= info.minimum_width;
 693                     width -= info.rect.width;
 694                 }
 695             }
 696         }
 697     }
 698 }
 699
 700 wxRibbonBar::wxRibbonBar()
 701 {
 702     m_flags = 0;
 703     m_tabs_total_width_ideal = 0;
 704     m_tabs_total_width_minimum = 0;
 705     m_tab_margin_left = 0;
 706     m_tab_margin_right = 0;
 707     m_tab_height = 0;
 708     m_tab_scroll_amount = 0;
 709     m_current_page = -1;
 710     m_current_hovered_page = -1;
 711     m_tab_scroll_left_button_state = wxRIBBON_SCROLL_BTN_NORMAL;
 712     m_tab_scroll_right_button_state = wxRIBBON_SCROLL_BTN_NORMAL;
 713     m_tab_scroll_buttons_shown = false;
 714     m_arePanelsShown = true;
 715 }
 716
 717 wxRibbonBar::wxRibbonBar(wxWindow* parent,
 718                          wxWindowID id,
 719                          const wxPoint& pos,
 720                          const wxSize& size,
 721                          long style)
 722     : wxRibbonControl(parent, id, pos, size, wxBORDER_NONE)
 723 {
 724     CommonInit(style);
 725 }
 726
 727 wxRibbonBar::~wxRibbonBar()
 728 {
 729     SetArtProvider(NULL);
 730 }
 731
 732 bool wxRibbonBar::Create(wxWindow* parent,
 733                 wxWindowID id,
 734                 const wxPoint& pos,
 735                 const wxSize& size,
 736                 long style)
 737 {
 738     if(!wxRibbonControl::Create(parent, id, pos, size, wxBORDER_NONE))
 739         return false;
 740
 741     CommonInit(style);
 742
 743     return true;
 744 }
 745
 746 void wxRibbonBar::CommonInit(long style)
 747 {
 748     SetName(wxT("wxRibbonBar"));
 749
 750     m_flags = style;
 751     m_tabs_total_width_ideal = 0;
 752     m_tabs_total_width_minimum = 0;
 753     m_tab_margin_left = 50;
 754     m_tab_margin_right = 20;
 755     if ( m_flags & wxRIBBON_BAR_SHOW_TOGGLE_BUTTON )
 756         m_tab_margin_right += 20;
 757     if ( m_flags & wxRIBBON_BAR_SHOW_HELP_BUTTON )
 758         m_tab_margin_right += 20;
 759     m_tab_height = 20; // initial guess
 760     m_tab_scroll_amount = 0;
 761     m_current_page = -1;
 762     m_current_hovered_page = -1;
 763     m_tab_scroll_left_button_state = wxRIBBON_SCROLL_BTN_NORMAL;
 764     m_tab_scroll_right_button_state = wxRIBBON_SCROLL_BTN_NORMAL;
 765     m_tab_scroll_buttons_shown = false;
 766     m_arePanelsShown = true;
 767
 768     if(m_art == NULL)
 769     {
 770         SetArtProvider(new wxRibbonDefaultArtProvider);
 771     }
 772     SetBackgroundStyle(wxBG_STYLE_CUSTOM);
 773
 774     m_toggle_button_hovered = false;
 775     m_bar_hovered = false;
 776
 777     m_ribbon_state = wxRIBBON_BAR_PINNED;
 778 }
 779
 780 void wxRibbonBar::SetArtProvider(wxRibbonArtProvider* art)
 781 {
 782     wxRibbonArtProvider *old = m_art;
 783     m_art = art;
 784
 785     if(art)
 786     {
 787         art->SetFlags(m_flags);
 788     }
 789     size_t numpages = m_pages.GetCount();
 790     size_t i;
 791     for(i = 0; i < numpages; ++i)
 792     {
 793         wxRibbonPage *page = m_pages.Item(i).page;
 794         if(page->GetArtProvider() != art)
 795         {
 796             page->SetArtProvider(art);
 797         }
 798     }
 799
 800     delete old;
 801 }
 802
 803 void wxRibbonBar::OnPaint(wxPaintEvent& WXUNUSED(evt))
 804 {
 805     wxAutoBufferedPaintDC dc(this);
 806
 807     if(GetUpdateRegion().Contains(0, 0, GetClientSize().GetWidth(), m_tab_height) == wxOutRegion)
 808     {
 809         // Nothing to do in the tab area, and the page area is handled by the active page
 810         return;
 811     }
 812
 813     DoEraseBackground(dc);
 814
 815     if ( m_flags & wxRIBBON_BAR_SHOW_HELP_BUTTON  )
 816         m_help_button_rect = m_art->GetRibbonHelpButtonArea(GetSize());
 817     if ( m_flags & wxRIBBON_BAR_SHOW_TOGGLE_BUTTON  )
 818         m_toggle_button_rect = m_art->GetBarToggleButtonArea(GetSize());
 819
 820     size_t numtabs = m_pages.GetCount();
 821     double sep_visibility = 0.0;
 822     bool draw_sep = false;
 823     wxRect tabs_rect(m_tab_margin_left, 0, GetClientSize().GetWidth() - m_tab_margin_left - m_tab_margin_right, m_tab_height);
 824     if(m_tab_scroll_buttons_shown)
 825     {
 826         tabs_rect.x += m_tab_scroll_left_button_rect.GetWidth();
 827         tabs_rect.width -= m_tab_scroll_left_button_rect.GetWidth() + m_tab_scroll_right_button_rect.GetWidth();
 828     }
 829     size_t i;
 830     for(i = 0; i < numtabs; ++i)
 831     {
 832         wxRibbonPageTabInfo& info = m_pages.Item(i);
 833         if (!info.shown)
 834             continue;
 835
 836         dc.DestroyClippingRegion();
 837         if(m_tab_scroll_buttons_shown)
 838         {
 839             if(!tabs_rect.Intersects(info.rect))
 840                 continue;
 841             dc.SetClippingRegion(tabs_rect);
 842         }
 843         dc.SetClippingRegion(info.rect);
 844         m_art->DrawTab(dc, this, info);
 845
 846         if(info.rect.width < info.small_begin_need_separator_width)
 847         {
 848             draw_sep = true;
 849             if(info.rect.width < info.small_must_have_separator_width)
 850             {
 851                 sep_visibility += 1.0;
 852             }
 853             else
 854             {
 855                 sep_visibility += (double)(info.small_begin_need_separator_width - info.rect.width) / (double)(info.small_begin_need_separator_width - info.small_must_have_separator_width);
 856             }
 857         }
 858     }
 859     if(draw_sep)
 860     {
 861         wxRect rect = m_pages.Item(0).rect;
 862         rect.width = m_art->GetMetric(wxRIBBON_ART_TAB_SEPARATION_SIZE);
 863         sep_visibility /= (double)numtabs;
 864         for(i = 0; i < numtabs - 1; ++i)
 865         {
 866             wxRibbonPageTabInfo& info = m_pages.Item(i);
 867             if (!info.shown)
 868                 continue;
 869             rect.x = info.rect.x + info.rect.width;
 870
 871             if(m_tab_scroll_buttons_shown && !tabs_rect.Intersects(rect))
 872             {
 873                 continue;
 874             }
 875
 876             dc.DestroyClippingRegion();
 877             dc.SetClippingRegion(rect);
 878             m_art->DrawTabSeparator(dc, this, rect, sep_visibility);
 879         }
 880     }
 881     if(m_tab_scroll_buttons_shown)
 882     {
 883         if(m_tab_scroll_left_button_rect.GetWidth() != 0)
 884         {
 885             dc.DestroyClippingRegion();
 886             dc.SetClippingRegion(m_tab_scroll_left_button_rect);
 887             m_art->DrawScrollButton(dc, this, m_tab_scroll_left_button_rect, wxRIBBON_SCROLL_BTN_LEFT | m_tab_scroll_left_button_state | wxRIBBON_SCROLL_BTN_FOR_TABS);
 888         }
 889         if(m_tab_scroll_right_button_rect.GetWidth() != 0)
 890         {
 891             dc.DestroyClippingRegion();
 892             dc.SetClippingRegion(m_tab_scroll_right_button_rect);
 893             m_art->DrawScrollButton(dc, this, m_tab_scroll_right_button_rect, wxRIBBON_SCROLL_BTN_RIGHT | m_tab_scroll_right_button_state | wxRIBBON_SCROLL_BTN_FOR_TABS);
 894         }
 895     }
 896
 897     if ( m_flags & wxRIBBON_BAR_SHOW_HELP_BUTTON  )
 898         m_art->DrawHelpButton(dc, this, m_help_button_rect);
 899     if ( m_flags & wxRIBBON_BAR_SHOW_TOGGLE_BUTTON  )
 900         m_art->DrawToggleButton(dc, this, m_toggle_button_rect, m_ribbon_state);
 901
 902 }
 903
 904 void wxRibbonBar::OnEraseBackground(wxEraseEvent& WXUNUSED(evt))
 905 {
 906     // Background painting done in main paint handler to reduce screen flicker
 907 }
 908
 909 void wxRibbonBar::DoEraseBackground(wxDC& dc)
 910 {
 911     wxRect tabs(GetSize());
 912     tabs.height = m_tab_height;
 913     m_art->DrawTabCtrlBackground(dc, this, tabs);
 914 }
 915
 916 void wxRibbonBar::OnSize(wxSizeEvent& evt)
 917 {
 918     RecalculateTabSizes();
 919     if(m_current_page != -1)
 920     {
 921         RepositionPage(m_pages.Item(m_current_page).page);
 922     }
 923     RefreshTabBar();
 924
 925     evt.Skip();
 926 }
 927
 928 void wxRibbonBar::RepositionPage(wxRibbonPage *page)
 929 {
 930     int w, h;
 931     GetSize(&w, &h);
 932     page->SetSizeWithScrollButtonAdjustment(0, m_tab_height, w, h - m_tab_height);
 933 }
 934
 935 wxRibbonPageTabInfo* wxRibbonBar::HitTestTabs(wxPoint position, int* index)
 936 {
 937     wxRect tabs_rect(m_tab_margin_left, 0, GetClientSize().GetWidth() - m_tab_margin_left - m_tab_margin_right, m_tab_height);
 938     if(m_tab_scroll_buttons_shown)
 939     {
 940         tabs_rect.SetX(tabs_rect.GetX() + m_tab_scroll_left_button_rect.GetWidth());
 941         tabs_rect.SetWidth(tabs_rect.GetWidth() - m_tab_scroll_left_button_rect.GetWidth() - m_tab_scroll_right_button_rect.GetWidth());
 942     }
 943     if(tabs_rect.Contains(position))
 944     {
 945         size_t numtabs = m_pages.GetCount();
 946         size_t i;
 947         for(i = 0; i < numtabs; ++i)
 948         {
 949             wxRibbonPageTabInfo& info = m_pages.Item(i);
 950             if (!info.shown)
 951                 continue;
 952             if(info.rect.Contains(position))
 953             {
 954                 if(index != NULL)
 955                 {
 956                     *index = (int)i;
 957                 }
 958                 return &info;
 959             }
 960         }
 961     }
 962     if(index != NULL)
 963     {
 964         *index = -1;
 965     }
 966     return NULL;
 967 }
 968
 969 void wxRibbonBar::OnMouseLeftDown(wxMouseEvent& evt)
 970 {
 971     wxRibbonPageTabInfo *tab = HitTestTabs(evt.GetPosition());
 972     SetFocus();
 973     if ( tab )
 974     {
 975         if ( m_ribbon_state == wxRIBBON_BAR_MINIMIZED )
 976         {
 977             ShowPanels();
 978             m_ribbon_state = wxRIBBON_BAR_EXPANDED;
 979         }
 980         else if ( (tab == &m_pages.Item(m_current_page)) && (m_ribbon_state == wxRIBBON_BAR_EXPANDED) )
 981         {
 982             HidePanels();
 983             m_ribbon_state = wxRIBBON_BAR_MINIMIZED;
 984         }
 985     }
 986     else
 987     {
 988         if ( m_ribbon_state == wxRIBBON_BAR_EXPANDED )
 989         {
 990             HidePanels();
 991             m_ribbon_state = wxRIBBON_BAR_MINIMIZED;
 992         }
 993     }
 994     if(tab && tab != &m_pages.Item(m_current_page))
 995     {
 996         wxRibbonBarEvent query(wxEVT_COMMAND_RIBBONBAR_PAGE_CHANGING, GetId(), tab->page);
 997         query.SetEventObject(this);
 998         ProcessWindowEvent(query);
 999         if(query.IsAllowed())
1000         {
1001             SetActivePage(query.GetPage());
1002
1003             wxRibbonBarEvent notification(wxEVT_COMMAND_RIBBONBAR_PAGE_CHANGED, GetId(), m_pages.Item(m_current_page).page);
1004             notification.SetEventObject(this);
1005             ProcessWindowEvent(notification);
1006         }
1007     }
1008     else if(tab == NULL)
1009     {
1010         if(m_tab_scroll_left_button_rect.Contains(evt.GetPosition()))
1011         {
1012             m_tab_scroll_left_button_state |= wxRIBBON_SCROLL_BTN_ACTIVE | wxRIBBON_SCROLL_BTN_HOVERED;
1013             RefreshTabBar();
1014         }
1015         else if(m_tab_scroll_right_button_rect.Contains(evt.GetPosition()))
1016         {
1017             m_tab_scroll_right_button_state |= wxRIBBON_SCROLL_BTN_ACTIVE | wxRIBBON_SCROLL_BTN_HOVERED;
1018             RefreshTabBar();
1019         }
1020     }
1021
1022     wxPoint position = evt.GetPosition();
1023
1024     if(position.x >= 0 && position.y >= 0)
1025     {
1026         wxSize size = GetSize();
1027         if(position.x < size.GetWidth() && position.y < size.GetHeight())
1028         {
1029             if(m_toggle_button_rect.Contains(position))
1030             {
1031                 bool pshown = ArePanelsShown();
1032                 ShowPanels(!pshown);
1033                 if ( pshown )
1034                     m_ribbon_state = wxRIBBON_BAR_MINIMIZED;
1035                 else
1036                     m_ribbon_state = wxRIBBON_BAR_PINNED;
1037                 wxRibbonBarEvent event(wxEVT_COMMAND_RIBBONBAR_TOGGLED, GetId());
1038                 event.SetEventObject(this);
1039                 ProcessWindowEvent(event);
1040             }
1041             if ( m_help_button_rect.Contains(position) )
1042             {
1043                 wxRibbonBarEvent event(wxEVT_COMMAND_RIBBONBAR_HELP_CLICKED, GetId());
1044                 event.SetEventObject(this);
1045                 ProcessWindowEvent(event);
1046             }
1047         }
1048     }
1049 }
1050
1051 void wxRibbonBar::OnMouseLeftUp(wxMouseEvent& WXUNUSED(evt))
1052 {
1053     if(!m_tab_scroll_buttons_shown)
1054     {
1055         return;
1056     }
1057
1058     int amount = 0;
1059     if(m_tab_scroll_left_button_state & wxRIBBON_SCROLL_BTN_ACTIVE)
1060     {
1061         amount = -1;
1062     }
1063     else if(m_tab_scroll_right_button_state & wxRIBBON_SCROLL_BTN_ACTIVE)
1064     {
1065         amount = 1;
1066     }
1067     if(amount != 0)
1068     {
1069         m_tab_scroll_left_button_state &= ~wxRIBBON_SCROLL_BTN_ACTIVE;
1070         m_tab_scroll_right_button_state &= ~wxRIBBON_SCROLL_BTN_ACTIVE;
1071         ScrollTabBar(amount * 8);
1072     }
1073 }
1074
1075 void wxRibbonBar::ScrollTabBar(int amount)
1076 {
1077     bool show_left = true;
1078     bool show_right = true;
1079     if(m_tab_scroll_amount + amount <= 0)
1080     {
1081         amount = -m_tab_scroll_amount;
1082         show_left = false;
1083     }
1084     else if(m_tab_scroll_amount + amount + (GetClientSize().GetWidth() - m_tab_margin_left - m_tab_margin_right) >= m_tabs_total_width_minimum)
1085     {
1086         amount = m_tabs_total_width_minimum - m_tab_scroll_amount - (GetClientSize().GetWidth() - m_tab_margin_left - m_tab_margin_right);
1087         show_right = false;
1088     }
1089     if(amount == 0)
1090     {
1091         return;
1092     }
1093     m_tab_scroll_amount += amount;
1094     size_t numtabs = m_pages.GetCount();
1095     size_t i;
1096     for(i = 0; i < numtabs; ++i)
1097     {
1098         wxRibbonPageTabInfo& info = m_pages.Item(i);
1099         if (!info.shown)
1100             continue;
1101         info.rect.SetX(info.rect.GetX() - amount);
1102     }
1103     if(show_right != (m_tab_scroll_right_button_rect.GetWidth() != 0) ||
1104         show_left != (m_tab_scroll_left_button_rect.GetWidth() != 0))
1105     {
1106         wxClientDC temp_dc(this);
1107         if(show_left)
1108         {
1109             m_tab_scroll_left_button_rect.SetWidth(m_art->GetScrollButtonMinimumSize(temp_dc, this, wxRIBBON_SCROLL_BTN_LEFT | wxRIBBON_SCROLL_BTN_NORMAL | wxRIBBON_SCROLL_BTN_FOR_TABS).GetWidth());
1110         }
1111         else
1112         {
1113             m_tab_scroll_left_button_rect.SetWidth(0);
1114         }
1115
1116         if(show_right)
1117         {
1118             if(m_tab_scroll_right_button_rect.GetWidth() == 0)
1119             {
1120                 m_tab_scroll_right_button_rect.SetWidth(m_art->GetScrollButtonMinimumSize(temp_dc, this, wxRIBBON_SCROLL_BTN_RIGHT | wxRIBBON_SCROLL_BTN_NORMAL | wxRIBBON_SCROLL_BTN_FOR_TABS).GetWidth());
1121                 m_tab_scroll_right_button_rect.SetX(m_tab_scroll_right_button_rect.GetX() - m_tab_scroll_right_button_rect.GetWidth());
1122             }
1123         }
1124         else
1125         {
1126             if(m_tab_scroll_right_button_rect.GetWidth() != 0)
1127             {
1128                 m_tab_scroll_right_button_rect.SetX(m_tab_scroll_right_button_rect.GetX() + m_tab_scroll_right_button_rect.GetWidth());
1129                 m_tab_scroll_right_button_rect.SetWidth(0);
1130             }
1131         }
1132     }
1133
1134     RefreshTabBar();
1135 }
1136
1137 void wxRibbonBar::RefreshTabBar()
1138 {
1139     wxRect tab_rect(0, 0, GetClientSize().GetWidth(), m_tab_height);
1140     Refresh(false, &tab_rect);
1141 }
1142
1143 void wxRibbonBar::OnMouseMiddleDown(wxMouseEvent& evt)
1144 {
1145     DoMouseButtonCommon(evt, wxEVT_COMMAND_RIBBONBAR_TAB_MIDDLE_DOWN);
1146 }
1147
1148 void wxRibbonBar::OnMouseMiddleUp(wxMouseEvent& evt)
1149 {
1150     DoMouseButtonCommon(evt, wxEVT_COMMAND_RIBBONBAR_TAB_MIDDLE_UP);
1151 }
1152
1153 void wxRibbonBar::OnMouseRightDown(wxMouseEvent& evt)
1154 {
1155     DoMouseButtonCommon(evt, wxEVT_COMMAND_RIBBONBAR_TAB_RIGHT_DOWN);
1156 }
1157
1158 void wxRibbonBar::OnMouseRightUp(wxMouseEvent& evt)
1159 {
1160     DoMouseButtonCommon(evt, wxEVT_COMMAND_RIBBONBAR_TAB_RIGHT_UP);
1161 }
1162
1163 void wxRibbonBar::OnMouseDoubleClick(wxMouseEvent& evt)
1164 {
1165     wxRibbonPageTabInfo *tab = HitTestTabs(evt.GetPosition());
1166     SetFocus();
1167     if ( tab && tab == &m_pages.Item(m_current_page) )
1168     {
1169         if ( m_ribbon_state == wxRIBBON_BAR_PINNED )
1170         {
1171             m_ribbon_state = wxRIBBON_BAR_MINIMIZED;
1172             HidePanels();
1173         }
1174         else
1175         {
1176             m_ribbon_state = wxRIBBON_BAR_PINNED;
1177             ShowPanels();
1178         }
1179     }
1180 }
1181
1182 void wxRibbonBar::DoMouseButtonCommon(wxMouseEvent& evt, wxEventType tab_event_type)
1183 {
1184     wxRibbonPageTabInfo *tab = HitTestTabs(evt.GetPosition());
1185     if(tab)
1186     {
1187         wxRibbonBarEvent notification(tab_event_type, GetId(), tab->page);
1188         notification.SetEventObject(this);
1189         ProcessWindowEvent(notification);
1190     }
1191 }
1192
1193 void wxRibbonBar::RecalculateMinSize()
1194 {
1195     wxSize min_size(wxDefaultCoord, wxDefaultCoord);
1196     size_t numtabs = m_pages.GetCount();
1197     if(numtabs != 0)
1198     {
1199         min_size = m_pages.Item(0).page->GetMinSize();
1200
1201         size_t i;
1202         for(i = 1; i < numtabs; ++i)
1203         {
1204             wxRibbonPageTabInfo& info = m_pages.Item(i);
1205             if (!info.shown)
1206                 continue;
1207             wxSize page_min = info.page->GetMinSize();
1208
1209             min_size.x = wxMax(min_size.x, page_min.x);
1210             min_size.y = wxMax(min_size.y, page_min.y);
1211         }
1212     }
1213     if(min_size.y != wxDefaultCoord)
1214     {
1215         // TODO: Decide on best course of action when min height is unspecified
1216         // - should we specify it to the tab minimum, or leave it unspecified?
1217         min_size.IncBy(0, m_tab_height);
1218     }
1219
1220     m_minWidth = min_size.GetWidth();
1221     m_minHeight = m_arePanelsShown ? min_size.GetHeight() : m_tab_height;
1222 }
1223
1224 wxSize wxRibbonBar::DoGetBestSize() const
1225 {
1226     wxSize best(0, 0);
1227     if(m_current_page != -1)
1228     {
1229         best = m_pages.Item(m_current_page).page->GetBestSize();
1230     }
1231     if(best.GetHeight() == wxDefaultCoord)
1232     {
1233         best.SetHeight(m_tab_height);
1234     }
1235     else
1236     {
1237         best.IncBy(0, m_tab_height);
1238     }
1239     if(!m_arePanelsShown)
1240     {
1241         best.SetHeight(m_tab_height);
1242     }
1243     return best;
1244 }
1245
1246 void wxRibbonBar::HitTestRibbonButton(const wxRect& rect, const wxPoint& position, bool &hover_flag)
1247 {
1248     bool hovered = false, toggle_button_hovered = false;
1249     if(position.x >= 0 && position.y >= 0)
1250     {
1251         wxSize size = GetSize();
1252         if(position.x < size.GetWidth() && position.y < size.GetHeight())
1253         {
1254             hovered = true;
1255         }
1256     }
1257     if(hovered)
1258     {
1259         toggle_button_hovered = rect.Contains(position);
1260
1261         if ( hovered != m_bar_hovered || toggle_button_hovered != hover_flag )
1262         {
1263             m_bar_hovered = hovered;
1264             hover_flag = toggle_button_hovered;
1265             Refresh(false);
1266         }
1267     }
1268 }
1269
1270 void wxRibbonBar::HideIfExpanded()
1271 {
1272     if ( m_ribbon_state == wxRIBBON_BAR_EXPANDED )
1273     {
1274         HidePanels();
1275         m_ribbon_state = wxRIBBON_BAR_MINIMIZED;
1276     }
1277     else
1278     {
1279         ShowPanels();
1280         m_ribbon_state = wxRIBBON_BAR_PINNED;
1281     }
1282 }
1283
1284 void wxRibbonBar::OnKillFocus(wxFocusEvent& WXUNUSED(evt))
1285 {
1286     HideIfExpanded();
1287 }
1288
1289 #endif // wxUSE_RIBBON