]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/ribbon/bar.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
missing commit
[wxWidgets.git] / src / ribbon / bar.cpp
... / ...
CommitLineData
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
35WX_DEFINE_USER_EXPORTED_OBJARRAY(wxRibbonPageTabInfoArray)
36
37wxDEFINE_EVENT(wxEVT_RIBBONBAR_PAGE_CHANGED, wxRibbonBarEvent);
38wxDEFINE_EVENT(wxEVT_RIBBONBAR_PAGE_CHANGING, wxRibbonBarEvent);
39wxDEFINE_EVENT(wxEVT_RIBBONBAR_TAB_MIDDLE_DOWN, wxRibbonBarEvent);
40wxDEFINE_EVENT(wxEVT_RIBBONBAR_TAB_MIDDLE_UP, wxRibbonBarEvent);
41wxDEFINE_EVENT(wxEVT_RIBBONBAR_TAB_RIGHT_DOWN, wxRibbonBarEvent);
42wxDEFINE_EVENT(wxEVT_RIBBONBAR_TAB_RIGHT_UP, wxRibbonBarEvent);
43wxDEFINE_EVENT(wxEVT_RIBBONBAR_TAB_LEFT_DCLICK, wxRibbonBarEvent);
44wxDEFINE_EVENT(wxEVT_RIBBONBAR_TOGGLED, wxRibbonBarEvent);
45wxDEFINE_EVENT(wxEVT_RIBBONBAR_HELP_CLICK, wxRibbonBarEvent);
46
47IMPLEMENT_CLASS(wxRibbonBar, wxRibbonControl)
48IMPLEMENT_DYNAMIC_CLASS(wxRibbonBarEvent, wxNotifyEvent)
49
50BEGIN_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)
64END_EVENT_TABLE()
65
66void 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
112bool wxRibbonBar::DismissExpandedPanel()
113{
114 if(m_current_page == -1)
115 return false;
116 return m_pages.Item(m_current_page).page->DismissExpandedPanel();
117}
118
119void wxRibbonBar::ShowPanels(bool show)
120{
121 m_arePanelsShown = show;
122 SetMinSize(wxSize(GetSize().GetWidth(), DoGetBestSize().GetHeight()));
123 Realise();
124 GetParent()->Layout();
125}
126
127void wxRibbonBar::SetWindowStyleFlag(long style)
128{
129 m_flags = style;
130 if(m_art)
131 m_art->SetFlags(style);
132}
133
134long wxRibbonBar::GetWindowStyleFlag() const
135{
136 return m_flags;
137}
138
139bool 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
189void 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
257void 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
296wxRibbonPage* 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
303size_t wxRibbonBar::GetPageCount() const
304{
305 return m_pages.GetCount();
306}
307
308bool 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
315void 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
322bool 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
329void 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
336void 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
376void 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
397bool 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
428bool 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
442int 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
456int wxRibbonBar::GetActivePage() const
457{
458 return m_current_page;
459}
460
461void wxRibbonBar::SetTabCtrlMargins(int left, int right)
462{
463 m_tab_margin_left = left;
464 m_tab_margin_right = right;
465
466 RecalculateTabSizes();
467}
468
469struct 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
485void 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
700wxRibbonBar::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 m_help_button_hovered = false;
716}
717
718wxRibbonBar::wxRibbonBar(wxWindow* parent,
719 wxWindowID id,
720 const wxPoint& pos,
721 const wxSize& size,
722 long style)
723 : wxRibbonControl(parent, id, pos, size, wxBORDER_NONE)
724{
725 CommonInit(style);
726}
727
728wxRibbonBar::~wxRibbonBar()
729{
730 SetArtProvider(NULL);
731}
732
733bool wxRibbonBar::Create(wxWindow* parent,
734 wxWindowID id,
735 const wxPoint& pos,
736 const wxSize& size,
737 long style)
738{
739 if(!wxRibbonControl::Create(parent, id, pos, size, wxBORDER_NONE))
740 return false;
741
742 CommonInit(style);
743
744 return true;
745}
746
747void wxRibbonBar::CommonInit(long style)
748{
749 SetName(wxT("wxRibbonBar"));
750
751 m_flags = style;
752 m_tabs_total_width_ideal = 0;
753 m_tabs_total_width_minimum = 0;
754 m_tab_margin_left = 50;
755 m_tab_margin_right = 20;
756 if ( m_flags & wxRIBBON_BAR_SHOW_TOGGLE_BUTTON )
757 m_tab_margin_right += 20;
758 if ( m_flags & wxRIBBON_BAR_SHOW_HELP_BUTTON )
759 m_tab_margin_right += 20;
760 m_tab_height = 20; // initial guess
761 m_tab_scroll_amount = 0;
762 m_current_page = -1;
763 m_current_hovered_page = -1;
764 m_tab_scroll_left_button_state = wxRIBBON_SCROLL_BTN_NORMAL;
765 m_tab_scroll_right_button_state = wxRIBBON_SCROLL_BTN_NORMAL;
766 m_tab_scroll_buttons_shown = false;
767 m_arePanelsShown = true;
768
769 if(m_art == NULL)
770 {
771 SetArtProvider(new wxRibbonDefaultArtProvider);
772 }
773 SetBackgroundStyle(wxBG_STYLE_CUSTOM);
774
775 m_toggle_button_hovered = false;
776 m_bar_hovered = false;
777
778 m_ribbon_state = wxRIBBON_BAR_PINNED;
779}
780
781void wxRibbonBar::SetArtProvider(wxRibbonArtProvider* art)
782{
783 wxRibbonArtProvider *old = m_art;
784 m_art = art;
785
786 if(art)
787 {
788 art->SetFlags(m_flags);
789 }
790 size_t numpages = m_pages.GetCount();
791 size_t i;
792 for(i = 0; i < numpages; ++i)
793 {
794 wxRibbonPage *page = m_pages.Item(i).page;
795 if(page->GetArtProvider() != art)
796 {
797 page->SetArtProvider(art);
798 }
799 }
800
801 delete old;
802}
803
804void wxRibbonBar::OnPaint(wxPaintEvent& WXUNUSED(evt))
805{
806 wxAutoBufferedPaintDC dc(this);
807
808 if(GetUpdateRegion().Contains(0, 0, GetClientSize().GetWidth(), m_tab_height) == wxOutRegion)
809 {
810 // Nothing to do in the tab area, and the page area is handled by the active page
811 return;
812 }
813
814 DoEraseBackground(dc);
815
816 if ( m_flags & wxRIBBON_BAR_SHOW_HELP_BUTTON )
817 m_help_button_rect = m_art->GetRibbonHelpButtonArea(GetSize());
818 if ( m_flags & wxRIBBON_BAR_SHOW_TOGGLE_BUTTON )
819 m_toggle_button_rect = m_art->GetBarToggleButtonArea(GetSize());
820
821 size_t numtabs = m_pages.GetCount();
822 double sep_visibility = 0.0;
823 bool draw_sep = false;
824 wxRect tabs_rect(m_tab_margin_left, 0, GetClientSize().GetWidth() - m_tab_margin_left - m_tab_margin_right, m_tab_height);
825 if(m_tab_scroll_buttons_shown)
826 {
827 tabs_rect.x += m_tab_scroll_left_button_rect.GetWidth();
828 tabs_rect.width -= m_tab_scroll_left_button_rect.GetWidth() + m_tab_scroll_right_button_rect.GetWidth();
829 }
830 size_t i;
831 for(i = 0; i < numtabs; ++i)
832 {
833 wxRibbonPageTabInfo& info = m_pages.Item(i);
834 if (!info.shown)
835 continue;
836
837 dc.DestroyClippingRegion();
838 if(m_tab_scroll_buttons_shown)
839 {
840 if(!tabs_rect.Intersects(info.rect))
841 continue;
842 dc.SetClippingRegion(tabs_rect);
843 }
844 dc.SetClippingRegion(info.rect);
845 m_art->DrawTab(dc, this, info);
846
847 if(info.rect.width < info.small_begin_need_separator_width)
848 {
849 draw_sep = true;
850 if(info.rect.width < info.small_must_have_separator_width)
851 {
852 sep_visibility += 1.0;
853 }
854 else
855 {
856 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);
857 }
858 }
859 }
860 if(draw_sep)
861 {
862 wxRect rect = m_pages.Item(0).rect;
863 rect.width = m_art->GetMetric(wxRIBBON_ART_TAB_SEPARATION_SIZE);
864 sep_visibility /= (double)numtabs;
865 for(i = 0; i < numtabs - 1; ++i)
866 {
867 wxRibbonPageTabInfo& info = m_pages.Item(i);
868 if (!info.shown)
869 continue;
870 rect.x = info.rect.x + info.rect.width;
871
872 if(m_tab_scroll_buttons_shown && !tabs_rect.Intersects(rect))
873 {
874 continue;
875 }
876
877 dc.DestroyClippingRegion();
878 dc.SetClippingRegion(rect);
879 m_art->DrawTabSeparator(dc, this, rect, sep_visibility);
880 }
881 }
882 if(m_tab_scroll_buttons_shown)
883 {
884 if(m_tab_scroll_left_button_rect.GetWidth() != 0)
885 {
886 dc.DestroyClippingRegion();
887 dc.SetClippingRegion(m_tab_scroll_left_button_rect);
888 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);
889 }
890 if(m_tab_scroll_right_button_rect.GetWidth() != 0)
891 {
892 dc.DestroyClippingRegion();
893 dc.SetClippingRegion(m_tab_scroll_right_button_rect);
894 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);
895 }
896 }
897
898 if ( m_flags & wxRIBBON_BAR_SHOW_HELP_BUTTON )
899 m_art->DrawHelpButton(dc, this, m_help_button_rect);
900 if ( m_flags & wxRIBBON_BAR_SHOW_TOGGLE_BUTTON )
901 m_art->DrawToggleButton(dc, this, m_toggle_button_rect, m_ribbon_state);
902
903}
904
905void wxRibbonBar::OnEraseBackground(wxEraseEvent& WXUNUSED(evt))
906{
907 // Background painting done in main paint handler to reduce screen flicker
908}
909
910void wxRibbonBar::DoEraseBackground(wxDC& dc)
911{
912 wxRect tabs(GetSize());
913 tabs.height = m_tab_height;
914 m_art->DrawTabCtrlBackground(dc, this, tabs);
915}
916
917void wxRibbonBar::OnSize(wxSizeEvent& evt)
918{
919 RecalculateTabSizes();
920 if(m_current_page != -1)
921 {
922 RepositionPage(m_pages.Item(m_current_page).page);
923 }
924 RefreshTabBar();
925
926 evt.Skip();
927}
928
929void wxRibbonBar::RepositionPage(wxRibbonPage *page)
930{
931 int w, h;
932 GetSize(&w, &h);
933 page->SetSizeWithScrollButtonAdjustment(0, m_tab_height, w, h - m_tab_height);
934}
935
936wxRibbonPageTabInfo* wxRibbonBar::HitTestTabs(wxPoint position, int* index)
937{
938 wxRect tabs_rect(m_tab_margin_left, 0, GetClientSize().GetWidth() - m_tab_margin_left - m_tab_margin_right, m_tab_height);
939 if(m_tab_scroll_buttons_shown)
940 {
941 tabs_rect.SetX(tabs_rect.GetX() + m_tab_scroll_left_button_rect.GetWidth());
942 tabs_rect.SetWidth(tabs_rect.GetWidth() - m_tab_scroll_left_button_rect.GetWidth() - m_tab_scroll_right_button_rect.GetWidth());
943 }
944 if(tabs_rect.Contains(position))
945 {
946 size_t numtabs = m_pages.GetCount();
947 size_t i;
948 for(i = 0; i < numtabs; ++i)
949 {
950 wxRibbonPageTabInfo& info = m_pages.Item(i);
951 if (!info.shown)
952 continue;
953 if(info.rect.Contains(position))
954 {
955 if(index != NULL)
956 {
957 *index = (int)i;
958 }
959 return &info;
960 }
961 }
962 }
963 if(index != NULL)
964 {
965 *index = -1;
966 }
967 return NULL;
968}
969
970void wxRibbonBar::OnMouseLeftDown(wxMouseEvent& evt)
971{
972 wxRibbonPageTabInfo *tab = HitTestTabs(evt.GetPosition());
973 SetFocus();
974 if ( tab )
975 {
976 if ( m_ribbon_state == wxRIBBON_BAR_MINIMIZED )
977 {
978 ShowPanels();
979 m_ribbon_state = wxRIBBON_BAR_EXPANDED;
980 }
981 else if ( (tab == &m_pages.Item(m_current_page)) && (m_ribbon_state == wxRIBBON_BAR_EXPANDED) )
982 {
983 HidePanels();
984 m_ribbon_state = wxRIBBON_BAR_MINIMIZED;
985 }
986 }
987 else
988 {
989 if ( m_ribbon_state == wxRIBBON_BAR_EXPANDED )
990 {
991 HidePanels();
992 m_ribbon_state = wxRIBBON_BAR_MINIMIZED;
993 }
994 }
995 if(tab && tab != &m_pages.Item(m_current_page))
996 {
997 wxRibbonBarEvent query(wxEVT_RIBBONBAR_PAGE_CHANGING, GetId(), tab->page);
998 query.SetEventObject(this);
999 ProcessWindowEvent(query);
1000 if(query.IsAllowed())
1001 {
1002 SetActivePage(query.GetPage());
1003
1004 wxRibbonBarEvent notification(wxEVT_RIBBONBAR_PAGE_CHANGED, GetId(), m_pages.Item(m_current_page).page);
1005 notification.SetEventObject(this);
1006 ProcessWindowEvent(notification);
1007 }
1008 }
1009 else if(tab == NULL)
1010 {
1011 if(m_tab_scroll_left_button_rect.Contains(evt.GetPosition()))
1012 {
1013 m_tab_scroll_left_button_state |= wxRIBBON_SCROLL_BTN_ACTIVE | wxRIBBON_SCROLL_BTN_HOVERED;
1014 RefreshTabBar();
1015 }
1016 else if(m_tab_scroll_right_button_rect.Contains(evt.GetPosition()))
1017 {
1018 m_tab_scroll_right_button_state |= wxRIBBON_SCROLL_BTN_ACTIVE | wxRIBBON_SCROLL_BTN_HOVERED;
1019 RefreshTabBar();
1020 }
1021 }
1022
1023 wxPoint position = evt.GetPosition();
1024
1025 if(position.x >= 0 && position.y >= 0)
1026 {
1027 wxSize size = GetSize();
1028 if(position.x < size.GetWidth() && position.y < size.GetHeight())
1029 {
1030 if(m_toggle_button_rect.Contains(position))
1031 {
1032 bool pshown = ArePanelsShown();
1033 ShowPanels(!pshown);
1034 if ( pshown )
1035 m_ribbon_state = wxRIBBON_BAR_MINIMIZED;
1036 else
1037 m_ribbon_state = wxRIBBON_BAR_PINNED;
1038 wxRibbonBarEvent event(wxEVT_RIBBONBAR_TOGGLED, GetId());
1039 event.SetEventObject(this);
1040 ProcessWindowEvent(event);
1041 }
1042 if ( m_help_button_rect.Contains(position) )
1043 {
1044 wxRibbonBarEvent event(wxEVT_RIBBONBAR_HELP_CLICK, GetId());
1045 event.SetEventObject(this);
1046 ProcessWindowEvent(event);
1047 }
1048 }
1049 }
1050}
1051
1052void wxRibbonBar::OnMouseLeftUp(wxMouseEvent& WXUNUSED(evt))
1053{
1054 if(!m_tab_scroll_buttons_shown)
1055 {
1056 return;
1057 }
1058
1059 int amount = 0;
1060 if(m_tab_scroll_left_button_state & wxRIBBON_SCROLL_BTN_ACTIVE)
1061 {
1062 amount = -1;
1063 }
1064 else if(m_tab_scroll_right_button_state & wxRIBBON_SCROLL_BTN_ACTIVE)
1065 {
1066 amount = 1;
1067 }
1068 if(amount != 0)
1069 {
1070 m_tab_scroll_left_button_state &= ~wxRIBBON_SCROLL_BTN_ACTIVE;
1071 m_tab_scroll_right_button_state &= ~wxRIBBON_SCROLL_BTN_ACTIVE;
1072 ScrollTabBar(amount * 8);
1073 }
1074}
1075
1076void wxRibbonBar::ScrollTabBar(int amount)
1077{
1078 bool show_left = true;
1079 bool show_right = true;
1080 if(m_tab_scroll_amount + amount <= 0)
1081 {
1082 amount = -m_tab_scroll_amount;
1083 show_left = false;
1084 }
1085 else if(m_tab_scroll_amount + amount + (GetClientSize().GetWidth() - m_tab_margin_left - m_tab_margin_right) >= m_tabs_total_width_minimum)
1086 {
1087 amount = m_tabs_total_width_minimum - m_tab_scroll_amount - (GetClientSize().GetWidth() - m_tab_margin_left - m_tab_margin_right);
1088 show_right = false;
1089 }
1090 if(amount == 0)
1091 {
1092 return;
1093 }
1094 m_tab_scroll_amount += amount;
1095 size_t numtabs = m_pages.GetCount();
1096 size_t i;
1097 for(i = 0; i < numtabs; ++i)
1098 {
1099 wxRibbonPageTabInfo& info = m_pages.Item(i);
1100 if (!info.shown)
1101 continue;
1102 info.rect.SetX(info.rect.GetX() - amount);
1103 }
1104 if(show_right != (m_tab_scroll_right_button_rect.GetWidth() != 0) ||
1105 show_left != (m_tab_scroll_left_button_rect.GetWidth() != 0))
1106 {
1107 wxClientDC temp_dc(this);
1108 if(show_left)
1109 {
1110 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());
1111 }
1112 else
1113 {
1114 m_tab_scroll_left_button_rect.SetWidth(0);
1115 }
1116
1117 if(show_right)
1118 {
1119 if(m_tab_scroll_right_button_rect.GetWidth() == 0)
1120 {
1121 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());
1122 m_tab_scroll_right_button_rect.SetX(m_tab_scroll_right_button_rect.GetX() - m_tab_scroll_right_button_rect.GetWidth());
1123 }
1124 }
1125 else
1126 {
1127 if(m_tab_scroll_right_button_rect.GetWidth() != 0)
1128 {
1129 m_tab_scroll_right_button_rect.SetX(m_tab_scroll_right_button_rect.GetX() + m_tab_scroll_right_button_rect.GetWidth());
1130 m_tab_scroll_right_button_rect.SetWidth(0);
1131 }
1132 }
1133 }
1134
1135 RefreshTabBar();
1136}
1137
1138void wxRibbonBar::RefreshTabBar()
1139{
1140 wxRect tab_rect(0, 0, GetClientSize().GetWidth(), m_tab_height);
1141 Refresh(false, &tab_rect);
1142}
1143
1144void wxRibbonBar::OnMouseMiddleDown(wxMouseEvent& evt)
1145{
1146 DoMouseButtonCommon(evt, wxEVT_RIBBONBAR_TAB_MIDDLE_DOWN);
1147}
1148
1149void wxRibbonBar::OnMouseMiddleUp(wxMouseEvent& evt)
1150{
1151 DoMouseButtonCommon(evt, wxEVT_RIBBONBAR_TAB_MIDDLE_UP);
1152}
1153
1154void wxRibbonBar::OnMouseRightDown(wxMouseEvent& evt)
1155{
1156 DoMouseButtonCommon(evt, wxEVT_RIBBONBAR_TAB_RIGHT_DOWN);
1157}
1158
1159void wxRibbonBar::OnMouseRightUp(wxMouseEvent& evt)
1160{
1161 DoMouseButtonCommon(evt, wxEVT_RIBBONBAR_TAB_RIGHT_UP);
1162}
1163
1164void wxRibbonBar::OnMouseDoubleClick(wxMouseEvent& evt)
1165{
1166 wxRibbonPageTabInfo *tab = HitTestTabs(evt.GetPosition());
1167 SetFocus();
1168 if ( tab && tab == &m_pages.Item(m_current_page) )
1169 {
1170 if ( m_ribbon_state == wxRIBBON_BAR_PINNED )
1171 {
1172 m_ribbon_state = wxRIBBON_BAR_MINIMIZED;
1173 HidePanels();
1174 }
1175 else
1176 {
1177 m_ribbon_state = wxRIBBON_BAR_PINNED;
1178 ShowPanels();
1179 }
1180 }
1181}
1182
1183void wxRibbonBar::DoMouseButtonCommon(wxMouseEvent& evt, wxEventType tab_event_type)
1184{
1185 wxRibbonPageTabInfo *tab = HitTestTabs(evt.GetPosition());
1186 if(tab)
1187 {
1188 wxRibbonBarEvent notification(tab_event_type, GetId(), tab->page);
1189 notification.SetEventObject(this);
1190 ProcessWindowEvent(notification);
1191 }
1192}
1193
1194void wxRibbonBar::RecalculateMinSize()
1195{
1196 wxSize min_size(wxDefaultCoord, wxDefaultCoord);
1197 size_t numtabs = m_pages.GetCount();
1198 if(numtabs != 0)
1199 {
1200 min_size = m_pages.Item(0).page->GetMinSize();
1201
1202 size_t i;
1203 for(i = 1; i < numtabs; ++i)
1204 {
1205 wxRibbonPageTabInfo& info = m_pages.Item(i);
1206 if (!info.shown)
1207 continue;
1208 wxSize page_min = info.page->GetMinSize();
1209
1210 min_size.x = wxMax(min_size.x, page_min.x);
1211 min_size.y = wxMax(min_size.y, page_min.y);
1212 }
1213 }
1214 if(min_size.y != wxDefaultCoord)
1215 {
1216 // TODO: Decide on best course of action when min height is unspecified
1217 // - should we specify it to the tab minimum, or leave it unspecified?
1218 min_size.IncBy(0, m_tab_height);
1219 }
1220
1221 m_minWidth = min_size.GetWidth();
1222 m_minHeight = m_arePanelsShown ? min_size.GetHeight() : m_tab_height;
1223}
1224
1225wxSize wxRibbonBar::DoGetBestSize() const
1226{
1227 wxSize best(0, 0);
1228 if(m_current_page != -1)
1229 {
1230 best = m_pages.Item(m_current_page).page->GetBestSize();
1231 }
1232 if(best.GetHeight() == wxDefaultCoord)
1233 {
1234 best.SetHeight(m_tab_height);
1235 }
1236 else
1237 {
1238 best.IncBy(0, m_tab_height);
1239 }
1240 if(!m_arePanelsShown)
1241 {
1242 best.SetHeight(m_tab_height);
1243 }
1244 return best;
1245}
1246
1247void wxRibbonBar::HitTestRibbonButton(const wxRect& rect, const wxPoint& position, bool &hover_flag)
1248{
1249 bool hovered = false, toggle_button_hovered = false;
1250 if(position.x >= 0 && position.y >= 0)
1251 {
1252 wxSize size = GetSize();
1253 if(position.x < size.GetWidth() && position.y < size.GetHeight())
1254 {
1255 hovered = true;
1256 }
1257 }
1258 if(hovered)
1259 {
1260 toggle_button_hovered = rect.Contains(position);
1261
1262 if ( hovered != m_bar_hovered || toggle_button_hovered != hover_flag )
1263 {
1264 m_bar_hovered = hovered;
1265 hover_flag = toggle_button_hovered;
1266 Refresh(false);
1267 }
1268 }
1269}
1270
1271void wxRibbonBar::HideIfExpanded()
1272{
1273 if ( m_ribbon_state == wxRIBBON_BAR_EXPANDED )
1274 {
1275 HidePanels();
1276 m_ribbon_state = wxRIBBON_BAR_MINIMIZED;
1277 }
1278 else
1279 {
1280 ShowPanels();
1281 m_ribbon_state = wxRIBBON_BAR_PINNED;
1282 }
1283}
1284
1285void wxRibbonBar::OnKillFocus(wxFocusEvent& WXUNUSED(evt))
1286{
1287 HideIfExpanded();
1288}
1289
1290#endif // wxUSE_RIBBON
wxWidgets (Impactor)