src/ribbon/page.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/ribbon/page.cpp
   3 // Purpose:     Container for ribbon-bar-style interface panels
   4 // Author:      Peter Cawley
   5 // Modified by:
   6 // Created:     2009-05-25
   7 // RCS-ID:      $Id$
   8 // Copyright:   (C) Peter Cawley
   9 // Licence:     wxWindows licence
  10 ///////////////////////////////////////////////////////////////////////////////
  11 #include "wx/wxprec.h"
  12
  13 #ifdef __BORLANDC__
  14     #pragma hdrstop
  15 #endif
  16
  17 #if wxUSE_RIBBON
  18
  19 #include "wx/ribbon/page.h"
  20 #include "wx/ribbon/art.h"
  21 #include "wx/ribbon/bar.h"
  22 #include "wx/dcbuffer.h"
  23
  24 #ifndef WX_PRECOMP
  25 #endif
  26
  27 #ifdef __WXMSW__
  28 #include "wx/msw/private.h"
  29 #endif
  30
  31 static int GetSizeInOrientation(wxSize size, wxOrientation orientation);
  32
  33 // As scroll buttons need to be rendered on top of a page's child windows, the
  34 // buttons themselves have to be proper child windows (rather than just painted
  35 // onto the page). In order to get proper clipping of a page's children (with
  36 // regard to the scroll button), the scroll buttons are created as children of
  37 // the ribbon bar rather than children of the page. This could not have been
  38 // achieved by creating buttons as children of the page and then doing some Z-order
  39 // manipulation, as this causes problems on win32 due to ribbon panels having the
  40 // transparent flag set.
  41 class wxRibbonPageScrollButton : public wxRibbonControl
  42 {
  43 public:
  44     wxRibbonPageScrollButton(wxRibbonPage* sibling,
  45                  wxWindowID id = wxID_ANY,
  46                  const wxPoint& pos = wxDefaultPosition,
  47                  const wxSize& size = wxDefaultSize,
  48                  long style = 0);
  49
  50     virtual ~wxRibbonPageScrollButton();
  51
  52 protected:
  53     virtual wxBorder GetDefaultBorder() const { return wxBORDER_NONE; }
  54
  55     void OnEraseBackground(wxEraseEvent& evt);
  56     void OnPaint(wxPaintEvent& evt);
  57     void OnMouseEnter(wxMouseEvent& evt);
  58     void OnMouseLeave(wxMouseEvent& evt);
  59     void OnMouseDown(wxMouseEvent& evt);
  60     void OnMouseUp(wxMouseEvent& evt);
  61
  62     wxRibbonPage* m_sibling;
  63     long m_flags;
  64
  65     DECLARE_CLASS(wxRibbonPageScrollButton)
  66     DECLARE_EVENT_TABLE()
  67 };
  68
  69 IMPLEMENT_CLASS(wxRibbonPageScrollButton, wxRibbonControl)
  70
  71 BEGIN_EVENT_TABLE(wxRibbonPageScrollButton, wxRibbonControl)
  72     EVT_ENTER_WINDOW(wxRibbonPageScrollButton::OnMouseEnter)
  73     EVT_ERASE_BACKGROUND(wxRibbonPageScrollButton::OnEraseBackground)
  74     EVT_LEAVE_WINDOW(wxRibbonPageScrollButton::OnMouseLeave)
  75     EVT_LEFT_DOWN(wxRibbonPageScrollButton::OnMouseDown)
  76     EVT_LEFT_UP(wxRibbonPageScrollButton::OnMouseUp)
  77     EVT_PAINT(wxRibbonPageScrollButton::OnPaint)
  78 END_EVENT_TABLE()
  79
  80 wxRibbonPageScrollButton::wxRibbonPageScrollButton(wxRibbonPage* sibling,
  81                  wxWindowID id,
  82                  const wxPoint& pos,
  83                  const wxSize& size,
  84                  long style) : wxRibbonControl(sibling->GetParent(), id, pos, size, wxBORDER_NONE)
  85 {
  86     SetBackgroundStyle(wxBG_STYLE_CUSTOM);
  87     m_sibling = sibling;
  88     m_flags = (style & wxRIBBON_SCROLL_BTN_DIRECTION_MASK) | wxRIBBON_SCROLL_BTN_FOR_PAGE;
  89 }
  90
  91 wxRibbonPageScrollButton::~wxRibbonPageScrollButton()
  92 {
  93 }
  94
  95 void wxRibbonPageScrollButton::OnEraseBackground(wxEraseEvent& WXUNUSED(evt))
  96 {
  97     // Do nothing - all painting done in main paint handler
  98 }
  99
 100 void wxRibbonPageScrollButton::OnPaint(wxPaintEvent& WXUNUSED(evt))
 101 {
 102     wxAutoBufferedPaintDC dc(this);
 103     if(m_art)
 104     {
 105         m_art->DrawScrollButton(dc, this, GetSize(), m_flags);
 106     }
 107 }
 108
 109 void wxRibbonPageScrollButton::OnMouseEnter(wxMouseEvent& WXUNUSED(evt))
 110 {
 111     m_flags |= wxRIBBON_SCROLL_BTN_HOVERED;
 112     Refresh(false);
 113 }
 114
 115 void wxRibbonPageScrollButton::OnMouseLeave(wxMouseEvent& WXUNUSED(evt))
 116 {
 117     m_flags &= ~wxRIBBON_SCROLL_BTN_HOVERED;
 118     m_flags &= ~wxRIBBON_SCROLL_BTN_ACTIVE;
 119     Refresh(false);
 120 }
 121
 122 void wxRibbonPageScrollButton::OnMouseDown(wxMouseEvent& WXUNUSED(evt))
 123 {
 124     m_flags |= wxRIBBON_SCROLL_BTN_ACTIVE;
 125     Refresh(false);
 126 }
 127
 128 void wxRibbonPageScrollButton::OnMouseUp(wxMouseEvent& WXUNUSED(evt))
 129 {
 130     if(m_flags & wxRIBBON_SCROLL_BTN_ACTIVE)
 131     {
 132         m_flags &= ~wxRIBBON_SCROLL_BTN_ACTIVE;
 133         Refresh(false);
 134         switch(m_flags & wxRIBBON_SCROLL_BTN_DIRECTION_MASK)
 135         {
 136         case wxRIBBON_SCROLL_BTN_DOWN:
 137         case wxRIBBON_SCROLL_BTN_RIGHT:
 138             m_sibling->ScrollLines(1);
 139             break;
 140         case wxRIBBON_SCROLL_BTN_UP:
 141         case wxRIBBON_SCROLL_BTN_LEFT:
 142             m_sibling->ScrollLines(-1);
 143             break;
 144         default:
 145             break;
 146         }
 147     }
 148 }
 149
 150 IMPLEMENT_CLASS(wxRibbonPage, wxRibbonControl)
 151
 152 BEGIN_EVENT_TABLE(wxRibbonPage, wxRibbonControl)
 153     EVT_ERASE_BACKGROUND(wxRibbonPage::OnEraseBackground)
 154     EVT_PAINT(wxRibbonPage::OnPaint)
 155     EVT_SIZE(wxRibbonPage::OnSize)
 156 END_EVENT_TABLE()
 157
 158 wxRibbonPage::wxRibbonPage()
 159 {
 160     m_scroll_left_btn = NULL;
 161     m_scroll_right_btn = NULL;
 162     m_scroll_amount = 0;
 163     m_scroll_buttons_visible = false;
 164 }
 165
 166 wxRibbonPage::wxRibbonPage(wxRibbonBar* parent,
 167                    wxWindowID id,
 168                    const wxString& label,
 169                    const wxBitmap& icon,
 170                    long WXUNUSED(style))
 171     : wxRibbonControl(parent, id, wxDefaultPosition, wxDefaultSize, wxBORDER_NONE)
 172 {
 173     CommonInit(label, icon);
 174 }
 175
 176 wxRibbonPage::~wxRibbonPage()
 177 {
 178     delete[] m_size_calc_array;
 179 }
 180
 181 bool wxRibbonPage::Create(wxRibbonBar* parent,
 182                 wxWindowID id,
 183                 const wxString& label,
 184                 const wxBitmap& icon,
 185                 long WXUNUSED(style))
 186 {
 187     if(!wxRibbonControl::Create(parent, id, wxDefaultPosition, wxDefaultSize, wxBORDER_NONE))
 188         return false;
 189
 190     CommonInit(label, icon);
 191
 192     return true;
 193 }
 194
 195 void wxRibbonPage::CommonInit(const wxString& label, const wxBitmap& icon)
 196 {
 197     SetName(label);
 198
 199     SetLabel(label);
 200     m_old_size = wxSize(0, 0);
 201     m_icon = icon;
 202     m_scroll_left_btn = NULL;
 203     m_scroll_right_btn = NULL;
 204     m_size_calc_array = NULL;
 205     m_size_calc_array_size = 0;
 206     m_scroll_amount = 0;
 207     m_scroll_buttons_visible = false;
 208
 209     SetBackgroundStyle(wxBG_STYLE_CUSTOM);
 210
 211     wxDynamicCast(GetParent(), wxRibbonBar)->AddPage(this);
 212 }
 213
 214 void wxRibbonPage::SetArtProvider(wxRibbonArtProvider* art)
 215 {
 216     m_art = art;
 217     for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
 218           node;
 219           node = node->GetNext() )
 220     {
 221         wxWindow* child = node->GetData();
 222         wxRibbonControl* ribbon_child = wxDynamicCast(child, wxRibbonControl);
 223         if(ribbon_child)
 224         {
 225             ribbon_child->SetArtProvider(art);
 226         }
 227     }
 228 }
 229
 230 void wxRibbonPage::AdjustRectToIncludeScrollButtons(wxRect* rect) const
 231 {
 232     if(m_scroll_buttons_visible)
 233     {
 234         if(GetMajorAxis() == wxVERTICAL)
 235         {
 236             if(m_scroll_left_btn)
 237             {
 238                 rect->SetY(rect->GetY() -
 239                     m_scroll_left_btn->GetSize().GetHeight());
 240                 rect->SetHeight(rect->GetHeight() +
 241                     m_scroll_left_btn->GetSize().GetHeight());
 242             }
 243             if(m_scroll_right_btn)
 244             {
 245                 rect->SetHeight(rect->GetHeight() +
 246                     m_scroll_right_btn->GetSize().GetHeight());
 247             }
 248         }
 249         else
 250         {
 251             if(m_scroll_left_btn)
 252             {
 253                 rect->SetX(rect->GetX() -
 254                     m_scroll_left_btn->GetSize().GetWidth());
 255                 rect->SetWidth(rect->GetWidth() +
 256                     m_scroll_left_btn->GetSize().GetWidth());
 257             }
 258             if(m_scroll_right_btn)
 259             {
 260                 rect->SetWidth(rect->GetWidth() +
 261                     m_scroll_right_btn->GetSize().GetWidth());
 262             }
 263         }
 264     }
 265 }
 266
 267 void wxRibbonPage::OnEraseBackground(wxEraseEvent& WXUNUSED(evt))
 268 {
 269     // All painting done in main paint handler to minimise flicker
 270 }
 271
 272 void wxRibbonPage::OnPaint(wxPaintEvent& WXUNUSED(evt))
 273 {
 274     // No foreground painting done by the page itself, but a paint DC
 275     // must be created anyway.
 276     wxAutoBufferedPaintDC dc(this);
 277     wxRect rect(GetSize());
 278     AdjustRectToIncludeScrollButtons(&rect);
 279     m_art->DrawPageBackground(dc, this, rect);
 280 }
 281
 282 wxOrientation wxRibbonPage::GetMajorAxis() const
 283 {
 284     if(m_art && (m_art->GetFlags() & wxRIBBON_BAR_FLOW_VERTICAL))
 285     {
 286         return wxVERTICAL;
 287     }
 288     else
 289     {
 290         return wxHORIZONTAL;
 291     }
 292 }
 293
 294 bool wxRibbonPage::ScrollLines(int lines)
 295 {
 296     return ScrollPixels(lines * 8);
 297 }
 298
 299 bool wxRibbonPage::ScrollPixels(int pixels)
 300 {
 301     if(pixels < 0)
 302     {
 303         if(m_scroll_amount == 0)
 304             return false;
 305         if(m_scroll_amount < -pixels)
 306             pixels = -m_scroll_amount;
 307     }
 308     else if(pixels > 0)
 309     {
 310         if(m_scroll_amount == m_scroll_amount_limit)
 311             return false;
 312         if(m_scroll_amount + pixels > m_scroll_amount_limit)
 313             pixels = m_scroll_amount_limit - m_scroll_amount;
 314     }
 315     else
 316         return false;
 317
 318     m_scroll_amount += pixels;
 319
 320     for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
 321               node;
 322               node = node->GetNext() )
 323     {
 324         wxWindow* child = node->GetData();
 325         int x, y;
 326         child->GetPosition(&x, &y);
 327         if(GetMajorAxis() == wxHORIZONTAL)
 328             x -= pixels;
 329         else
 330             y -= pixels;
 331         child->SetPosition(wxPoint(x, y));
 332     }
 333
 334     ShowScrollButtons();
 335     Refresh();
 336     return true;
 337 }
 338
 339 void wxRibbonPage::SetSizeWithScrollButtonAdjustment(int x, int y, int width, int height)
 340 {
 341     if(m_scroll_buttons_visible)
 342     {
 343         if(GetMajorAxis() == wxHORIZONTAL)
 344         {
 345             if(m_scroll_left_btn)
 346             {
 347                 int w = m_scroll_left_btn->GetSize().GetWidth();
 348                 m_scroll_left_btn->SetPosition(wxPoint(x, y));
 349                 x += w;
 350                 width -= w;
 351             }
 352             if(m_scroll_right_btn)
 353             {
 354                 int w = m_scroll_right_btn->GetSize().GetWidth();
 355                 width -= w;
 356                 m_scroll_right_btn->SetPosition(wxPoint(x + width, y));
 357             }
 358         }
 359         else
 360         {
 361             if(m_scroll_left_btn)
 362             {
 363                 int h = m_scroll_left_btn->GetSize().GetHeight();
 364                 m_scroll_left_btn->SetPosition(wxPoint(x, y));
 365                 y += h;
 366                 height -= h;
 367             }
 368             if(m_scroll_right_btn)
 369             {
 370                 int h = m_scroll_right_btn->GetSize().GetHeight();
 371                 height -= h;
 372                 m_scroll_right_btn->SetPosition(wxPoint(x, y + height));
 373             }
 374         }
 375     }
 376     if (width < 0) width = 0;
 377     if (height < 0) height = 0;
 378     SetSize(x, y, width, height);
 379 }
 380
 381 void wxRibbonPage::DoSetSize(int x, int y, int width, int height, int sizeFlags)
 382 {
 383     // When a resize triggers the scroll buttons to become visible, the page is resized.
 384     // This resize from within a resize event can cause (MSW) wxWidgets some confusion,
 385     // and report the 1st size to the 2nd size event. Hence the most recent size is
 386     // remembered internally and used in Layout() where appropriate.
 387
 388     if(GetMajorAxis() == wxHORIZONTAL)
 389     {
 390         m_size_in_major_axis_for_children = width;
 391         if(m_scroll_buttons_visible)
 392         {
 393             if(m_scroll_left_btn)
 394                 m_size_in_major_axis_for_children += m_scroll_left_btn->GetSize().GetWidth();
 395             if(m_scroll_right_btn)
 396                 m_size_in_major_axis_for_children += m_scroll_right_btn->GetSize().GetWidth();
 397         }
 398     }
 399     else
 400     {
 401         m_size_in_major_axis_for_children = height;
 402         if(m_scroll_buttons_visible)
 403         {
 404             if(m_scroll_left_btn)
 405                 m_size_in_major_axis_for_children += m_scroll_left_btn->GetSize().GetHeight();
 406             if(m_scroll_right_btn)
 407                 m_size_in_major_axis_for_children += m_scroll_right_btn->GetSize().GetHeight();
 408         }
 409     }
 410
 411     wxRibbonControl::DoSetSize(x, y, width, height, sizeFlags);
 412 }
 413
 414 void wxRibbonPage::OnSize(wxSizeEvent& evt)
 415 {
 416     wxSize new_size = evt.GetSize();
 417
 418     if (m_art)
 419     {
 420         wxMemoryDC temp_dc;
 421         wxRect invalid_rect = m_art->GetPageBackgroundRedrawArea(temp_dc, this, m_old_size, new_size);
 422         Refresh(true, &invalid_rect);
 423     }
 424
 425     m_old_size = new_size;
 426
 427     if(new_size.GetX() > 0 && new_size.GetY() > 0)
 428     {
 429         Layout();
 430     }
 431     else
 432     {
 433         // Simplify other calculations by pretending new size is zero in both
 434         // X and Y
 435         new_size.Set(0, 0);
 436         // When size == 0, no point in doing any layout
 437     }
 438
 439     evt.Skip();
 440 }
 441
 442 void wxRibbonPage::RemoveChild(wxWindowBase *child)
 443 {
 444     // Remove all references to the child from the collapse stack
 445     size_t count = m_collapse_stack.GetCount();
 446     size_t src, dst;
 447     for(src = 0, dst = 0; src < count; ++src, ++dst)
 448     {
 449         wxRibbonControl *item = m_collapse_stack.Item(src);
 450         if(item == child)
 451         {
 452             ++src;
 453             if(src == count)
 454             {
 455                 break;
 456             }
 457         }
 458         if(src != dst)
 459         {
 460             m_collapse_stack.Item(dst) = item;
 461         }
 462     }
 463     if(src > dst)
 464     {
 465         m_collapse_stack.RemoveAt(dst, src - dst);
 466     }
 467
 468     // ... and then proceed as normal
 469     wxRibbonControl::RemoveChild(child);
 470 }
 471
 472 bool wxRibbonPage::Realize()
 473 {
 474     bool status = true;
 475
 476     m_collapse_stack.Clear();
 477     for (wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
 478                   node;
 479                   node = node->GetNext())
 480     {
 481         wxRibbonControl* child = wxDynamicCast(node->GetData(), wxRibbonControl);
 482         if(child == NULL)
 483         {
 484             continue;
 485         }
 486         if(!child->Realize())
 487         {
 488             status = false;
 489         }
 490     }
 491     PopulateSizeCalcArray(&wxWindow::GetMinSize);
 492
 493     return DoActualLayout() && status;
 494 }
 495
 496 void wxRibbonPage::PopulateSizeCalcArray(wxSize (wxWindow::*get_size)(void) const)
 497 {
 498     wxSize parentSize = GetSize();
 499     parentSize.x -= m_art->GetMetric(wxRIBBON_ART_PAGE_BORDER_LEFT_SIZE);
 500     parentSize.x -= m_art->GetMetric(wxRIBBON_ART_PAGE_BORDER_RIGHT_SIZE);
 501     parentSize.y -= m_art->GetMetric(wxRIBBON_ART_PAGE_BORDER_TOP_SIZE);
 502     parentSize.y -= m_art->GetMetric(wxRIBBON_ART_PAGE_BORDER_BOTTOM_SIZE);
 503
 504     if(m_size_calc_array_size != GetChildren().GetCount())
 505     {
 506         delete[] m_size_calc_array;
 507         m_size_calc_array_size = GetChildren().GetCount();
 508         m_size_calc_array = new wxSize[m_size_calc_array_size];
 509     }
 510
 511     wxSize* node_size = m_size_calc_array;
 512     for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
 513           node;
 514           node = node->GetNext(), ++node_size )
 515     {
 516         wxWindow* child = node->GetData();
 517         wxRibbonPanel* panel = wxDynamicCast(child, wxRibbonPanel);
 518         if (panel && panel->GetFlags() & wxRIBBON_PANEL_FLEXIBLE)
 519             *node_size = panel->GetBestSizeForParentSize(parentSize);
 520         else
 521             *node_size = (child->*get_size)();
 522     }
 523 }
 524
 525 bool wxRibbonPage::Layout()
 526 {
 527     if(GetChildren().GetCount() == 0)
 528     {
 529         return true;
 530     }
 531     else
 532     {
 533         PopulateSizeCalcArray(&wxWindow::GetSize);
 534         return DoActualLayout();
 535     }
 536 }
 537
 538 bool wxRibbonPage::DoActualLayout()
 539 {
 540     wxPoint origin(m_art->GetMetric(wxRIBBON_ART_PAGE_BORDER_LEFT_SIZE), m_art->GetMetric(wxRIBBON_ART_PAGE_BORDER_TOP_SIZE));
 541     wxOrientation major_axis = GetMajorAxis();
 542     int gap;
 543     int minor_axis_size;
 544     int available_space;
 545     if(major_axis == wxHORIZONTAL)
 546     {
 547         gap = m_art->GetMetric(wxRIBBON_ART_PANEL_X_SEPARATION_SIZE);
 548         minor_axis_size = GetSize().GetHeight() - origin.y - m_art->GetMetric(wxRIBBON_ART_PAGE_BORDER_BOTTOM_SIZE);
 549         available_space = m_size_in_major_axis_for_children - m_art->GetMetric(wxRIBBON_ART_PAGE_BORDER_RIGHT_SIZE) - origin.x;
 550     }
 551     else
 552     {
 553         gap = m_art->GetMetric(wxRIBBON_ART_PANEL_Y_SEPARATION_SIZE);
 554         minor_axis_size = GetSize().GetWidth() - origin.x - m_art->GetMetric(wxRIBBON_ART_PAGE_BORDER_RIGHT_SIZE);
 555         available_space = m_size_in_major_axis_for_children - m_art->GetMetric(wxRIBBON_ART_PAGE_BORDER_BOTTOM_SIZE) - origin.y;
 556     }
 557     if (minor_axis_size < 0) minor_axis_size = 0;
 558     size_t size_index;
 559     for(size_index = 0; size_index < m_size_calc_array_size; ++size_index)
 560     {
 561         if(major_axis == wxHORIZONTAL)
 562         {
 563             available_space -= m_size_calc_array[size_index].GetWidth();
 564             m_size_calc_array[size_index].SetHeight(minor_axis_size);
 565         }
 566         else
 567         {
 568             available_space -= m_size_calc_array[size_index].GetHeight();
 569             m_size_calc_array[size_index].SetWidth(minor_axis_size);
 570         }
 571         if(size_index != 0)
 572             available_space -= gap;
 573     }
 574     bool todo_hide_scroll_buttons = false;
 575     bool todo_show_scroll_buttons = false;
 576     if(available_space >= 0)
 577     {
 578         if(m_scroll_buttons_visible)
 579             todo_hide_scroll_buttons = true;
 580         if(available_space > 0)
 581             ExpandPanels(major_axis, available_space);
 582     }
 583     else
 584     {
 585         if(m_scroll_buttons_visible)
 586         {
 587             // Scroll buttons already visible - not going to be able to downsize any more
 588             m_scroll_amount_limit = -available_space;
 589             if(m_scroll_amount > m_scroll_amount_limit)
 590             {
 591                 m_scroll_amount = m_scroll_amount_limit;
 592                 todo_show_scroll_buttons = true;
 593             }
 594         }
 595         else
 596         {
 597             if(!CollapsePanels(major_axis, -available_space))
 598             {
 599                 m_scroll_amount = 0;
 600                 m_scroll_amount_limit = -available_space;
 601                 todo_show_scroll_buttons = true;
 602             }
 603         }
 604     }
 605     if(m_scroll_buttons_visible)
 606     {
 607         if(major_axis == wxHORIZONTAL)
 608         {
 609             origin.x -= m_scroll_amount;
 610             if(m_scroll_left_btn)
 611                 origin.x -= m_scroll_left_btn->GetSize().GetWidth();
 612         }
 613         else
 614         {
 615             origin.y -= m_scroll_amount;
 616             if(m_scroll_left_btn)
 617                 origin.y -= m_scroll_left_btn->GetSize().GetHeight();
 618         }
 619     }
 620     size_index = 0;
 621     for(wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
 622         node;
 623         node = node->GetNext(), ++size_index )
 624     {
 625         wxWindow* child = node->GetData();
 626         int w = m_size_calc_array[size_index].GetWidth();
 627         int h = m_size_calc_array[size_index].GetHeight();
 628         child->SetSize(origin.x, origin.y, w, h);
 629         if(major_axis == wxHORIZONTAL)
 630         {
 631             origin.x += w + gap;
 632         }
 633         else
 634         {
 635             origin.y += h + gap;
 636         }
 637     }
 638
 639     if(todo_show_scroll_buttons)
 640         ShowScrollButtons();
 641     else if(todo_hide_scroll_buttons)
 642         HideScrollButtons();
 643     else if(m_scroll_buttons_visible)
 644         ShowScrollButtons();
 645
 646     Refresh();
 647     return true;
 648 }
 649
 650 bool wxRibbonPage::Show(bool show)
 651 {
 652     if(m_scroll_left_btn)
 653         m_scroll_left_btn->Show(show);
 654     if(m_scroll_right_btn)
 655         m_scroll_right_btn->Show(show);
 656     return wxRibbonControl::Show(show);
 657 }
 658
 659 void wxRibbonPage::HideScrollButtons()
 660 {
 661     m_scroll_amount = 0;
 662     m_scroll_amount_limit = 0;
 663     ShowScrollButtons();
 664 }
 665
 666 void wxRibbonPage::ShowScrollButtons()
 667 {
 668     bool show_left = true;
 669     bool show_right = true;
 670     bool reposition = false;
 671     if(m_scroll_amount == 0)
 672     {
 673         show_left = false;
 674     }
 675     if(m_scroll_amount >= m_scroll_amount_limit)
 676     {
 677         show_right = false;
 678         m_scroll_amount = m_scroll_amount_limit;
 679     }
 680     m_scroll_buttons_visible = show_left || show_right;
 681
 682     if(show_left)
 683     {
 684         wxMemoryDC temp_dc;
 685         wxSize size;
 686         long direction;
 687         if(GetMajorAxis() == wxHORIZONTAL)
 688         {
 689               direction = wxRIBBON_SCROLL_BTN_LEFT;
 690               size = m_art->GetScrollButtonMinimumSize(temp_dc, GetParent(), direction);
 691               size.SetHeight(GetSize().GetHeight());
 692         }
 693         else
 694         {
 695               direction = wxRIBBON_SCROLL_BTN_UP;
 696               size = m_art->GetScrollButtonMinimumSize(temp_dc, GetParent(), direction);
 697               size.SetWidth(GetSize().GetWidth());
 698         }
 699         if (m_scroll_left_btn)
 700         {
 701               m_scroll_left_btn->SetSize(size);
 702         }
 703         else
 704         {
 705               m_scroll_left_btn = new wxRibbonPageScrollButton(this, wxID_ANY, GetPosition(), size, direction);
 706               reposition = true;
 707         }
 708         if(!IsShown())
 709         {
 710               m_scroll_left_btn->Hide();
 711         }
 712     }
 713     else
 714     {
 715         if(m_scroll_left_btn != NULL)
 716         {
 717             m_scroll_left_btn->Destroy();
 718             m_scroll_left_btn = NULL;
 719             reposition = true;
 720         }
 721     }
 722
 723     if(show_right)
 724     {
 725         wxMemoryDC temp_dc;
 726         wxSize size;
 727         long direction;
 728         if(GetMajorAxis() == wxHORIZONTAL)
 729         {
 730               direction = wxRIBBON_SCROLL_BTN_RIGHT;
 731               size = m_art->GetScrollButtonMinimumSize(temp_dc, GetParent(), direction);
 732               size.SetHeight(GetSize().GetHeight());
 733         }
 734         else
 735         {
 736               direction = wxRIBBON_SCROLL_BTN_DOWN;
 737               size = m_art->GetScrollButtonMinimumSize(temp_dc, GetParent(), direction);
 738               size.SetWidth(GetSize().GetWidth());
 739         }
 740         wxPoint initial_pos = GetPosition() + GetSize() - size;
 741         if (m_scroll_right_btn)
 742         {
 743               m_scroll_right_btn->SetSize(size);
 744         }
 745         else
 746         {
 747               m_scroll_right_btn = new wxRibbonPageScrollButton(this, wxID_ANY, initial_pos, size, direction);
 748               reposition = true;
 749         }
 750         if(!IsShown())
 751         {
 752               m_scroll_right_btn->Hide();
 753         }
 754     }
 755     else
 756     {
 757         if(m_scroll_right_btn != NULL)
 758         {
 759             m_scroll_right_btn->Destroy();
 760             m_scroll_right_btn = NULL;
 761             reposition = true;
 762         }
 763     }
 764
 765     if(reposition)
 766     {
 767         wxDynamicCast(GetParent(), wxRibbonBar)->RepositionPage(this);
 768     }
 769 }
 770
 771 static int GetSizeInOrientation(wxSize size, wxOrientation orientation)
 772 {
 773     switch(orientation)
 774     {
 775     case wxHORIZONTAL: return size.GetWidth();
 776     case wxVERTICAL: return size.GetHeight();
 777     case wxBOTH: return size.GetWidth() * size.GetHeight();
 778     default: return 0;
 779     }
 780 }
 781
 782 bool wxRibbonPage::ExpandPanels(wxOrientation direction, int maximum_amount)
 783 {
 784     bool expanded_something = false;
 785     while(maximum_amount > 0)
 786     {
 787         int smallest_size = INT_MAX;
 788         wxRibbonPanel* smallest_panel = NULL;
 789         wxSize* smallest_panel_size = NULL;
 790         wxSize* panel_size = m_size_calc_array;
 791         for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
 792                   node;
 793                   node = node->GetNext(), ++panel_size )
 794         {
 795             wxRibbonPanel* panel = wxDynamicCast(node->GetData(), wxRibbonPanel);
 796             if(panel == NULL)
 797             {
 798                 continue;
 799             }
 800             if (panel->GetFlags() & wxRIBBON_PANEL_FLEXIBLE)
 801             {
 802                 // Don't change if it's flexible since we already calculated the
 803                 // correct size for the panel.
 804             }
 805             else if(panel->IsSizingContinuous())
 806             {
 807                 int size = GetSizeInOrientation(*panel_size, direction);
 808                 if(size < smallest_size)
 809                 {
 810                     smallest_size = size;
 811                     smallest_panel = panel;
 812                     smallest_panel_size = panel_size;
 813                 }
 814             }
 815             else
 816             {
 817                 int size = GetSizeInOrientation(*panel_size, direction);
 818                 if(size < smallest_size)
 819                 {
 820                     wxSize larger = panel->GetNextLargerSize(direction, *panel_size);
 821                     if(larger != (*panel_size) && GetSizeInOrientation(larger, direction) > size)
 822                     {
 823                         smallest_size = size;
 824                         smallest_panel = panel;
 825                         smallest_panel_size = panel_size;
 826                     }
 827                 }
 828             }
 829         }
 830         if(smallest_panel != NULL)
 831         {
 832             if(smallest_panel->IsSizingContinuous())
 833             {
 834                 int amount = maximum_amount;
 835                 if(amount > 32)
 836                 {
 837                     // For "large" growth, grow this panel a bit, and then re-allocate
 838                     // the remainder (which may come to this panel again anyway)
 839                     amount = 32;
 840                 }
 841                 if(direction & wxHORIZONTAL)
 842                 {
 843                     smallest_panel_size->x += amount;
 844                 }
 845                 if(direction & wxVERTICAL)
 846                 {
 847                     smallest_panel_size->y += amount;
 848                 }
 849                 maximum_amount -= amount;
 850                 m_collapse_stack.Add(smallest_panel);
 851                 expanded_something = true;
 852             }
 853             else
 854             {
 855                 wxSize larger = smallest_panel->GetNextLargerSize(direction, *smallest_panel_size);
 856                 wxSize delta = larger - (*smallest_panel_size);
 857                 if(GetSizeInOrientation(delta, direction) <= maximum_amount)
 858                 {
 859                     *smallest_panel_size = larger;
 860                     maximum_amount -= GetSizeInOrientation(delta, direction);
 861                     m_collapse_stack.Add(smallest_panel);
 862                     expanded_something = true;
 863                 }
 864                 else
 865                 {
 866                     break;
 867                 }
 868             }
 869         }
 870         else
 871         {
 872             break;
 873         }
 874     }
 875     return expanded_something;
 876 }
 877
 878 bool wxRibbonPage::CollapsePanels(wxOrientation direction, int minimum_amount)
 879 {
 880     bool collapsed_something = false;
 881     while(minimum_amount > 0)
 882     {
 883         int largest_size = 0;
 884         wxRibbonPanel* largest_panel = NULL;
 885         wxSize* largest_panel_size = NULL;
 886         wxSize* panel_size = m_size_calc_array;
 887         if(!m_collapse_stack.IsEmpty())
 888         {
 889             // For a more consistent panel layout, try to collapse panels which
 890             // were recently expanded.
 891             largest_panel = wxDynamicCast(m_collapse_stack.Last(), wxRibbonPanel);
 892             m_collapse_stack.RemoveAt(m_collapse_stack.GetCount() - 1);
 893             for(wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
 894                       node;
 895                       node = node->GetNext(), ++panel_size )
 896             {
 897                 wxRibbonPanel* panel = wxDynamicCast(node->GetData(), wxRibbonPanel);
 898                 if(panel == largest_panel)
 899                 {
 900                     largest_panel_size = panel_size;
 901                     break;
 902                 }
 903             }
 904         }
 905         else
 906         {
 907             for(wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
 908                       node;
 909                       node = node->GetNext(), ++panel_size )
 910             {
 911                 wxRibbonPanel* panel = wxDynamicCast(node->GetData(), wxRibbonPanel);
 912                 if(panel == NULL)
 913                 {
 914                     continue;
 915                 }
 916                 if(panel->IsSizingContinuous())
 917                 {
 918                     int size = GetSizeInOrientation(*panel_size, direction);
 919                     if(size > largest_size)
 920                     {
 921                         largest_size = size;
 922                         largest_panel = panel;
 923                         largest_panel_size = panel_size;
 924                     }
 925                 }
 926                 else
 927                 {
 928                     int size = GetSizeInOrientation(*panel_size, direction);
 929                     if(size > largest_size)
 930                     {
 931                         wxSize smaller = panel->GetNextSmallerSize(direction, *panel_size);
 932                         if(smaller != (*panel_size) &&
 933                             GetSizeInOrientation(smaller, direction) < size)
 934                         {
 935                             largest_size = size;
 936                             largest_panel = panel;
 937                             largest_panel_size = panel_size;
 938                         }
 939                     }
 940                 }
 941             }
 942         }
 943         if(largest_panel != NULL)
 944         {
 945             if(largest_panel->IsSizingContinuous())
 946             {
 947                 int amount = minimum_amount;
 948                 if(amount > 32)
 949                 {
 950                     // For "large" contraction, reduce this panel a bit, and
 951                     // then re-allocate the remainder of the quota (which may
 952                     // come to this panel again anyway)
 953                     amount = 32;
 954                 }
 955                 if(direction & wxHORIZONTAL)
 956                 {
 957                     largest_panel_size->x -= amount;
 958                 }
 959                 if(direction & wxVERTICAL)
 960                 {
 961                     largest_panel_size->y -= amount;
 962                 }
 963                 minimum_amount -= amount;
 964                 collapsed_something = true;
 965             }
 966             else
 967             {
 968                 wxSize smaller = largest_panel->GetNextSmallerSize(direction, *largest_panel_size);
 969                 wxSize delta = (*largest_panel_size) - smaller;
 970                 *largest_panel_size = smaller;
 971                 minimum_amount -= GetSizeInOrientation(delta, direction);
 972                 collapsed_something = true;
 973             }
 974         }
 975         else
 976         {
 977             break;
 978         }
 979     }
 980     return collapsed_something;
 981 }
 982
 983 bool wxRibbonPage::DismissExpandedPanel()
 984 {
 985     for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
 986               node;
 987               node = node->GetNext() )
 988     {
 989         wxRibbonPanel* panel = wxDynamicCast(node->GetData(), wxRibbonPanel);
 990         if(panel == NULL)
 991         {
 992             continue;
 993         }
 994         if(panel->GetExpandedPanel() != NULL)
 995         {
 996             return panel->HideExpanded();
 997         }
 998     }
 999     return false;
