]> 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
Second part of #15224 fix: AddRows, AddColumns (dghart)
[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// Copyright: (C) Peter Cawley
8// Licence: wxWindows licence
9///////////////////////////////////////////////////////////////////////////////
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/bar.h"
20#include "wx/ribbon/art.h"
21#include "wx/dcbuffer.h"
22#include "wx/app.h"
23#include "wx/vector.h"
24
25#ifndef WX_PRECOMP
26#endif
27
28#ifdef __WXMSW__
29#include "wx/msw/private.h"
30#endif
31
32#include "wx/arrimpl.cpp"
33
34WX_DEFINE_USER_EXPORTED_OBJARRAY(wxRibbonPageTabInfoArray)
35
36wxDEFINE_EVENT(wxEVT_RIBBONBAR_PAGE_CHANGED, wxRibbonBarEvent);
37wxDEFINE_EVENT(wxEVT_RIBBONBAR_PAGE_CHANGING, wxRibbonBarEvent);
38wxDEFINE_EVENT(wxEVT_RIBBONBAR_TAB_MIDDLE_DOWN, wxRibbonBarEvent);
39wxDEFINE_EVENT(wxEVT_RIBBONBAR_TAB_MIDDLE_UP, wxRibbonBarEvent);
40wxDEFINE_EVENT(wxEVT_RIBBONBAR_TAB_RIGHT_DOWN, wxRibbonBarEvent);
41wxDEFINE_EVENT(wxEVT_RIBBONBAR_TAB_RIGHT_UP, wxRibbonBarEvent);
42wxDEFINE_EVENT(wxEVT_RIBBONBAR_TAB_LEFT_DCLICK, wxRibbonBarEvent);
43wxDEFINE_EVENT(wxEVT_RIBBONBAR_TOGGLED, wxRibbonBarEvent);
44wxDEFINE_EVENT(wxEVT_RIBBONBAR_HELP_CLICK, wxRibbonBarEvent);
45
46IMPLEMENT_CLASS(wxRibbonBar, wxRibbonControl)
47IMPLEMENT_DYNAMIC_CLASS(wxRibbonBarEvent, wxNotifyEvent)
48
49BEGIN_EVENT_TABLE(wxRibbonBar, wxRibbonControl)
50 EVT_ERASE_BACKGROUND(wxRibbonBar::OnEraseBackground)
51 EVT_LEAVE_WINDOW(wxRibbonBar::OnMouseLeave)
52 EVT_LEFT_DOWN(wxRibbonBar::OnMouseLeftDown)
53 EVT_LEFT_UP(wxRibbonBar::OnMouseLeftUp)
54 EVT_MIDDLE_DOWN(wxRibbonBar::OnMouseMiddleDown)
55 EVT_MIDDLE_UP(wxRibbonBar::OnMouseMiddleUp)
56 EVT_MOTION(wxRibbonBar::OnMouseMove)
57 EVT_PAINT(wxRibbonBar::OnPaint)
58 EVT_RIGHT_DOWN(wxRibbonBar::OnMouseRightDown)
59 EVT_RIGHT_UP(wxRibbonBar::OnMouseRightUp)
60 EVT_LEFT_DCLICK(wxRibbonBar::OnMouseDoubleClick)
61 EVT_SIZE(wxRibbonBar::OnSize)
62 EVT_KILL_FOCUS(wxRibbonBar::OnKillFocus)
63END_EVENT_TABLE()
64
65void wxRibbonBar::AddPage(wxRibbonPage *page)
66{
67 wxRibbonPageTabInfo info;
68
69 info.page = page;
70 info.active = false;
71 info.hovered = false;
72 info.highlight = false;
73 info.shown = true;
74 // info.rect not set (intentional)
75
76 wxClientDC dcTemp(this);
77 wxString label = wxEmptyString;
78 if(m_flags & wxRIBBON_BAR_SHOW_PAGE_LABELS)
79 label = page->GetLabel();
80 wxBitmap icon = wxNullBitmap;
81 if(m_flags & wxRIBBON_BAR_SHOW_PAGE_ICONS)
82 icon = page->GetIcon();
83 m_art->GetBarTabWidth(dcTemp, this, label, icon,
84 &info.ideal_width,
85 &info.small_begin_need_separator_width,
86 &info.small_must_have_separator_width,
87 &info.minimum_width);
88
89 if(m_pages.IsEmpty())
90 {
91 m_tabs_total_width_ideal = info.ideal_width;
92 m_tabs_total_width_minimum = info.minimum_width;
93 }
94 else
95 {
96 int sep = m_art->GetMetric(wxRIBBON_ART_TAB_SEPARATION_SIZE);
97 m_tabs_total_width_ideal += sep + info.ideal_width;
98 m_tabs_total_width_minimum += sep + info.minimum_width;
99 }
100 m_pages.Add(info);
101
102 page->Hide(); // Most likely case is that this new page is not the active tab
103 page->SetArtProvider(m_art);
104
105 if(m_pages.GetCount() == 1)
106 {
107 SetActivePage((size_t)0);
108 }
109}
110
111bool wxRibbonBar::DismissExpandedPanel()
112{
113 if(m_current_page == -1)
114 return false;
115 return m_pages.Item(m_current_page).page->DismissExpandedPanel();
116}
117
118void wxRibbonBar::ShowPanels(bool show)
119{
120 m_arePanelsShown = show;
121 SetMinSize(wxSize(GetSize().GetWidth(), DoGetBestSize().GetHeight()));
122 Realise();
123 GetParent()->Layout();
124}
125
126void wxRibbonBar::SetWindowStyleFlag(long style)
127{
128 m_flags = style;
129 if(m_art)
130 m_art->SetFlags(style);
131}
132
133long wxRibbonBar::GetWindowStyleFlag() const
134{
135 return m_flags;
136}
137
138bool wxRibbonBar::Realize()
139{
140 bool status = true;
141
142 wxClientDC dcTemp(this);
143 int sep = m_art->GetMetric(wxRIBBON_ART_TAB_SEPARATION_SIZE);
144 size_t numtabs = m_pages.GetCount();
145 size_t i;
146 for(i = 0; i < numtabs; ++i)
147 {
148 wxRibbonPageTabInfo& info = m_pages.Item(i);
149 if (!info.shown)
150 continue;
151 RepositionPage(info.page);
152 if(!info.page->Realize())
153 {
154 status = false;
155 }
156 wxString label = wxEmptyString;
157 if(m_flags & wxRIBBON_BAR_SHOW_PAGE_LABELS)
158 label = info.page->GetLabel();
159 wxBitmap icon = wxNullBitmap;
160 if(m_flags & wxRIBBON_BAR_SHOW_PAGE_ICONS)
161 icon = info.page->GetIcon();
162 m_art->GetBarTabWidth(dcTemp, this, label, icon,
163 &info.ideal_width,
164 &info.small_begin_need_separator_width,
165 &info.small_must_have_separator_width,
166 &info.minimum_width);
167
168 if(i == 0)
169 {
170 m_tabs_total_width_ideal = info.ideal_width;
171 m_tabs_total_width_minimum = info.minimum_width;
172 }
173 else
174 {
175 m_tabs_total_width_ideal += sep + info.ideal_width;
176 m_tabs_total_width_minimum += sep + info.minimum_width;
177 }
178 }
179 m_tab_height = m_art->GetTabCtrlHeight(dcTemp, this, m_pages);
180
181 RecalculateMinSize();
182 RecalculateTabSizes();
183 Refresh();
184
185 return status;
186}
187
188void wxRibbonBar::OnMouseMove(wxMouseEvent& evt)
189{
190 int x = evt.GetX();
191 int y = evt.GetY();
192 int hovered_page = -1;
193 bool refresh_tabs = false;
194 if(y < m_tab_height)
195 {
196 // It is quite likely that the mouse moved a small amount and is still over the same tab
197 if(m_current_hovered_page != -1 && m_pages.Item((size_t)m_current_hovered_page).rect.Contains(x, y))
198 {
199 hovered_page = m_current_hovered_page;
200 // But be careful, if tabs can be scrolled, then parts of the tab rect may not be valid
201 if(m_tab_scroll_buttons_shown)
202 {
203 if(x >= m_tab_scroll_right_button_rect.GetX() || x < m_tab_scroll_left_button_rect.GetRight())
204 {
205 hovered_page = -1;
206 }
207 }
208 }
209 else
210 {
211 HitTestTabs(evt.GetPosition(), &hovered_page);
212 }
213 }
214 if(hovered_page != m_current_hovered_page)
215 {
216 if(m_current_hovered_page != -1)
217 {
218 m_pages.Item((int)m_current_hovered_page).hovered = false;
219 }
220 m_current_hovered_page = hovered_page;
221 if(m_current_hovered_page != -1)
222 {
223 m_pages.Item((int)m_current_hovered_page).hovered = true;
224 }
225 refresh_tabs = true;
226 }
227 if(m_tab_scroll_buttons_shown)
228 {
229#define SET_FLAG(variable, flag) \
230 { if(((variable) & (flag)) != (flag)) { variable |= (flag); refresh_tabs = true; }}
231#define UNSET_FLAG(variable, flag) \
232 { if((variable) & (flag)) { variable &= ~(flag); refresh_tabs = true; }}
233
234 if(m_tab_scroll_left_button_rect.Contains(x, y))
235 SET_FLAG(m_tab_scroll_left_button_state, wxRIBBON_SCROLL_BTN_HOVERED)
236 else
237 UNSET_FLAG(m_tab_scroll_left_button_state, wxRIBBON_SCROLL_BTN_HOVERED)
238
239 if(m_tab_scroll_right_button_rect.Contains(x, y))
240 SET_FLAG(m_tab_scroll_right_button_state, wxRIBBON_SCROLL_BTN_HOVERED)
241 else
242 UNSET_FLAG(m_tab_scroll_right_button_state, wxRIBBON_SCROLL_BTN_HOVERED)
243#undef SET_FLAG
244#undef UNSET_FLAG
245 }
246 if(refresh_tabs)
247 {
248 RefreshTabBar();
249 }
250 if ( m_flags & wxRIBBON_BAR_SHOW_TOGGLE_BUTTON )
251 HitTestRibbonButton(m_toggle_button_rect, evt.GetPosition(), m_toggle_button_hovered);
252 if ( m_flags & wxRIBBON_BAR_SHOW_HELP_BUTTON )
253 HitTestRibbonButton(m_help_button_rect, evt.GetPosition(), m_help_button_hovered);
254}
255
256void wxRibbonBar::OnMouseLeave(wxMouseEvent& WXUNUSED(evt))
257{
258 // The ribbon bar is (usually) at the top of a window, and at least on MSW, the mouse
259 // can leave the window quickly and leave a tab in the hovered state.
260 bool refresh_tabs = false;
261 if(m_current_hovered_page != -1)
262 {
263 m_pages.Item((int)m_current_hovered_page).hovered = false;
264 m_current_hovered_page = -1;
265 refresh_tabs = true;
266 }
267 if(m_tab_scroll_left_button_state & wxRIBBON_SCROLL_BTN_HOVERED)
268 {
269 m_tab_scroll_left_button_state &= ~wxRIBBON_SCROLL_BTN_HOVERED;
270 refresh_tabs = true;
271 }
272 if(m_tab_scroll_right_button_state & wxRIBBON_SCROLL_BTN_HOVERED)
273 {
274 m_tab_scroll_right_button_state &= ~wxRIBBON_SCROLL_BTN_HOVERED;
275 refresh_tabs = true;
276 }
277 if(refresh_tabs)
278 {
279 RefreshTabBar();
280 }
281 if(m_toggle_button_hovered)
282 {
283 m_bar_hovered = false;
284 m_toggle_button_hovered = false;
285 Refresh(false);
286 }
287 if ( m_help_button_hovered )
288 {
289 m_help_button_hovered = false;
290 m_bar_hovered = false;
291 Refresh(false);
292 }
293}
294
295wxRibbonPage* wxRibbonBar::GetPage(int n)
296{
297 if(n < 0 || (size_t)n >= m_pages.GetCount())
298 return 0;
299 return m_pages.Item(n).page;
300}
301
302size_t wxRibbonBar::GetPageCount() const
303{
304 return m_pages.GetCount();
305}
306
307bool wxRibbonBar::IsPageShown(size_t page) const
308{
309 if (page >= m_pages.GetCount())
310 return false;
311 return m_pages.Item(page).shown;
312}
313
314void wxRibbonBar::ShowPage(size_t page, bool show)
315{
316 if(page >= m_pages.GetCount())
317 return;
318 m_pages.Item(page).shown = show;
319}
320
321bool wxRibbonBar::IsPageHighlighted(size_t page) const
322{
323 if (page >= m_pages.GetCount())
324 return false;
325 return m_pages.Item(page).highlight;
326}
327
328void wxRibbonBar::AddPageHighlight(size_t page, bool highlight)
329{
330 if(page >= m_pages.GetCount())
331 return;
332 m_pages.Item(page).highlight = highlight;
333}
334
335void wxRibbonBar::DeletePage(size_t n)
336{
337 if(n < m_pages.GetCount())
338 {
339 wxRibbonPage *page = m_pages.Item(n).page;
340
341 // Schedule page object for destruction and not destroying directly
342 // as this function can be called in an event handler and page functions
343 // can be called afeter removing.
344 // Like in wxRibbonButtonBar::OnMouseUp
345 if(!wxTheApp->IsScheduledForDestruction(page))
346 {
347 wxTheApp->ScheduleForDestruction(page);
348 }
349
350 m_pages.RemoveAt(n);
351
352 if(m_current_page == static_cast<int>(n))
353 {
354 m_current_page = -1;
355
356 if(m_pages.GetCount() > 0)
357 {
358 if(n >= m_pages.GetCount())
359 {
360 SetActivePage(m_pages.GetCount() - 1);
361 }
362 else
363 {
364 SetActivePage(n - 1);
365 }
366 }
367 }
368 else if(m_current_page > static_cast<int>(n))
369 {
370 m_current_page--;
371 }
372 }
373}
374
375void wxRibbonBar::ClearPages()
376{
377 size_t i;
378 for(i=0; i<m_pages.GetCount(); i++)
379 {
380 wxRibbonPage *page = m_pages.Item(i).page;
381 // Schedule page object for destruction and not destroying directly
382 // as this function can be called in an event handler and page functions
383 // can be called afeter removing.
384 // Like in wxRibbonButtonBar::OnMouseUp
385 if(!wxTheApp->IsScheduledForDestruction(page))
386 {
387 wxTheApp->ScheduleForDestruction(page);
388 }
389 }
390 m_pages.Empty();
391 Realize();
392 m_current_page = -1;
393 Refresh();
394}
395
396bool wxRibbonBar::SetActivePage(size_t page)
397{
398 if(m_current_page == (int)page)
399 {
400 return true;
401 }
402
403 if(page >= m_pages.GetCount())
404 {
405 return false;
406 }
407
408 if(m_current_page != -1)
409 {
410 m_pages.Item((size_t)m_current_page).active = false;
411 m_pages.Item((size_t)m_current_page).page->Hide();
412 }
413 m_current_page = (int)page;
414 m_pages.Item(page).active = true;
415 m_pages.Item(page).shown = true;
416 {
417 wxRibbonPage* wnd = m_pages.Item(page).page;
418 RepositionPage(wnd);
419 wnd->Layout();
420 wnd->Show();
421 }
422 Refresh();
423
424 return true;
425}
426
427bool wxRibbonBar::SetActivePage(wxRibbonPage* page)
428{
429 size_t numpages = m_pages.GetCount();
430 size_t i;
431 for(i = 0; i < numpages; ++i)
432 {
433 if(m_pages.Item(i).page == page)
434 {
435 return SetActivePage(i);
436 }
437 }
438 return false;
439}
440
441int wxRibbonBar::GetPageNumber(wxRibbonPage* page) const
442{
443 size_t numpages = m_pages.GetCount();
444 for(size_t i = 0; i < numpages; ++i)
445 {
446 if(m_pages.Item(i).page == page)
447 {
448 return i;
449 }
450 }
451 return wxNOT_FOUND;
452}
453
454
455int wxRibbonBar::GetActivePage() const
456{
457 return m_current_page;
458}
459
460void wxRibbonBar::SetTabCtrlMargins(int left, int right)
461{
462 m_tab_margin_left = left;
463 m_tab_margin_right = right;
464
465 RecalculateTabSizes();
466}
467
468struct PageComparedBySmallWidthAsc
469{
470 wxEXPLICIT PageComparedBySmallWidthAsc(wxRibbonPageTabInfo* page)
471 : m_page(page)
472 {
473 }
474
475 bool operator<(const PageComparedBySmallWidthAsc& other) const
476 {
477 return m_page->small_must_have_separator_width
478 < other.m_page->small_must_have_separator_width;
479 }
480
481 wxRibbonPageTabInfo *m_page;
482};
483
484void wxRibbonBar::RecalculateTabSizes()
485{
486 size_t numtabs = m_pages.GetCount();
487
488 if(numtabs == 0)
489 return;
490
491 int width = GetSize().GetWidth() - m_tab_margin_left - m_tab_margin_right;
492 int tabsep = m_art->GetMetric(wxRIBBON_ART_TAB_SEPARATION_SIZE);
493 int x = m_tab_margin_left;
494 const int y = 0;
495
496 if(width >= m_tabs_total_width_ideal)
497 {
498 // Simple case: everything at ideal width
499 size_t i;
500 for(i = 0; i < numtabs; ++i)
501 {
502 wxRibbonPageTabInfo& info = m_pages.Item(i);
503 if (!info.shown)
504 continue;
505 info.rect.x = x;
506 info.rect.y = y;
507 info.rect.width = info.ideal_width;
508 info.rect.height = m_tab_height;
509 x += info.rect.width + tabsep;
510 }
511 m_tab_scroll_buttons_shown = false;
512 m_tab_scroll_left_button_rect.SetWidth(0);
513 m_tab_scroll_right_button_rect.SetWidth(0);
514 }
515 else if(width < m_tabs_total_width_minimum)
516 {
517 // Simple case: everything minimum with scrollbar
518 size_t i;
519 for(i = 0; i < numtabs; ++i)
520 {
521 wxRibbonPageTabInfo& info = m_pages.Item(i);
522 if (!info.shown)
523 continue;
524 info.rect.x = x;
525 info.rect.y = y;
526 info.rect.width = info.minimum_width;
527 info.rect.height = m_tab_height;
528 x += info.rect.width + tabsep;
529 }
530 if(!m_tab_scroll_buttons_shown)
531 {
532 m_tab_scroll_left_button_state = wxRIBBON_SCROLL_BTN_NORMAL;
533 m_tab_scroll_right_button_state = wxRIBBON_SCROLL_BTN_NORMAL;
534 m_tab_scroll_buttons_shown = true;
535 }
536 {
537 wxClientDC temp_dc(this);
538 int right_button_pos = GetClientSize().GetWidth() - m_tab_margin_right - m_tab_scroll_right_button_rect.GetWidth();
539 if ( right_button_pos < m_tab_margin_left )
540 right_button_pos = m_tab_margin_left;
541
542 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());
543 m_tab_scroll_left_button_rect.SetHeight(m_tab_height);
544 m_tab_scroll_left_button_rect.SetX(m_tab_margin_left);
545 m_tab_scroll_left_button_rect.SetY(0);
546 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());
547 m_tab_scroll_right_button_rect.SetHeight(m_tab_height);
548 m_tab_scroll_right_button_rect.SetX(right_button_pos);
549 m_tab_scroll_right_button_rect.SetY(0);
550 }
551 if(m_tab_scroll_amount == 0)
552 {
553 m_tab_scroll_left_button_rect.SetWidth(0);
554 }
555 else if(m_tab_scroll_amount + width >= m_tabs_total_width_minimum)
556 {
557 m_tab_scroll_amount = m_tabs_total_width_minimum - width;
558 m_tab_scroll_right_button_rect.SetX(m_tab_scroll_right_button_rect.GetX() + m_tab_scroll_right_button_rect.GetWidth());
559 m_tab_scroll_right_button_rect.SetWidth(0);
560 }
561 for(i = 0; i < numtabs; ++i)
562 {
563 wxRibbonPageTabInfo& info = m_pages.Item(i);
564 if (!info.shown)
565 continue;
566 info.rect.x -= m_tab_scroll_amount;
567 }
568 }
569 else
570 {
571 m_tab_scroll_buttons_shown = false;
572 m_tab_scroll_left_button_rect.SetWidth(0);
573 m_tab_scroll_right_button_rect.SetWidth(0);
574 // Complex case: everything sized such that: minimum <= width < ideal
575 /*
576 Strategy:
577 1) Uniformly reduce all tab widths from ideal to small_must_have_separator_width
578 2) Reduce the largest tab by 1 pixel, repeating until all tabs are same width (or at minimum)
579 3) Uniformly reduce all tabs down to their minimum width
580 */
581 int smallest_tab_width = INT_MAX;
582 int total_small_width = tabsep * (numtabs - 1);
583 size_t i;
584 for(i = 0; i < numtabs; ++i)
585 {
586 wxRibbonPageTabInfo& info = m_pages.Item(i);
587 if (!info.shown)
588 continue;
589 if(info.small_must_have_separator_width < smallest_tab_width)
590 {
591 smallest_tab_width = info.small_must_have_separator_width;
592 }
593 total_small_width += info.small_must_have_separator_width;
594 }
595 if(width >= total_small_width)
596 {
597 // Do (1)
598 int total_delta = m_tabs_total_width_ideal - total_small_width;
599 total_small_width -= tabsep * (numtabs - 1);
600 width -= tabsep * (numtabs - 1);
601 for(i = 0; i < numtabs; ++i)
602 {
603 wxRibbonPageTabInfo& info = m_pages.Item(i);
604 if (!info.shown)
605 continue;
606 int delta = info.ideal_width - info.small_must_have_separator_width;
607 info.rect.x = x;
608 info.rect.y = y;
609 info.rect.width = info.small_must_have_separator_width + delta * (width - total_small_width) / total_delta;
610 info.rect.height = m_tab_height;
611
612 x += info.rect.width + tabsep;
613 total_delta -= delta;
614 total_small_width -= info.small_must_have_separator_width;
615 width -= info.rect.width;
616 }
617 }
618 else
619 {
620 total_small_width = tabsep * (numtabs - 1);
621 for(i = 0; i < numtabs; ++i)
622 {
623 wxRibbonPageTabInfo& info = m_pages.Item(i);
624 if (!info.shown)
625 continue;
626 if(info.minimum_width < smallest_tab_width)
627 {
628 total_small_width += smallest_tab_width;
629 }
630 else
631 {
632 total_small_width += info.minimum_width;
633 }
634 }
635 if(width >= total_small_width)
636 {
637 // Do (2)
638 wxVector<PageComparedBySmallWidthAsc> sorted_pages;
639 sorted_pages.reserve(numtabs);
640 for ( i = 0; i < numtabs; ++i )
641 sorted_pages.push_back(PageComparedBySmallWidthAsc(&m_pages.Item(i)));
642
643 wxVectorSort(sorted_pages);
644 width -= tabsep * (numtabs - 1);
645 for(i = 0; i < numtabs; ++i)
646 {
647 wxRibbonPageTabInfo* info = sorted_pages[i].m_page;
648 if (!info->shown)
649 continue;
650 if(info->small_must_have_separator_width * (int)(numtabs - i) <= width)
651 {
652 info->rect.width = info->small_must_have_separator_width;;
653 }
654 else
655 {
656 info->rect.width = width / (numtabs - i);
657 }
658 width -= info->rect.width;
659 }
660 for(i = 0; i < numtabs; ++i)
661 {
662 wxRibbonPageTabInfo& info = m_pages.Item(i);
663 if (!info.shown)
664 continue;
665 info.rect.x = x;
666 info.rect.y = y;
667 info.rect.height = m_tab_height;
668 x += info.rect.width + tabsep;
669 }
670 }
671 else
672 {
673 // Do (3)
674 total_small_width = (smallest_tab_width + tabsep) * numtabs - tabsep;
675 int total_delta = total_small_width - m_tabs_total_width_minimum;
676 total_small_width = m_tabs_total_width_minimum - tabsep * (numtabs - 1);
677 width -= tabsep * (numtabs - 1);
678 for(i = 0; i < numtabs; ++i)
679 {
680 wxRibbonPageTabInfo& info = m_pages.Item(i);
681 if (!info.shown)
682 continue;
683 int delta = smallest_tab_width - info.minimum_width;
684 info.rect.x = x;
685 info.rect.y = y;
686 info.rect.width = info.minimum_width + delta * (width - total_small_width) / total_delta;
687 info.rect.height = m_tab_height;
688
689 x += info.rect.width + tabsep;
690 total_delta -= delta;
691 total_small_width -= info.minimum_width;
692 width -= info.rect.width;
693 }
694 }
695 }
696 }
697}
698
699wxRibbonBar::wxRibbonBar()
700{
701 m_flags = 0;
702 m_tabs_total_width_ideal = 0;
703 m_tabs_total_width_minimum = 0;
704 m_tab_margin_left = 0;
705 m_tab_margin_right = 0;
706 m_tab_height = 0;
707 m_tab_scroll_amount = 0;
708 m_current_page = -1;
709 m_current_hovered_page = -1;
710 m_tab_scroll_left_button_state = wxRIBBON_SCROLL_BTN_NORMAL;
711 m_tab_scroll_right_button_state = wxRIBBON_SCROLL_BTN_NORMAL;
712 m_tab_scroll_buttons_shown = false;
713 m_arePanelsShown = true;
714 m_help_button_hovered = false;
715}
716
717wxRibbonBar::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
727wxRibbonBar::~wxRibbonBar()
728{
729 SetArtProvider(NULL);
730}
731
732bool 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
746void 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
780void 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
803void 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
904void wxRibbonBar::OnEraseBackground(wxEraseEvent& WXUNUSED(evt))
905{
906 // Background painting done in main paint handler to reduce screen flicker
907}
908
909void wxRibbonBar::DoEraseBackground(wxDC& dc)
910{
911 wxRect tabs(GetSize());
912 tabs.height = m_tab_height;
913 m_art->DrawTabCtrlBackground(dc, this, tabs);
914}
915
916void 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
928void 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
935wxRibbonPageTabInfo* 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
969void 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_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_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_RIBBONBAR_TOGGLED, GetId());
1038 event.SetEventObject(this);
1039 ProcessWindowEvent(event);
1040 }
1041 if ( m_help_button_rect.Contains(position) )
1042 {
1043 wxRibbonBarEvent event(wxEVT_RIBBONBAR_HELP_CLICK, GetId());
1044 event.SetEventObject(this);
1045 ProcessWindowEvent(event);
1046 }
1047 }
1048 }
1049}
1050
1051void 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
1075void 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
1137void wxRibbonBar::RefreshTabBar()
1138{
1139 wxRect tab_rect(0, 0, GetClientSize().GetWidth(), m_tab_height);
1140 Refresh(false, &tab_rect);
1141}
1142
1143void wxRibbonBar::OnMouseMiddleDown(wxMouseEvent& evt)
1144{
1145 DoMouseButtonCommon(evt, wxEVT_RIBBONBAR_TAB_MIDDLE_DOWN);
1146}
1147
1148void wxRibbonBar::OnMouseMiddleUp(wxMouseEvent& evt)
1149{
1150 DoMouseButtonCommon(evt, wxEVT_RIBBONBAR_TAB_MIDDLE_UP);
1151}
1152
1153void wxRibbonBar::OnMouseRightDown(wxMouseEvent& evt)
1154{
1155 DoMouseButtonCommon(evt, wxEVT_RIBBONBAR_TAB_RIGHT_DOWN);
1156}
1157
1158void wxRibbonBar::OnMouseRightUp(wxMouseEvent& evt)
1159{
1160 DoMouseButtonCommon(evt, wxEVT_RIBBONBAR_TAB_RIGHT_UP);
1161}
1162
1163void 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
1182void 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
1193void 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
1224wxSize 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
1246void 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
1270void 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
1284void wxRibbonBar::OnKillFocus(wxFocusEvent& WXUNUSED(evt))
1285{
1286 HideIfExpanded();
1287}
1288
1289#endif // wxUSE_RIBBON
wxWidgets (Impactor)