]> 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
Pass wxRect/wxPoint arguments to wxDataViewCustomRenderer by reference.
[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
24#ifndef WX_PRECOMP
25#endif
26
27#ifdef __WXMSW__
28#include "wx/msw/private.h"
29#endif
30
31#include "wx/arrimpl.cpp"
32
33WX_DEFINE_USER_EXPORTED_OBJARRAY(wxRibbonPageTabInfoArray)
34
35wxDEFINE_EVENT(wxEVT_COMMAND_RIBBONBAR_PAGE_CHANGED, wxRibbonBarEvent);
36wxDEFINE_EVENT(wxEVT_COMMAND_RIBBONBAR_PAGE_CHANGING, wxRibbonBarEvent);
37wxDEFINE_EVENT(wxEVT_COMMAND_RIBBONBAR_TAB_MIDDLE_DOWN, wxRibbonBarEvent);
38wxDEFINE_EVENT(wxEVT_COMMAND_RIBBONBAR_TAB_MIDDLE_UP, wxRibbonBarEvent);
39wxDEFINE_EVENT(wxEVT_COMMAND_RIBBONBAR_TAB_RIGHT_DOWN, wxRibbonBarEvent);
40wxDEFINE_EVENT(wxEVT_COMMAND_RIBBONBAR_TAB_RIGHT_UP, wxRibbonBarEvent);
41wxDEFINE_EVENT(wxEVT_COMMAND_RIBBONBAR_TAB_LEFT_DCLICK, wxRibbonBarEvent);
42
43IMPLEMENT_CLASS(wxRibbonBar, wxRibbonControl)
44IMPLEMENT_DYNAMIC_CLASS(wxRibbonBarEvent, wxNotifyEvent)
45
46BEGIN_EVENT_TABLE(wxRibbonBar, wxRibbonControl)
47 EVT_ERASE_BACKGROUND(wxRibbonBar::OnEraseBackground)
48 EVT_LEAVE_WINDOW(wxRibbonBar::OnMouseLeave)
49 EVT_LEFT_DOWN(wxRibbonBar::OnMouseLeftDown)
50 EVT_LEFT_UP(wxRibbonBar::OnMouseLeftUp)
51 EVT_MIDDLE_DOWN(wxRibbonBar::OnMouseMiddleDown)
52 EVT_MIDDLE_UP(wxRibbonBar::OnMouseMiddleUp)
53 EVT_MOTION(wxRibbonBar::OnMouseMove)
54 EVT_PAINT(wxRibbonBar::OnPaint)
55 EVT_RIGHT_DOWN(wxRibbonBar::OnMouseRightDown)
56 EVT_RIGHT_UP(wxRibbonBar::OnMouseRightUp)
57 EVT_LEFT_DCLICK(wxRibbonBar::OnMouseDoubleClick)
58 EVT_SIZE(wxRibbonBar::OnSize)
59END_EVENT_TABLE()
60
61void wxRibbonBar::AddPage(wxRibbonPage *page)
62{
63 wxRibbonPageTabInfo info;
64
65 info.page = page;
66 info.active = false;
67 info.hovered = false;
68 // info.rect not set (intentional)
69
70 wxClientDC dcTemp(this);
71 wxString label = wxEmptyString;
72 if(m_flags & wxRIBBON_BAR_SHOW_PAGE_LABELS)
73 label = page->GetLabel();
74 wxBitmap icon = wxNullBitmap;
75 if(m_flags & wxRIBBON_BAR_SHOW_PAGE_ICONS)
76 icon = page->GetIcon();
77 m_art->GetBarTabWidth(dcTemp, this, label, icon,
78 &info.ideal_width,
79 &info.small_begin_need_separator_width,
80 &info.small_must_have_separator_width,
81 &info.minimum_width);
82
83 if(m_pages.IsEmpty())
84 {
85 m_tabs_total_width_ideal = info.ideal_width;
86 m_tabs_total_width_minimum = info.minimum_width;
87 }
88 else
89 {
90 int sep = m_art->GetMetric(wxRIBBON_ART_TAB_SEPARATION_SIZE);
91 m_tabs_total_width_ideal += sep + info.ideal_width;
92 m_tabs_total_width_minimum += sep + info.minimum_width;
93 }
94 m_pages.Add(info);
95
96 page->Hide(); // Most likely case is that this new page is not the active tab
97 page->SetArtProvider(m_art);
98
99 if(m_pages.GetCount() == 1)
100 {
101 SetActivePage((size_t)0);
102 }
103}
104
105bool wxRibbonBar::DismissExpandedPanel()
106{
107 if(m_current_page == -1)
108 return false;
109 return m_pages.Item(m_current_page).page->DismissExpandedPanel();
110}
111
112void wxRibbonBar::ShowPanels(bool show)
113{
114 m_arePanelsShown = show;
115 SetMinSize(wxSize(GetSize().GetWidth(), DoGetBestSize().GetHeight()));
116 Realise();
117 GetParent()->Layout();
118}
119
120void wxRibbonBar::SetWindowStyleFlag(long style)
121{
122 m_flags = style;
123 if(m_art)
124 m_art->SetFlags(style);
125}
126
127long wxRibbonBar::GetWindowStyleFlag() const
128{
129 return m_flags;
130}
131
132bool wxRibbonBar::Realize()
133{
134 bool status = true;
135
136 wxClientDC dcTemp(this);
137 int sep = m_art->GetMetric(wxRIBBON_ART_TAB_SEPARATION_SIZE);
138 size_t numtabs = m_pages.GetCount();
139 size_t i;
140 for(i = 0; i < numtabs; ++i)
141 {
142 wxRibbonPageTabInfo& info = m_pages.Item(i);
143 RepositionPage(info.page);
144 if(!info.page->Realize())
145 {
146 status = false;
147 }
148 wxString label = wxEmptyString;
149 if(m_flags & wxRIBBON_BAR_SHOW_PAGE_LABELS)
150 label = info.page->GetLabel();
151 wxBitmap icon = wxNullBitmap;
152 if(m_flags & wxRIBBON_BAR_SHOW_PAGE_ICONS)
153 icon = info.page->GetIcon();
154 m_art->GetBarTabWidth(dcTemp, this, label, icon,
155 &info.ideal_width,
156 &info.small_begin_need_separator_width,
157 &info.small_must_have_separator_width,
158 &info.minimum_width);
159
160 if(i == 0)
161 {
162 m_tabs_total_width_ideal = info.ideal_width;
163 m_tabs_total_width_minimum = info.minimum_width;
164 }
165 else
166 {
167 m_tabs_total_width_ideal += sep + info.ideal_width;
168 m_tabs_total_width_minimum += sep + info.minimum_width;
169 }
170 }
171 m_tab_height = m_art->GetTabCtrlHeight(dcTemp, this, m_pages);
172
173 RecalculateMinSize();
174 RecalculateTabSizes();
175 Refresh();
176
177 return status;
178}
179
180void wxRibbonBar::OnMouseMove(wxMouseEvent& evt)
181{
182 int x = evt.GetX();
183 int y = evt.GetY();
184 int hovered_page = -1;
185 bool refresh_tabs = false;
186 if(y < m_tab_height)
187 {
188 // It is quite likely that the mouse moved a small amount and is still over the same tab
189 if(m_current_hovered_page != -1 && m_pages.Item((size_t)m_current_hovered_page).rect.Contains(x, y))
190 {
191 hovered_page = m_current_hovered_page;
192 // But be careful, if tabs can be scrolled, then parts of the tab rect may not be valid
193 if(m_tab_scroll_buttons_shown)
194 {
195 if(x >= m_tab_scroll_right_button_rect.GetX() || x < m_tab_scroll_left_button_rect.GetRight())
196 {
197 hovered_page = -1;
198 }
199 }
200 }
201 else
202 {
203 HitTestTabs(evt.GetPosition(), &hovered_page);
204 }
205 }
206 if(hovered_page != m_current_hovered_page)
207 {
208 if(m_current_hovered_page != -1)
209 {
210 m_pages.Item((int)m_current_hovered_page).hovered = false;
211 }
212 m_current_hovered_page = hovered_page;
213 if(m_current_hovered_page != -1)
214 {
215 m_pages.Item((int)m_current_hovered_page).hovered = true;
216 }
217 refresh_tabs = true;
218 }
219 if(m_tab_scroll_buttons_shown)
220 {
221#define SET_FLAG(variable, flag) \
222 { if(((variable) & (flag)) != (flag)) { variable |= (flag); refresh_tabs = true; }}
223#define UNSET_FLAG(variable, flag) \
224 { if((variable) & (flag)) { variable &= ~(flag); refresh_tabs = true; }}
225
226 if(m_tab_scroll_left_button_rect.Contains(x, y))
227 SET_FLAG(m_tab_scroll_left_button_state, wxRIBBON_SCROLL_BTN_HOVERED)
228 else
229 UNSET_FLAG(m_tab_scroll_left_button_state, wxRIBBON_SCROLL_BTN_HOVERED)
230
231 if(m_tab_scroll_right_button_rect.Contains(x, y))
232 SET_FLAG(m_tab_scroll_right_button_state, wxRIBBON_SCROLL_BTN_HOVERED)
233 else
234 UNSET_FLAG(m_tab_scroll_right_button_state, wxRIBBON_SCROLL_BTN_HOVERED)
235#undef SET_FLAG
236#undef UNSET_FLAG
237 }
238 if(refresh_tabs)
239 {
240 RefreshTabBar();
241 }
242}
243
244void wxRibbonBar::OnMouseLeave(wxMouseEvent& WXUNUSED(evt))
245{
246 // The ribbon bar is (usually) at the top of a window, and at least on MSW, the mouse
247 // can leave the window quickly and leave a tab in the hovered state.
248 bool refresh_tabs = false;
249 if(m_current_hovered_page != -1)
250 {
251 m_pages.Item((int)m_current_hovered_page).hovered = false;
252 m_current_hovered_page = -1;
253 refresh_tabs = true;
254 }
255 if(m_tab_scroll_left_button_state & wxRIBBON_SCROLL_BTN_HOVERED)
256 {
257 m_tab_scroll_left_button_state &= ~wxRIBBON_SCROLL_BTN_HOVERED;
258 refresh_tabs = true;
259 }
260 if(m_tab_scroll_right_button_state & wxRIBBON_SCROLL_BTN_HOVERED)
261 {
262 m_tab_scroll_right_button_state &= ~wxRIBBON_SCROLL_BTN_HOVERED;
263 refresh_tabs = true;
264 }
265 if(refresh_tabs)
266 {
267 RefreshTabBar();
268 }
269}
270
271wxRibbonPage* wxRibbonBar::GetPage(int n)
272{
273 if(n < 0 || (size_t)n >= m_pages.GetCount())
274 return 0;
275 return m_pages.Item(n).page;
276}
277
278bool wxRibbonBar::SetActivePage(size_t page)
279{
280 if(m_current_page == (int)page)
281 {
282 return true;
283 }
284
285 if(page >= m_pages.GetCount())
286 {
287 return false;
288 }
289
290 if(m_current_page != -1)
291 {
292 m_pages.Item((size_t)m_current_page).active = false;
293 m_pages.Item((size_t)m_current_page).page->Hide();
294 }
295 m_current_page = (int)page;
296 m_pages.Item(page).active = true;
297 {
298 wxRibbonPage* wnd = m_pages.Item(page).page;
299 RepositionPage(wnd);
300 wnd->Layout();
301 wnd->Show();
302 }
303 Refresh();
304
305 return true;
306}
307
308bool wxRibbonBar::SetActivePage(wxRibbonPage* page)
309{
310 size_t numpages = m_pages.GetCount();
311 size_t i;
312 for(i = 0; i < numpages; ++i)
313 {
314 if(m_pages.Item(i).page == page)
315 {
316 return SetActivePage(i);
317 }
318 }
319 return false;
320}
321
322int wxRibbonBar::GetActivePage() const
323{
324 return m_current_page;
325}
326
327void wxRibbonBar::SetTabCtrlMargins(int left, int right)
328{
329 m_tab_margin_left = left;
330 m_tab_margin_right = right;
331
332 RecalculateTabSizes();
333}
334
335static int OrderPageTabInfoBySmallWidthAsc(wxRibbonPageTabInfo **first, wxRibbonPageTabInfo **second)
336{
337 return (**first).small_must_have_separator_width - (**second).small_must_have_separator_width;
338}
339
340void wxRibbonBar::RecalculateTabSizes()
341{
342 size_t numtabs = m_pages.GetCount();
343
344 if(numtabs == 0)
345 return;
346
347 int width = GetSize().GetWidth() - m_tab_margin_left - m_tab_margin_right;
348 int tabsep = m_art->GetMetric(wxRIBBON_ART_TAB_SEPARATION_SIZE);
349 int x = m_tab_margin_left;
350 const int y = 0;
351
352 if(width >= m_tabs_total_width_ideal)
353 {
354 // Simple case: everything at ideal width
355 size_t i;
356 for(i = 0; i < numtabs; ++i)
357 {
358 wxRibbonPageTabInfo& info = m_pages.Item(i);
359 info.rect.x = x;
360 info.rect.y = y;
361 info.rect.width = info.ideal_width;
362 info.rect.height = m_tab_height;
363 x += info.rect.width + tabsep;
364 }
365 m_tab_scroll_buttons_shown = false;
366 m_tab_scroll_left_button_rect.SetWidth(0);
367 m_tab_scroll_right_button_rect.SetWidth(0);
368 }
369 else if(width < m_tabs_total_width_minimum)
370 {
371 // Simple case: everything minimum with scrollbar
372 size_t i;
373 for(i = 0; i < numtabs; ++i)
374 {
375 wxRibbonPageTabInfo& info = m_pages.Item(i);
376 info.rect.x = x;
377 info.rect.y = y;
378 info.rect.width = info.minimum_width;
379 info.rect.height = m_tab_height;
380 x += info.rect.width + tabsep;
381 }
382 if(!m_tab_scroll_buttons_shown)
383 {
384 m_tab_scroll_left_button_state = wxRIBBON_SCROLL_BTN_NORMAL;
385 m_tab_scroll_right_button_state = wxRIBBON_SCROLL_BTN_NORMAL;
386 m_tab_scroll_buttons_shown = true;
387 }
388 {
389 wxClientDC temp_dc(this);
390 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());
391 m_tab_scroll_left_button_rect.SetHeight(m_tab_height);
392 m_tab_scroll_left_button_rect.SetX(m_tab_margin_left);
393 m_tab_scroll_left_button_rect.SetY(0);
394 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());
395 m_tab_scroll_right_button_rect.SetHeight(m_tab_height);
396 m_tab_scroll_right_button_rect.SetX(GetClientSize().GetWidth() - m_tab_margin_right - m_tab_scroll_right_button_rect.GetWidth());
397 m_tab_scroll_right_button_rect.SetY(0);
398 }
399 if(m_tab_scroll_amount == 0)
400 {
401 m_tab_scroll_left_button_rect.SetWidth(0);
402 }
403 else if(m_tab_scroll_amount + width >= m_tabs_total_width_minimum)
404 {
405 m_tab_scroll_amount = m_tabs_total_width_minimum - width;
406 m_tab_scroll_right_button_rect.SetX(m_tab_scroll_right_button_rect.GetX() + m_tab_scroll_right_button_rect.GetWidth());
407 m_tab_scroll_right_button_rect.SetWidth(0);
408 }
409 for(i = 0; i < numtabs; ++i)
410 {
411 wxRibbonPageTabInfo& info = m_pages.Item(i);
412 info.rect.x -= m_tab_scroll_amount;
413 }
414 }
415 else
416 {
417 m_tab_scroll_buttons_shown = false;
418 m_tab_scroll_left_button_rect.SetWidth(0);
419 m_tab_scroll_right_button_rect.SetWidth(0);
420 // Complex case: everything sized such that: minimum <= width < ideal
421 /*
422 Strategy:
423 1) Uniformly reduce all tab widths from ideal to small_must_have_separator_width
424 2) Reduce the largest tab by 1 pixel, repeating until all tabs are same width (or at minimum)
425 3) Uniformly reduce all tabs down to their minimum width
426 */
427 int smallest_tab_width = INT_MAX;
428 int total_small_width = tabsep * (numtabs - 1);
429 size_t i;
430 for(i = 0; i < numtabs; ++i)
431 {
432 wxRibbonPageTabInfo& info = m_pages.Item(i);
433 if(info.small_must_have_separator_width < smallest_tab_width)
434 {
435 smallest_tab_width = info.small_must_have_separator_width;
436 }
437 total_small_width += info.small_must_have_separator_width;
438 }
439 if(width >= total_small_width)
440 {
441 // Do (1)
442 int total_delta = m_tabs_total_width_ideal - total_small_width;
443 total_small_width -= tabsep * (numtabs - 1);
444 width -= tabsep * (numtabs - 1);
445 for(i = 0; i < numtabs; ++i)
446 {
447 wxRibbonPageTabInfo& info = m_pages.Item(i);
448 int delta = info.ideal_width - info.small_must_have_separator_width;
449 info.rect.x = x;
450 info.rect.y = y;
451 info.rect.width = info.small_must_have_separator_width + delta * (width - total_small_width) / total_delta;
452 info.rect.height = m_tab_height;
453
454 x += info.rect.width + tabsep;
455 total_delta -= delta;
456 total_small_width -= info.small_must_have_separator_width;
457 width -= info.rect.width;
458 }
459 }
460 else
461 {
462 total_small_width = tabsep * (numtabs - 1);
463 for(i = 0; i < numtabs; ++i)
464 {
465 wxRibbonPageTabInfo& info = m_pages.Item(i);
466 if(info.minimum_width < smallest_tab_width)
467 {
468 total_small_width += smallest_tab_width;
469 }
470 else
471 {
472 total_small_width += info.minimum_width;
473 }
474 }
475 if(width >= total_small_width)
476 {
477 // Do (2)
478 wxRibbonPageTabInfoArray sorted_pages;
479 for(i = 0; i < numtabs; ++i)
480 {
481 // Sneaky obj array trickery to not copy the tab descriptors
482 sorted_pages.Add(&m_pages.Item(i));
483 }
484 sorted_pages.Sort(OrderPageTabInfoBySmallWidthAsc);
485 width -= tabsep * (numtabs - 1);
486 for(i = 0; i < numtabs; ++i)
487 {
488 wxRibbonPageTabInfo& info = sorted_pages.Item(i);
489 if(info.small_must_have_separator_width * (int)(numtabs - i) <= width)
490 {
491 info.rect.width = info.small_must_have_separator_width;;
492 }
493 else
494 {
495 info.rect.width = width / (numtabs - i);
496 }
497 width -= info.rect.width;
498 }
499 for(i = 0; i < numtabs; ++i)
500 {
501 wxRibbonPageTabInfo& info = m_pages.Item(i);
502 info.rect.x = x;
503 info.rect.y = y;
504 info.rect.height = m_tab_height;
505 x += info.rect.width + tabsep;
506 sorted_pages.Detach(numtabs - (i + 1));
507 }
508 }
509 else
510 {
511 // Do (3)
512 total_small_width = (smallest_tab_width + tabsep) * numtabs - tabsep;
513 int total_delta = total_small_width - m_tabs_total_width_minimum;
514 total_small_width = m_tabs_total_width_minimum - tabsep * (numtabs - 1);
515 width -= tabsep * (numtabs - 1);
516 for(i = 0; i < numtabs; ++i)
517 {
518 wxRibbonPageTabInfo& info = m_pages.Item(i);
519 int delta = smallest_tab_width - info.minimum_width;
520 info.rect.x = x;
521 info.rect.y = y;
522 info.rect.width = info.minimum_width + delta * (width - total_small_width) / total_delta;
523 info.rect.height = m_tab_height;
524
525 x += info.rect.width + tabsep;
526 total_delta -= delta;
527 total_small_width -= info.minimum_width;
528 width -= info.rect.width;
529 }
530 }
531 }
532 }
533}
534
535wxRibbonBar::wxRibbonBar()
536{
537 m_flags = 0;
538 m_tabs_total_width_ideal = 0;
539 m_tabs_total_width_minimum = 0;
540 m_tab_margin_left = 0;
541 m_tab_margin_right = 0;
542 m_tab_height = 0;
543 m_tab_scroll_amount = 0;
544 m_current_page = -1;
545 m_current_hovered_page = -1;
546 m_tab_scroll_left_button_state = wxRIBBON_SCROLL_BTN_NORMAL;
547 m_tab_scroll_right_button_state = wxRIBBON_SCROLL_BTN_NORMAL;
548 m_tab_scroll_buttons_shown = false;
549 m_arePanelsShown = true;
550}
551
552wxRibbonBar::wxRibbonBar(wxWindow* parent,
553 wxWindowID id,
554 const wxPoint& pos,
555 const wxSize& size,
556 long style)
557 : wxRibbonControl(parent, id, pos, size, wxBORDER_NONE)
558{
559 CommonInit(style);
560}
561
562wxRibbonBar::~wxRibbonBar()
563{
564 SetArtProvider(NULL);
565}
566
567bool wxRibbonBar::Create(wxWindow* parent,
568 wxWindowID id,
569 const wxPoint& pos,
570 const wxSize& size,
571 long style)
572{
573 if(!wxRibbonControl::Create(parent, id, pos, size, wxBORDER_NONE))
574 return false;
575
576 CommonInit(style);
577
578 return true;
579}
580
581void wxRibbonBar::CommonInit(long style)
582{
583 SetName(wxT("wxRibbonBar"));
584
585 m_flags = style;
586 m_tabs_total_width_ideal = 0;
587 m_tabs_total_width_minimum = 0;
588 m_tab_margin_left = 50;
589 m_tab_margin_right = 20;
590 m_tab_height = 20; // initial guess
591 m_tab_scroll_amount = 0;
592 m_current_page = -1;
593 m_current_hovered_page = -1;
594 m_tab_scroll_left_button_state = wxRIBBON_SCROLL_BTN_NORMAL;
595 m_tab_scroll_right_button_state = wxRIBBON_SCROLL_BTN_NORMAL;
596 m_tab_scroll_buttons_shown = false;
597 m_arePanelsShown = true;
598
599 if(m_art == NULL)
600 {
601 SetArtProvider(new wxRibbonDefaultArtProvider);
602 }
603 SetBackgroundStyle(wxBG_STYLE_CUSTOM);
604}
605
606void wxRibbonBar::SetArtProvider(wxRibbonArtProvider* art)
607{
608 wxRibbonArtProvider *old = m_art;
609 m_art = art;
610
611 if(art)
612 {
613 art->SetFlags(m_flags);
614 }
615 size_t numpages = m_pages.GetCount();
616 size_t i;
617 for(i = 0; i < numpages; ++i)
618 {
619 wxRibbonPage *page = m_pages.Item(i).page;
620 if(page->GetArtProvider() != art)
621 {
622 page->SetArtProvider(art);
623 }
624 }
625
626 delete old;
627}
628
629void wxRibbonBar::OnPaint(wxPaintEvent& WXUNUSED(evt))
630{
631 wxAutoBufferedPaintDC dc(this);
632
633 if(GetUpdateRegion().Contains(0, 0, GetClientSize().GetWidth(), m_tab_height) == wxOutRegion)
634 {
635 // Nothing to do in the tab area, and the page area is handled by the active page
636 return;
637 }
638
639 DoEraseBackground(dc);
640
641 size_t numtabs = m_pages.GetCount();
642 double sep_visibility = 0.0;
643 bool draw_sep = false;
644 wxRect tabs_rect(m_tab_margin_left, 0, GetClientSize().GetWidth() - m_tab_margin_left - m_tab_margin_right, m_tab_height);
645 if(m_tab_scroll_buttons_shown)
646 {
647 tabs_rect.x += m_tab_scroll_left_button_rect.GetWidth();
648 tabs_rect.width -= m_tab_scroll_left_button_rect.GetWidth() + m_tab_scroll_right_button_rect.GetWidth();
649 }
650 size_t i;
651 for(i = 0; i < numtabs; ++i)
652 {
653 wxRibbonPageTabInfo& info = m_pages.Item(i);
654
655 dc.DestroyClippingRegion();
656 if(m_tab_scroll_buttons_shown)
657 {
658 if(!tabs_rect.Intersects(info.rect))
659 continue;
660 dc.SetClippingRegion(tabs_rect);
661 }
662 dc.SetClippingRegion(info.rect);
663 m_art->DrawTab(dc, this, info);
664
665 if(info.rect.width < info.small_begin_need_separator_width)
666 {
667 draw_sep = true;
668 if(info.rect.width < info.small_must_have_separator_width)
669 {
670 sep_visibility += 1.0;
671 }
672 else
673 {
674 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);
675 }
676 }
677 }
678 if(draw_sep)
679 {
680 wxRect rect = m_pages.Item(0).rect;
681 rect.width = m_art->GetMetric(wxRIBBON_ART_TAB_SEPARATION_SIZE);
682 sep_visibility /= (double)numtabs;
683 for(i = 0; i < numtabs - 1; ++i)
684 {
685 wxRibbonPageTabInfo& info = m_pages.Item(i);
686 rect.x = info.rect.x + info.rect.width;
687
688 if(m_tab_scroll_buttons_shown && !tabs_rect.Intersects(rect))
689 {
690 continue;
691 }
692
693 dc.DestroyClippingRegion();
694 dc.SetClippingRegion(rect);
695 m_art->DrawTabSeparator(dc, this, rect, sep_visibility);
696 }
697 }
698 if(m_tab_scroll_buttons_shown)
699 {
700 dc.DestroyClippingRegion();
701 if(m_tab_scroll_left_button_rect.GetWidth() != 0)
702 {
703 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);
704 }
705 if(m_tab_scroll_right_button_rect.GetWidth() != 0)
706 {
707 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);
708 }
709 }
710}
711
712void wxRibbonBar::OnEraseBackground(wxEraseEvent& WXUNUSED(evt))
713{
714 // Background painting done in main paint handler to reduce screen flicker
715}
716
717void wxRibbonBar::DoEraseBackground(wxDC& dc)
718{
719 wxRect tabs(GetSize());
720 tabs.height = m_tab_height;
721 m_art->DrawTabCtrlBackground(dc, this, tabs);
722}
723
724void wxRibbonBar::OnSize(wxSizeEvent& evt)
725{
726 RecalculateTabSizes();
727 if(m_current_page != -1)
728 {
729 RepositionPage(m_pages.Item(m_current_page).page);
730 }
731 RefreshTabBar();
732
733 evt.Skip();
734}
735
736void wxRibbonBar::RepositionPage(wxRibbonPage *page)
737{
738 int w, h;
739 GetSize(&w, &h);
740 page->SetSizeWithScrollButtonAdjustment(0, m_tab_height, w, h - m_tab_height);
741}
742
743wxRibbonPageTabInfo* wxRibbonBar::HitTestTabs(wxPoint position, int* index)
744{
745 wxRect tabs_rect(m_tab_margin_left, 0, GetClientSize().GetWidth() - m_tab_margin_left - m_tab_margin_right, m_tab_height);
746 if(m_tab_scroll_buttons_shown)
747 {
748 tabs_rect.SetX(tabs_rect.GetX() + m_tab_scroll_left_button_rect.GetWidth());
749 tabs_rect.SetWidth(tabs_rect.GetWidth() - m_tab_scroll_left_button_rect.GetWidth() - m_tab_scroll_right_button_rect.GetWidth());
750 }
751 if(tabs_rect.Contains(position))
752 {
753 size_t numtabs = m_pages.GetCount();
754 size_t i;
755 for(i = 0; i < numtabs; ++i)
756 {
757 wxRibbonPageTabInfo& info = m_pages.Item(i);
758 if(info.rect.Contains(position))
759 {
760 if(index != NULL)
761 {
762 *index = (int)i;
763 }
764 return &info;
765 }
766 }
767 }
768 if(index != NULL)
769 {
770 *index = -1;
771 }
772 return NULL;
773}
774
775void wxRibbonBar::OnMouseLeftDown(wxMouseEvent& evt)
776{
777 wxRibbonPageTabInfo *tab = HitTestTabs(evt.GetPosition());
778 if(tab && tab != &m_pages.Item(m_current_page))
779 {
780 wxRibbonBarEvent query(wxEVT_COMMAND_RIBBONBAR_PAGE_CHANGING, GetId(), tab->page);
781 query.SetEventObject(this);
782 ProcessWindowEvent(query);
783 if(query.IsAllowed())
784 {
785 SetActivePage(query.GetPage());
786
787 wxRibbonBarEvent notification(wxEVT_COMMAND_RIBBONBAR_PAGE_CHANGED, GetId(), m_pages.Item(m_current_page).page);
788 notification.SetEventObject(this);
789 ProcessWindowEvent(notification);
790 }
791 }
792 else if(tab == NULL)
793 {
794 if(m_tab_scroll_left_button_rect.Contains(evt.GetPosition()))
795 {
796 m_tab_scroll_left_button_state |= wxRIBBON_SCROLL_BTN_ACTIVE | wxRIBBON_SCROLL_BTN_HOVERED;
797 RefreshTabBar();
798 }
799 else if(m_tab_scroll_right_button_rect.Contains(evt.GetPosition()))
800 {
801 m_tab_scroll_right_button_state |= wxRIBBON_SCROLL_BTN_ACTIVE | wxRIBBON_SCROLL_BTN_HOVERED;
802 RefreshTabBar();
803 }
804 }
805}
806
807void wxRibbonBar::OnMouseLeftUp(wxMouseEvent& WXUNUSED(evt))
808{
809 if(!m_tab_scroll_buttons_shown)
810 {
811 return;
812 }
813
814 int amount = 0;
815 if(m_tab_scroll_left_button_state & wxRIBBON_SCROLL_BTN_ACTIVE)
816 {
817 amount = -1;
818 }
819 else if(m_tab_scroll_right_button_state & wxRIBBON_SCROLL_BTN_ACTIVE)
820 {
821 amount = 1;
822 }
823 if(amount != 0)
824 {
825 m_tab_scroll_left_button_state &= ~wxRIBBON_SCROLL_BTN_ACTIVE;
826 m_tab_scroll_right_button_state &= ~wxRIBBON_SCROLL_BTN_ACTIVE;
827 ScrollTabBar(amount * 8);
828 }
829}
830
831void wxRibbonBar::ScrollTabBar(int amount)
832{
833 bool show_left = true;
834 bool show_right = true;
835 if(m_tab_scroll_amount + amount <= 0)
836 {
837 amount = -m_tab_scroll_amount;
838 show_left = false;
839 }
840 else if(m_tab_scroll_amount + amount + (GetClientSize().GetWidth() - m_tab_margin_left - m_tab_margin_right) >= m_tabs_total_width_minimum)
841 {
842 amount = m_tabs_total_width_minimum - m_tab_scroll_amount - (GetClientSize().GetWidth() - m_tab_margin_left - m_tab_margin_right);
843 show_right = false;
844 }
845 if(amount == 0)
846 {
847 return;
848 }
849 m_tab_scroll_amount += amount;
850 size_t numtabs = m_pages.GetCount();
851 size_t i;
852 for(i = 0; i < numtabs; ++i)
853 {
854 wxRibbonPageTabInfo& info = m_pages.Item(i);
855 info.rect.SetX(info.rect.GetX() - amount);
856 }
857 if(show_right != (m_tab_scroll_right_button_rect.GetWidth() != 0) ||
858 show_left != (m_tab_scroll_left_button_rect.GetWidth() != 0))
859 {
860 wxClientDC temp_dc(this);
861 if(show_left)
862 {
863 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());
864 }
865 else
866 {
867 m_tab_scroll_left_button_rect.SetWidth(0);
868 }
869
870 if(show_right)
871 {
872 if(m_tab_scroll_right_button_rect.GetWidth() == 0)
873 {
874 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());
875 m_tab_scroll_right_button_rect.SetX(m_tab_scroll_right_button_rect.GetX() - m_tab_scroll_right_button_rect.GetWidth());
876 }
877 }
878 else
879 {
880 if(m_tab_scroll_right_button_rect.GetWidth() != 0)
881 {
882 m_tab_scroll_right_button_rect.SetX(m_tab_scroll_right_button_rect.GetX() + m_tab_scroll_right_button_rect.GetWidth());
883 m_tab_scroll_right_button_rect.SetWidth(0);
884 }
885 }
886 }
887
888 RefreshTabBar();
889}
890
891void wxRibbonBar::RefreshTabBar()
892{
893 wxRect tab_rect(0, 0, GetClientSize().GetWidth(), m_tab_height);
894 Refresh(false, &tab_rect);
895}
896
897void wxRibbonBar::OnMouseMiddleDown(wxMouseEvent& evt)
898{
899 DoMouseButtonCommon(evt, wxEVT_COMMAND_RIBBONBAR_TAB_MIDDLE_DOWN);
900}
901
902void wxRibbonBar::OnMouseMiddleUp(wxMouseEvent& evt)
903{
904 DoMouseButtonCommon(evt, wxEVT_COMMAND_RIBBONBAR_TAB_MIDDLE_UP);
905}
906
907void wxRibbonBar::OnMouseRightDown(wxMouseEvent& evt)
908{
909 DoMouseButtonCommon(evt, wxEVT_COMMAND_RIBBONBAR_TAB_RIGHT_DOWN);
910}
911
912void wxRibbonBar::OnMouseRightUp(wxMouseEvent& evt)
913{
914 DoMouseButtonCommon(evt, wxEVT_COMMAND_RIBBONBAR_TAB_RIGHT_UP);
915}
916
917void wxRibbonBar::OnMouseDoubleClick(wxMouseEvent& evt)
918{
919 DoMouseButtonCommon(evt, wxEVT_COMMAND_RIBBONBAR_TAB_LEFT_DCLICK);
920}
921
922void wxRibbonBar::DoMouseButtonCommon(wxMouseEvent& evt, wxEventType tab_event_type)
923{
924 wxRibbonPageTabInfo *tab = HitTestTabs(evt.GetPosition());
925 if(tab)
926 {
927 wxRibbonBarEvent notification(tab_event_type, GetId(), tab->page);
928 notification.SetEventObject(this);
929 ProcessWindowEvent(notification);
930 }
931}
932
933void wxRibbonBar::RecalculateMinSize()
934{
935 wxSize min_size(wxDefaultCoord, wxDefaultCoord);
936 size_t numtabs = m_pages.GetCount();
937 if(numtabs != 0)
938 {
939 min_size = m_pages.Item(0).page->GetMinSize();
940
941 size_t i;
942 for(i = 1; i < numtabs; ++i)
943 {
944 wxRibbonPageTabInfo& info = m_pages.Item(i);
945 wxSize page_min = info.page->GetMinSize();
946
947 min_size.x = wxMax(min_size.x, page_min.x);
948 min_size.y = wxMax(min_size.y, page_min.y);
949 }
950 }
951 if(min_size.y != wxDefaultCoord)
952 {
953 // TODO: Decide on best course of action when min height is unspecified
954 // - should we specify it to the tab minimum, or leave it unspecified?
955 min_size.IncBy(0, m_tab_height);
956 }
957
958 m_minWidth = min_size.GetWidth();
959 m_minHeight = m_arePanelsShown ? min_size.GetHeight() : m_tab_height;
960}
961
962wxSize wxRibbonBar::DoGetBestSize() const
963{
964 wxSize best(0, 0);
965 if(m_current_page != -1)
966 {
967 best = m_pages.Item(m_current_page).page->GetBestSize();
968 }
969 if(best.GetHeight() == wxDefaultCoord)
970 {
971 best.SetHeight(m_tab_height);
972 }
973 else
974 {
975 best.IncBy(0, m_tab_height);
976 }
977 if(!m_arePanelsShown)
978 {
979 best.SetHeight(m_tab_height);
980 }
981 return best;
982}
983
984#endif // wxUSE_RIBBON
wxWidgets (Impactor)