1000 }
1001
1002 wxSize wxRibbonPage::GetMinSize() const
1003 {
1004     wxSize min(wxDefaultCoord, wxDefaultCoord);
1005
1006     for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
1007           node;
1008           node = node->GetNext() )
1009     {
1010         wxWindow* child = node->GetData();
1011         wxSize child_min(child->GetMinSize());
1012
1013         min.x = wxMax(min.x, child_min.x);
1014         min.y = wxMax(min.y, child_min.y);
1015     }
1016
1017     if(GetMajorAxis() == wxHORIZONTAL)
1018     {
1019         min.x = wxDefaultCoord;
1020         if(min.y != wxDefaultCoord)
1021         {
1022             min.y += m_art->GetMetric(wxRIBBON_ART_PAGE_BORDER_TOP_SIZE) + m_art->GetMetric(wxRIBBON_ART_PAGE_BORDER_BOTTOM_SIZE);
1023         }
1024     }
1025     else
1026     {
1027         if(min.x != wxDefaultCoord)
1028         {
1029             min.x += m_art->GetMetric(wxRIBBON_ART_PAGE_BORDER_LEFT_SIZE) + m_art->GetMetric(wxRIBBON_ART_PAGE_BORDER_RIGHT_SIZE);
1030         }
1031         min.y = wxDefaultCoord;
1032     }
1033
1034     return min;
1035 }
1036
1037 wxSize wxRibbonPage::DoGetBestSize() const
1038 {
1039     wxSize best(0, 0);
1040     size_t count = 0;
1041
1042     if(GetMajorAxis() == wxHORIZONTAL)
1043     {
1044         best.y = wxDefaultCoord;
1045
1046         for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
1047           node;
1048           node = node->GetNext() )
1049         {
1050             wxWindow* child = node->GetData();
1051             wxSize child_best(child->GetBestSize());
1052
1053             if(child_best.x != wxDefaultCoord)
1054             {
1055                 best.IncBy(child_best.x, 0);
1056             }
1057             best.y = wxMax(best.y, child_best.y);
1058
1059             ++count;
1060         }
1061
1062         if(count > 1)
1063         {
1064             best.IncBy((count - 1) * m_art->GetMetric(wxRIBBON_ART_PANEL_X_SEPARATION_SIZE), 0);
1065         }
1066     }
1067     else
1068     {
1069         best.x = wxDefaultCoord;
1070
1071         for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
1072           node;
1073           node = node->GetNext() )
1074         {
1075             wxWindow* child = node->GetData();
1076             wxSize child_best(child->GetBestSize());
1077
1078             best.x = wxMax(best.x, child_best.x);
1079             if(child_best.y != wxDefaultCoord)
1080             {
1081                 best.IncBy(0, child_best.y);
1082             }
1083
1084             ++count;
1085         }
1086
1087         if(count > 1)
1088         {
1089             best.IncBy(0, (count - 1) * m_art->GetMetric(wxRIBBON_ART_PANEL_Y_SEPARATION_SIZE));
1090         }
1091     }
1092
1093     if(best.x != wxDefaultCoord)
1094     {
1095         best.x += m_art->GetMetric(wxRIBBON_ART_PAGE_BORDER_LEFT_SIZE) + m_art->GetMetric(wxRIBBON_ART_PAGE_BORDER_RIGHT_SIZE);
1096     }
1097     if(best.y != wxDefaultCoord)
1098     {
1099         best.y += m_art->GetMetric(wxRIBBON_ART_PAGE_BORDER_TOP_SIZE) + m_art->GetMetric(wxRIBBON_ART_PAGE_BORDER_BOTTOM_SIZE);
1100     }
1101     return best;
1102 }
1103
1104 void wxRibbonPage::HideIfExpanded()
1105 {
1106     wxStaticCast(m_parent, wxRibbonBar)->HideIfExpanded();
1107 }
1108
1109 #endif // wxUSE_RIBBON