]> git.saurik.com Git - wxWidgets.git/blame - src/ribbon/buttonbar.cpp
projects / wxWidgets.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Generate wxEVT_COMMAND_TEXT_ENTER events for generic wxSpinCtrl.
[wxWidgets.git] / src / ribbon / buttonbar.cpp
CommitLineData
3c3ead1d
PC		 1///////////////////////////////////////////////////////////////////////////////
2// Name: src/ribbon/buttonbar.cpp
3// Purpose: Ribbon control similar to a tool bar
4// Author: Peter Cawley
5// Modified by:
6// Created: 2009-07-01
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
3c3ead1d
PC		 18#if wxUSE_RIBBON
19
4cf018e1 20#include "wx/ribbon/buttonbar.h"
3c3ead1d
PC		 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
31wxDEFINE_EVENT(wxEVT_COMMAND_RIBBONBUTTON_CLICKED, wxRibbonButtonBarEvent);
32wxDEFINE_EVENT(wxEVT_COMMAND_RIBBONBUTTON_DROPDOWN_CLICKED, wxRibbonButtonBarEvent);
33
34IMPLEMENT_DYNAMIC_CLASS(wxRibbonButtonBarEvent, wxCommandEvent)
35IMPLEMENT_CLASS(wxRibbonButtonBar, wxRibbonControl)
36
37BEGIN_EVENT_TABLE(wxRibbonButtonBar, wxRibbonControl)
38 EVT_ERASE_BACKGROUND(wxRibbonButtonBar::OnEraseBackground)
39 EVT_ENTER_WINDOW(wxRibbonButtonBar::OnMouseEnter)
40 EVT_LEAVE_WINDOW(wxRibbonButtonBar::OnMouseLeave)
41 EVT_MOTION(wxRibbonButtonBar::OnMouseMove)
42 EVT_PAINT(wxRibbonButtonBar::OnPaint)
43 EVT_SIZE(wxRibbonButtonBar::OnSize)
44 EVT_LEFT_DOWN(wxRibbonButtonBar::OnMouseDown)
45 EVT_LEFT_UP(wxRibbonButtonBar::OnMouseUp)
46END_EVENT_TABLE()
47
48class wxRibbonButtonBarButtonSizeInfo
49{
50public:
51 bool is_supported;
52 wxSize size;
53 wxRect normal_region;
54 wxRect dropdown_region;
55};
56
57class wxRibbonButtonBarButtonInstance
58{
59public:
60 wxPoint position;
61 wxRibbonButtonBarButtonBase* base;
62 wxRibbonButtonBarButtonState size;
63};
64
65class wxRibbonButtonBarButtonBase
66{
67public:
68 wxRibbonButtonBarButtonInstance NewInstance()
69 {
70 wxRibbonButtonBarButtonInstance i;
71 i.base = this;
72 return i;
73 }
74
75 wxRibbonButtonBarButtonState GetLargestSize()
76 {
77 if(sizes[wxRIBBON_BUTTONBAR_BUTTON_LARGE].is_supported)
78 return wxRIBBON_BUTTONBAR_BUTTON_LARGE;
79 if(sizes[wxRIBBON_BUTTONBAR_BUTTON_MEDIUM].is_supported)
80 return wxRIBBON_BUTTONBAR_BUTTON_MEDIUM;
81 wxASSERT(sizes[wxRIBBON_BUTTONBAR_BUTTON_SMALL].is_supported);
82 return wxRIBBON_BUTTONBAR_BUTTON_SMALL;
83 }
84
85 bool GetSmallerSize(
86 wxRibbonButtonBarButtonState* size, int n = 1)
87 {
88 for(; n > 0; --n)
89 {
90 switch(*size)
91 {
92 case wxRIBBON_BUTTONBAR_BUTTON_LARGE:
93 if(sizes[wxRIBBON_BUTTONBAR_BUTTON_MEDIUM].is_supported)
94 {
95 *size = wxRIBBON_BUTTONBAR_BUTTON_MEDIUM;
96 break;
97 }
98 case wxRIBBON_BUTTONBAR_BUTTON_MEDIUM:
99 if(sizes[wxRIBBON_BUTTONBAR_BUTTON_SMALL].is_supported)
100 {
101 *size = wxRIBBON_BUTTONBAR_BUTTON_SMALL;
102 break;
103 }
104 case wxRIBBON_BUTTONBAR_BUTTON_SMALL:
105 default:
106 return false;
107 }
108 }
109 return true;
110 }
111
112 wxString label;
113 wxString help_string;
114 wxBitmap bitmap_large;
115 wxBitmap bitmap_large_disabled;
116 wxBitmap bitmap_small;
117 wxBitmap bitmap_small_disabled;
118 wxRibbonButtonBarButtonSizeInfo sizes[3];
119 wxObject* client_data;
120 int id;
121 wxRibbonButtonKind kind;
122 long state;
123};
124
125WX_DECLARE_OBJARRAY(wxRibbonButtonBarButtonInstance, wxArrayRibbonButtonBarButtonInstance);
14371273 126#include "wx/arrimpl.cpp"
65391c8f 127WX_DEFINE_OBJARRAY(wxArrayRibbonButtonBarButtonInstance)
3c3ead1d
PC		 128
129class wxRibbonButtonBarLayout
130{
131public:
132 wxSize overall_size;
133 wxArrayRibbonButtonBarButtonInstance buttons;
134
135 void CalculateOverallSize()
136 {
137 overall_size = wxSize(0, 0);
138 size_t btn_count = buttons.Count();
139 size_t btn_i;
140 for(btn_i = 0; btn_i < btn_count; ++btn_i)
141 {
142 wxRibbonButtonBarButtonInstance& instance = buttons.Item(btn_i);
143 wxSize size = instance.base->sizes[instance.size].size;
144 int right = instance.position.x + size.GetWidth();
145 int bottom = instance.position.y + size.GetHeight();
146 if(right > overall_size.GetWidth())
147 {
148 overall_size.SetWidth(right);
149 }
150 if(bottom > overall_size.GetHeight())
151 {
152 overall_size.SetHeight(bottom);
153 }
154 }
155 }
156
157 wxRibbonButtonBarButtonInstance* FindSimilarInstance(
158 wxRibbonButtonBarButtonInstance* inst)
159 {
160 if(inst == NULL)
161 {
162 return NULL;
163 }
164 size_t btn_count = buttons.Count();
165 size_t btn_i;
166 for(btn_i = 0; btn_i < btn_count; ++btn_i)
167 {
168 wxRibbonButtonBarButtonInstance& instance = buttons.Item(btn_i);
169 if(instance.base == inst->base)
170 {
171 return &instance;
172 }
173 }
174 return NULL;
175 }
176};
177
178wxRibbonButtonBar::wxRibbonButtonBar()
179{
180 m_layouts_valid = false;
fd6e1597 181 CommonInit (0);
3c3ead1d
PC		 182}
183
184wxRibbonButtonBar::wxRibbonButtonBar(wxWindow* parent,
185 wxWindowID id,
186 const wxPoint& pos,
187 const wxSize& size,
188 long style)
189 : wxRibbonControl(parent, id, pos, size, wxBORDER_NONE)
190{
191 m_layouts_valid = false;
192
193 CommonInit(style);
194}
195
196wxRibbonButtonBar::~wxRibbonButtonBar()
197{
198 size_t count = m_buttons.GetCount();
199 size_t i;
200 for(i = 0; i < count; ++i)
201 {
202 wxRibbonButtonBarButtonBase* button = m_buttons.Item(i);
203 delete button;
204 }
205 m_buttons.Clear();
206
207 count = m_layouts.GetCount();
208 for(i = 0; i < count; ++i)
209 {
210 wxRibbonButtonBarLayout* layout = m_layouts.Item(i);
211 delete layout;
212 }
213 m_layouts.Clear();
214}
215
216bool wxRibbonButtonBar::Create(wxWindow* parent,
217 wxWindowID id,
218 const wxPoint& pos,
219 const wxSize& size,
220 long style)
221{
222 if(!wxRibbonControl::Create(parent, id, pos, size, wxBORDER_NONE))
223 {
224 return false;
225 }
226
227 CommonInit(style);
228 return true;
229}
230
231wxRibbonButtonBarButtonBase* wxRibbonButtonBar::AddButton(
232 int button_id,
233 const wxString& label,
234 const wxBitmap& bitmap,
235 const wxString& help_string,
236 wxRibbonButtonKind kind)
237{
238 return AddButton(button_id, label, bitmap, wxNullBitmap, wxNullBitmap,
239 wxNullBitmap, kind, help_string);
240}
241
242wxRibbonButtonBarButtonBase* wxRibbonButtonBar::AddDropdownButton(
243 int button_id,
244 const wxString& label,
245 const wxBitmap& bitmap,
246 const wxString& help_string)
247{
248 return AddButton(button_id, label, bitmap, help_string,
249 wxRIBBON_BUTTON_DROPDOWN);
250}
251
955bad41
PC		 252wxRibbonButtonBarButtonBase* wxRibbonButtonBar::AddToggleButton(
253 int button_id,
254 const wxString& label,
255 const wxBitmap& bitmap,
256 const wxString& help_string)
257{
258 return AddButton(button_id, label, bitmap, help_string,
259 wxRIBBON_BUTTON_TOGGLE);
260}
261
3c3ead1d
PC		 262wxRibbonButtonBarButtonBase* wxRibbonButtonBar::AddHybridButton(
263 int button_id,
264 const wxString& label,
265 const wxBitmap& bitmap,
266 const wxString& help_string)
267{
268 return AddButton(button_id, label, bitmap, help_string,
269 wxRIBBON_BUTTON_HYBRID);
270}
ce00f59b 271
3c3ead1d
PC		 272wxRibbonButtonBarButtonBase* wxRibbonButtonBar::AddButton(
273 int button_id,
274 const wxString& label,
275 const wxBitmap& bitmap,
276 const wxBitmap& bitmap_small,
277 const wxBitmap& bitmap_disabled,
278 const wxBitmap& bitmap_small_disabled,
279 wxRibbonButtonKind kind,
280 const wxString& help_string,
281 wxObject* client_data)
ff4cb916
VZ		 282{
283 return InsertButton(GetButtonCount(), button_id, label, bitmap,
284 bitmap_small, bitmap_disabled,bitmap_small_disabled, kind, help_string,
285 client_data);
286}
287
288wxRibbonButtonBarButtonBase* wxRibbonButtonBar::InsertButton(
289 size_t pos,
290 int button_id,
291 const wxString& label,
292 const wxBitmap& bitmap,
293 const wxBitmap& bitmap_small,
294 const wxBitmap& bitmap_disabled,
295 const wxBitmap& bitmap_small_disabled,
296 wxRibbonButtonKind kind,
297 const wxString& help_string,
298 wxObject* client_data)
3c3ead1d
PC		 299{
300 wxASSERT(bitmap.IsOk() || bitmap_small.IsOk());
301 if(m_buttons.IsEmpty())
302 {
303 if(bitmap.IsOk())
304 {
305 m_bitmap_size_large = bitmap.GetSize();
306 if(!bitmap_small.IsOk())
307 {
308 m_bitmap_size_small = m_bitmap_size_large;
309 m_bitmap_size_small *= 0.5;
310 }
311 }
312 if(bitmap_small.IsOk())
313 {
314 m_bitmap_size_small = bitmap_small.GetSize();
315 if(!bitmap.IsOk())
316 {
317 m_bitmap_size_large = m_bitmap_size_small;
318 m_bitmap_size_large *= 2.0;
319 }
320 }
321 }
322
323 wxRibbonButtonBarButtonBase* base = new wxRibbonButtonBarButtonBase;
324 base->id = button_id;
325 base->label = label;
326 base->bitmap_large = bitmap;
327 if(!base->bitmap_large.IsOk())
328 {
329 base->bitmap_large = MakeResizedBitmap(base->bitmap_small,
330 m_bitmap_size_large);
331 }
332 else if(base->bitmap_large.GetSize() != m_bitmap_size_large)
333 {
334 base->bitmap_large = MakeResizedBitmap(base->bitmap_large,
335 m_bitmap_size_large);
336 }
337 base->bitmap_small = bitmap_small;
338 if(!base->bitmap_small.IsOk())
339 {
340 base->bitmap_small = MakeResizedBitmap(base->bitmap_large,
341 m_bitmap_size_small);
342 }
343 else if(base->bitmap_small.GetSize() != m_bitmap_size_small)
344 {
345 base->bitmap_small = MakeResizedBitmap(base->bitmap_small,
346 m_bitmap_size_small);
347 }
348 base->bitmap_large_disabled = bitmap_disabled;
349 if(!base->bitmap_large_disabled.IsOk())
350 {
351 base->bitmap_large_disabled = MakeDisabledBitmap(base->bitmap_large);
352 }
353 base->bitmap_small_disabled = bitmap_small_disabled;
354 if(!base->bitmap_small_disabled.IsOk())
355 {
356 base->bitmap_small_disabled = MakeDisabledBitmap(base->bitmap_small);
357 }
358 base->kind = kind;
359 base->help_string = help_string;
360 base->client_data = client_data;
361 base->state = 0;
362
089ca539 363 wxClientDC temp_dc(this);
3c3ead1d
PC		 364 FetchButtonSizeInfo(base, wxRIBBON_BUTTONBAR_BUTTON_SMALL, temp_dc);
365 FetchButtonSizeInfo(base, wxRIBBON_BUTTONBAR_BUTTON_MEDIUM, temp_dc);
366 FetchButtonSizeInfo(base, wxRIBBON_BUTTONBAR_BUTTON_LARGE, temp_dc);
367
ff4cb916 368 m_buttons.Insert(base, pos);
3c3ead1d
PC		 369 m_layouts_valid = false;
370 return base;
371}
372
ff4cb916
VZ		 373wxRibbonButtonBarButtonBase* wxRibbonButtonBar::InsertButton(
374 size_t pos,
375 int button_id,
376 const wxString& label,
377 const wxBitmap& bitmap,
378 const wxString& help_string,
379 wxRibbonButtonKind kind)
380{
381 return InsertButton(pos, button_id, label, bitmap, wxNullBitmap,
382 wxNullBitmap, wxNullBitmap, kind, help_string);
383}
384
385wxRibbonButtonBarButtonBase* wxRibbonButtonBar::InsertDropdownButton(
386 size_t pos,
387 int button_id,
388 const wxString& label,
389 const wxBitmap& bitmap,
390 const wxString& help_string)
391{
392 return InsertButton(pos, button_id, label, bitmap, help_string,
393 wxRIBBON_BUTTON_DROPDOWN);
394}
395
396wxRibbonButtonBarButtonBase* wxRibbonButtonBar::InsertToggleButton(
397 size_t pos,
398 int button_id,
399 const wxString& label,
400 const wxBitmap& bitmap,
401 const wxString& help_string)
402{
403 return InsertButton(pos, button_id, label, bitmap, help_string,
404 wxRIBBON_BUTTON_TOGGLE);
405}
406
407wxRibbonButtonBarButtonBase* wxRibbonButtonBar::InsertHybridButton(
408 size_t pos,
409 int button_id,
410 const wxString& label,
411 const wxBitmap& bitmap,
412 const wxString& help_string)
413{
414 return InsertButton(pos, button_id, label, bitmap, help_string,
415 wxRIBBON_BUTTON_HYBRID);
416}
417
3c3ead1d
PC		 418void wxRibbonButtonBar::FetchButtonSizeInfo(wxRibbonButtonBarButtonBase* button,
419 wxRibbonButtonBarButtonState size, wxDC& dc)
420{
421 wxRibbonButtonBarButtonSizeInfo& info = button->sizes[size];
422 if(m_art)
423 {
424 info.is_supported = m_art->GetButtonBarButtonSize(dc, this,
425 button->kind, size, button->label, m_bitmap_size_large,
426 m_bitmap_size_small, &info.size, &info.normal_region,
427 &info.dropdown_region);
428 }
429 else
430 info.is_supported = false;
431}
432
433wxBitmap wxRibbonButtonBar::MakeResizedBitmap(const wxBitmap& original, wxSize size)
434{
435 wxImage img(original.ConvertToImage());
436 img.Rescale(size.GetWidth(), size.GetHeight(), wxIMAGE_QUALITY_HIGH);
437 return wxBitmap(img);
438}
439
440wxBitmap wxRibbonButtonBar::MakeDisabledBitmap(const wxBitmap& original)
441{
442 wxImage img(original.ConvertToImage());
443 return wxBitmap(img.ConvertToGreyscale());
444}
445
ff4cb916
VZ		 446size_t wxRibbonButtonBar::GetButtonCount() const
447{
448 return m_buttons.GetCount();
449}
450
3c3ead1d
PC		 451bool wxRibbonButtonBar::Realize()
452{
453 if(!m_layouts_valid)
454 {
455 MakeLayouts();
456 m_layouts_valid = true;
457 }
458 return true;
459}
460
461void wxRibbonButtonBar::ClearButtons()
462{
463 m_layouts_valid = false;
464 size_t count = m_buttons.GetCount();
465 size_t i;
466 for(i = 0; i < count; ++i)
467 {
468 wxRibbonButtonBarButtonBase* button = m_buttons.Item(i);
469 delete button;
470 }
471 m_buttons.Clear();
472 Realize();
473}
474
475bool wxRibbonButtonBar::DeleteButton(int button_id)
476{
477 size_t count = m_buttons.GetCount();
478 size_t i;
479 for(i = 0; i < count; ++i)
480 {
481 wxRibbonButtonBarButtonBase* button = m_buttons.Item(i);
482 if(button->id == button_id)
483 {
484 m_layouts_valid = false;
485 m_buttons.RemoveAt(i);
486 Realize();
487 Refresh();
488 return true;
489 }
490 }
491 return false;
492}
493
494void wxRibbonButtonBar::EnableButton(int button_id, bool enable)
495{
496 size_t count = m_buttons.GetCount();
497 size_t i;
498 for(i = 0; i < count; ++i)
499 {
500 wxRibbonButtonBarButtonBase* button = m_buttons.Item(i);
501 if(button->id == button_id)
502 {
503 if(enable)
504 {
505 if(button->state & wxRIBBON_BUTTONBAR_BUTTON_DISABLED)
506 {
507 button->state &= ~wxRIBBON_BUTTONBAR_BUTTON_DISABLED;
508 Refresh();
509 }
510 }
511 else
512 {
513 if((button->state & wxRIBBON_BUTTONBAR_BUTTON_DISABLED) == 0)
514 {
515 button->state |= wxRIBBON_BUTTONBAR_BUTTON_DISABLED;
516 Refresh();
517 }
518 }
519 return;
520 }
521 }
522}
523
955bad41
PC		 524void wxRibbonButtonBar::ToggleButton(int button_id, bool checked)
525{
526 size_t count = m_buttons.GetCount();
527 size_t i;
528 for(i = 0; i < count; ++i)
529 {
530 wxRibbonButtonBarButtonBase* button = m_buttons.Item(i);
531 if(button->id == button_id)
532 {
533 if(checked)
534 {
535 if((button->state & wxRIBBON_BUTTONBAR_BUTTON_TOGGLED) == 0)
536 {
537 button->state |= wxRIBBON_BUTTONBAR_BUTTON_TOGGLED;
538 Refresh();
539 }
540 }
541 else
542 {
543 if(button->state & wxRIBBON_BUTTONBAR_BUTTON_TOGGLED)
544 {
545 button->state &= ~wxRIBBON_BUTTONBAR_BUTTON_TOGGLED;
546 Refresh();
547 }
548 }
549 return;
550 }
551 }
552}
553
3c3ead1d
PC		 554void wxRibbonButtonBar::SetArtProvider(wxRibbonArtProvider* art)
555{
556 if(art == m_art)
557 {
558 return;
559 }
560
561 wxRibbonControl::SetArtProvider(art);
562
089ca539 563 wxClientDC temp_dc(this);
3c3ead1d
PC		 564 size_t btn_count = m_buttons.Count();
565 size_t btn_i;
566 for(btn_i = 0; btn_i < btn_count; ++btn_i)
567 {
568 wxRibbonButtonBarButtonBase* base = m_buttons.Item(btn_i);
569
570 FetchButtonSizeInfo(base, wxRIBBON_BUTTONBAR_BUTTON_SMALL, temp_dc);
571 FetchButtonSizeInfo(base, wxRIBBON_BUTTONBAR_BUTTON_MEDIUM, temp_dc);
572 FetchButtonSizeInfo(base, wxRIBBON_BUTTONBAR_BUTTON_LARGE, temp_dc);
573 }
574
575 m_layouts_valid = false;
576 Realize();
577}
578
579bool wxRibbonButtonBar::IsSizingContinuous() const
580{
581 return false;
582}
583
584wxSize wxRibbonButtonBar::DoGetNextSmallerSize(wxOrientation direction,
585 wxSize result) const
586{
587 size_t nlayouts = m_layouts.GetCount();
588 size_t i;
589 for(i = 0; i < nlayouts; ++i)
590 {
591 wxRibbonButtonBarLayout* layout = m_layouts.Item(i);
592 wxSize size = layout->overall_size;
593 switch(direction)
594 {
595 case wxHORIZONTAL:
596 if(size.x < result.x && size.y <= result.y)
597 {
598 result.x = size.x;
599 break;
600 }
601 else
602 continue;
603 case wxVERTICAL:
604 if(size.x <= result.x && size.y < result.y)
605 {
606 result.y = size.y;
607 break;
608 }
609 else
610 continue;
611 case wxBOTH:
612 if(size.x < result.x && size.y < result.y)
613 {
614 result = size;
615 break;
616 }
617 else
618 continue;
619 }
620 break;
621 }
622 return result;
623}
624
625wxSize wxRibbonButtonBar::DoGetNextLargerSize(wxOrientation direction,
626 wxSize result) const
627{
628 size_t nlayouts = m_layouts.GetCount();
629 size_t i = nlayouts;
630 while(i > 0)
631 {
632 --i;
633 wxRibbonButtonBarLayout* layout = m_layouts.Item(i);
634 wxSize size = layout->overall_size;
635 switch(direction)
636 {
637 case wxHORIZONTAL:
638 if(size.x > result.x && size.y <= result.y)
639 {
640 result.x = size.x;
641 break;
642 }
643 else
644 continue;
645 case wxVERTICAL:
646 if(size.x <= result.x && size.y > result.y)
647 {
648 result.y = size.y;
649 break;
650 }
651 else
652 continue;
653 case wxBOTH:
654 if(size.x > result.x && size.y > result.y)
655 {
656 result = size;
657 break;
658 }
659 else
660 continue;
661 }
662 break;
663 }
664 return result;
665}
666
f01e5624
VZ		 667void wxRibbonButtonBar::UpdateWindowUI(long flags)
668{
669 wxWindowBase::UpdateWindowUI(flags);
670
671 // don't waste time updating state of tools in a hidden toolbar
672 if ( !IsShown() )
673 return;
674
675 size_t btn_count = m_buttons.size();
676 bool rerealize = false;
677 for ( size_t btn_i = 0; btn_i < btn_count; ++btn_i )
678 {
679 wxRibbonButtonBarButtonBase& btn = *m_buttons.Item(btn_i);
680 int id = btn.id;
681
682 wxUpdateUIEvent event(id);
683 event.SetEventObject(this);
684
685 if ( ProcessWindowEvent(event) )
686 {
687 if ( event.GetSetEnabled() )
688 EnableButton(id, event.GetEnabled());
689 if ( event.GetSetChecked() )
690 ToggleButton(id, event.GetChecked());
691 if ( event.GetSetText() )
692 {
693 btn.label = event.GetText();
694 rerealize = true;
695 }
696 }
697 }
698
699 if ( rerealize )
700 Realize();
701}
702
3c3ead1d
PC		 703void wxRibbonButtonBar::OnEraseBackground(wxEraseEvent& WXUNUSED(evt))
704{
705 // All painting done in main paint handler to minimise flicker
706}
707
708void wxRibbonButtonBar::OnPaint(wxPaintEvent& WXUNUSED(evt))
709{
710 wxAutoBufferedPaintDC dc(this);
711 m_art->DrawButtonBarBackground(dc, this, GetSize());
712
713 wxRibbonButtonBarLayout* layout = m_layouts.Item(m_current_layout);
714
715 size_t btn_count = layout->buttons.Count();
716 size_t btn_i;
717 for(btn_i = 0; btn_i < btn_count; ++btn_i)
718 {
719 wxRibbonButtonBarButtonInstance& button = layout->buttons.Item(btn_i);
720 wxRibbonButtonBarButtonBase* base = button.base;
721
722 wxBitmap* bitmap = &base->bitmap_large;
723 wxBitmap* bitmap_small = &base->bitmap_small;
724 if(base->state & wxRIBBON_BUTTONBAR_BUTTON_DISABLED)
725 {
726 bitmap = &base->bitmap_large_disabled;
727 bitmap_small = &base->bitmap_small_disabled;
728 }
729 wxRect rect(button.position + m_layout_offset, base->sizes[button.size].size);
ce00f59b 730
3c3ead1d
PC		 731 m_art->DrawButtonBarButton(dc, this, rect, base->kind,
732 base->state | button.size, base->label, *bitmap, *bitmap_small);
733 }
734}
735
736void wxRibbonButtonBar::OnSize(wxSizeEvent& evt)
737{
738 wxSize new_size = evt.GetSize();
739 size_t layout_count = m_layouts.GetCount();
740 size_t layout_i;
741 m_current_layout = layout_count - 1;
742 for(layout_i = 0; layout_i < layout_count; ++layout_i)
743 {
744 wxSize layout_size = m_layouts.Item(layout_i)->overall_size;
745 if(layout_size.x <= new_size.x && layout_size.y <= new_size.y)
746 {
747 m_layout_offset.x = (new_size.x - layout_size.x) / 2;
748 m_layout_offset.y = (new_size.y - layout_size.y) / 2;
749 m_current_layout = layout_i;
750 break;
751 }
752 }
753 m_hovered_button = m_layouts.Item(m_current_layout)->FindSimilarInstance(m_hovered_button);
754 Refresh();
755}
756
757void wxRibbonButtonBar::CommonInit(long WXUNUSED(style))
758{
759 m_bitmap_size_large = wxSize(32, 32);
760 m_bitmap_size_small = wxSize(16, 16);
761
762 wxRibbonButtonBarLayout* placeholder_layout = new wxRibbonButtonBarLayout;
763 placeholder_layout->overall_size = wxSize(20, 20);
764 m_layouts.Add(placeholder_layout);
765 m_current_layout = 0;
766 m_layout_offset = wxPoint(0, 0);
767 m_hovered_button = NULL;
768 m_active_button = NULL;
769 m_lock_active_state = false;
770
771 SetBackgroundStyle(wxBG_STYLE_CUSTOM);
65391c8f 772}
3c3ead1d
PC		 773
774wxSize wxRibbonButtonBar::GetMinSize() const
775{
776 return m_layouts.Last()->overall_size;
777}
778
779wxSize wxRibbonButtonBar::DoGetBestSize() const
780{
781 return m_layouts.Item(0)->overall_size;
782}
783
784void wxRibbonButtonBar::MakeLayouts()
785{
786 if(m_layouts_valid || m_art == NULL)
787 {
788 return;
789 }
790 {
791 // Clear existing layouts
792 if(m_hovered_button)
793 {
794 m_hovered_button->base->state &= ~wxRIBBON_BUTTONBAR_BUTTON_HOVER_MASK;
795 m_hovered_button = NULL;
796 }
797 if(m_active_button)
798 {
799 m_active_button->base->state &= ~wxRIBBON_BUTTONBAR_BUTTON_ACTIVE_MASK;
800 m_active_button = NULL;
801 }
802 size_t count = m_layouts.GetCount();
803 size_t i;
804 for(i = 0; i < count; ++i)
805 {
806 wxRibbonButtonBarLayout* layout = m_layouts.Item(i);
807 delete layout;
808 }
809 m_layouts.Clear();
810 }
811 size_t btn_count = m_buttons.Count();
812 size_t btn_i;
813 {
814 // Best layout : all buttons large, stacking horizontally
815 wxRibbonButtonBarLayout* layout = new wxRibbonButtonBarLayout;
816 wxPoint cursor(0, 0);
817 layout->overall_size.SetHeight(0);
818 for(btn_i = 0; btn_i < btn_count; ++btn_i)
819 {
820 wxRibbonButtonBarButtonBase* button = m_buttons.Item(btn_i);
821 wxRibbonButtonBarButtonInstance instance = button->NewInstance();
822 instance.position = cursor;
823 instance.size = button->GetLargestSize();
824 wxSize& size = button->sizes[instance.size].size;
825 cursor.x += size.GetWidth();
826 layout->overall_size.SetHeight(wxMax(layout->overall_size.GetHeight(),
827 size.GetHeight()));
828 layout->buttons.Add(instance);
829 }
830 layout->overall_size.SetWidth(cursor.x);
831 m_layouts.Add(layout);
832 }
833 if(btn_count >= 2)
834 {
835 // Collapse the rightmost buttons and stack them vertically
836 size_t iLast = btn_count - 1;
837 while(TryCollapseLayout(m_layouts.Last(), iLast, &iLast) && iLast > 0)
838 {
839 --iLast;
840 }
841 }
842}
843
844bool wxRibbonButtonBar::TryCollapseLayout(wxRibbonButtonBarLayout* original,
845 size_t first_btn, size_t* last_button)
846{
847 size_t btn_count = m_buttons.Count();
848 size_t btn_i;
849 int used_height = 0;
850 int used_width = 0;
851 int available_width = 0;
852 int available_height = 0;
853
854 for(btn_i = first_btn + 1; btn_i > 0; /* decrement is inside loop */)
855 {
856 --btn_i;
857 wxRibbonButtonBarButtonBase* button = m_buttons.Item(btn_i);
858 wxRibbonButtonBarButtonState large_size_class = button->GetLargestSize();
859 wxSize large_size = button->sizes[large_size_class].size;
860 int t_available_height = wxMax(available_height,
861 large_size.GetHeight());
862 int t_available_width = available_width + large_size.GetWidth();
863 wxRibbonButtonBarButtonState small_size_class = large_size_class;
864 if(!button->GetSmallerSize(&small_size_class))
865 {
866 return false;
867 }
868 wxSize small_size = button->sizes[small_size_class].size;
869 int t_used_height = used_height + small_size.GetHeight();
870 int t_used_width = wxMax(used_width, small_size.GetWidth());
871
872 if(t_used_height > t_available_height)
873 {
874 ++btn_i;
875 break;
876 }
877 else
878 {
879 used_height = t_used_height;
880 used_width = t_used_width;
881 available_width = t_available_width;
882 available_height = t_available_height;
883 }
884 }
885
886 if(btn_i >= first_btn || used_width >= available_width)
887 {
888 return false;
889 }
890 if(last_button != NULL)
891 {
892 *last_button = btn_i;
893 }
894
895 wxRibbonButtonBarLayout* layout = new wxRibbonButtonBarLayout;
896 WX_APPEND_ARRAY(layout->buttons, original->buttons);
897 wxPoint cursor(layout->buttons.Item(btn_i).position);
898 bool preserve_height = false;
899 if(btn_i == 0)
900 {
901 // If height isn't preserved (i.e. it is reduced), then the minimum
902 // size for the button bar will decrease, preventing the original
903 // layout from being used (in some cases).
904 // It may be a good idea to always preverse the height, but for now
905 // it is only done when the first button is involved in a collapse.
906 preserve_height = true;
907 }
908
909 for(; btn_i <= first_btn; ++btn_i)
910 {
911 wxRibbonButtonBarButtonInstance& instance = layout->buttons.Item(btn_i);
912 instance.base->GetSmallerSize(&instance.size);
913 instance.position = cursor;
914 cursor.y += instance.base->sizes[instance.size].size.GetHeight();
915 }
916
917 int x_adjust = available_width - used_width;
918
919 for(; btn_i < btn_count; ++btn_i)
920 {
921 wxRibbonButtonBarButtonInstance& instance = layout->buttons.Item(btn_i);
922 instance.position.x -= x_adjust;
923 }
924
925 layout->CalculateOverallSize();
926
927 // Sanity check
928 if(layout->overall_size.GetWidth() >= original->overall_size.GetWidth() ||
929 layout->overall_size.GetHeight() > original->overall_size.GetHeight())
930 {
931 delete layout;
65391c8f 932 wxFAIL_MSG("Layout collapse resulted in increased size");
3c3ead1d
PC		 933 return false;
934 }
935
936 if(preserve_height)
937 {
938 layout->overall_size.SetHeight(original->overall_size.GetHeight());
939 }
940
941 m_layouts.Add(layout);
942 return true;
943}
944
945void wxRibbonButtonBar::OnMouseMove(wxMouseEvent& evt)
946{
947 wxPoint cursor(evt.GetPosition());
948 wxRibbonButtonBarButtonInstance* new_hovered = NULL;
949 long new_hovered_state = 0;
950
951 wxRibbonButtonBarLayout* layout = m_layouts.Item(m_current_layout);
952 size_t btn_count = layout->buttons.Count();
953 size_t btn_i;
954 for(btn_i = 0; btn_i < btn_count; ++btn_i)
955 {
956 wxRibbonButtonBarButtonInstance& instance = layout->buttons.Item(btn_i);
957 wxRibbonButtonBarButtonSizeInfo& size = instance.base->sizes[instance.size];
958 wxRect btn_rect;
959 btn_rect.SetTopLeft(m_layout_offset + instance.position);
960 btn_rect.SetSize(size.size);
961 if(btn_rect.Contains(cursor))
962 {
963 new_hovered = &instance;
964 new_hovered_state = instance.base->state;
965 new_hovered_state &= ~wxRIBBON_BUTTONBAR_BUTTON_HOVER_MASK;
966 wxPoint offset(cursor);
967 offset -= btn_rect.GetTopLeft();
968 if(size.normal_region.Contains(offset))
969 {
970 new_hovered_state |= wxRIBBON_BUTTONBAR_BUTTON_NORMAL_HOVERED;
971 }
972 if(size.dropdown_region.Contains(offset))
973 {
974 new_hovered_state |= wxRIBBON_BUTTONBAR_BUTTON_DROPDOWN_HOVERED;
975 }
976 break;
977 }
978 }
979
f8193bbb 980#if wxUSE_TOOLTIPS
349f41fd
VZ		 981 if(new_hovered == NULL && GetToolTip())
982 {
983 UnsetToolTip();
984 }
f8193bbb 985#endif
349f41fd 986
3c3ead1d
PC		 987 if(new_hovered != m_hovered_button || (m_hovered_button != NULL &&
988 new_hovered_state != m_hovered_button->base->state))
989 {
990 if(m_hovered_button != NULL)
991 {
992 m_hovered_button->base->state &= ~wxRIBBON_BUTTONBAR_BUTTON_HOVER_MASK;
993 }
994 m_hovered_button = new_hovered;
995 if(m_hovered_button != NULL)
996 {
997 m_hovered_button->base->state = new_hovered_state;
f8193bbb 998#if wxUSE_TOOLTIPS
349f41fd 999 SetToolTip(m_hovered_button->base->help_string);
f8193bbb 1000#endif
3c3ead1d
PC		 1001 }
1002 Refresh(false);
1003 }
1004
1005 if(m_active_button && !m_lock_active_state)
1006 {
1007 long new_active_state = m_active_button->base->state;
1008 new_active_state &= ~wxRIBBON_BUTTONBAR_BUTTON_ACTIVE_MASK;
1009 wxRibbonButtonBarButtonSizeInfo& size =
1010 m_active_button->base->sizes[m_active_button->size];
1011 wxRect btn_rect;
1012 btn_rect.SetTopLeft(m_layout_offset + m_active_button->position);
1013 btn_rect.SetSize(size.size);
1014 if(btn_rect.Contains(cursor))
1015 {
1016 wxPoint offset(cursor);
1017 offset -= btn_rect.GetTopLeft();
1018 if(size.normal_region.Contains(offset))
1019 {
1020 new_active_state |= wxRIBBON_BUTTONBAR_BUTTON_NORMAL_ACTIVE;
1021 }
1022 if(size.dropdown_region.Contains(offset))
1023 {
1024 new_active_state |= wxRIBBON_BUTTONBAR_BUTTON_DROPDOWN_ACTIVE;
1025 }
1026 }
1027 if(new_active_state != m_active_button->base->state)
1028 {
1029 m_active_button->base->state = new_active_state;
1030 Refresh(false);
1031 }
1032 }
1033}
1034
1035void wxRibbonButtonBar::OnMouseDown(wxMouseEvent& evt)
1036{
1037 wxPoint cursor(evt.GetPosition());
1038 m_active_button = NULL;
1039
1040 wxRibbonButtonBarLayout* layout = m_layouts.Item(m_current_layout);
1041 size_t btn_count = layout->buttons.Count();
1042 size_t btn_i;
1043 for(btn_i = 0; btn_i < btn_count; ++btn_i)
1044 {
1045 wxRibbonButtonBarButtonInstance& instance = layout->buttons.Item(btn_i);
1046 wxRibbonButtonBarButtonSizeInfo& size = instance.base->sizes[instance.size];
1047 wxRect btn_rect;
1048 btn_rect.SetTopLeft(m_layout_offset + instance.position);
1049 btn_rect.SetSize(size.size);
1050 if(btn_rect.Contains(cursor))
1051 {
1052 m_active_button = &instance;
1053 cursor -= btn_rect.GetTopLeft();
1054 long state = 0;
1055 if(size.normal_region.Contains(cursor))
1056 state = wxRIBBON_BUTTONBAR_BUTTON_NORMAL_ACTIVE;
1057 else if(size.dropdown_region.Contains(cursor))
1058 state = wxRIBBON_BUTTONBAR_BUTTON_DROPDOWN_ACTIVE;
1059 instance.base->state |= state;
1060 Refresh(false);
1061 break;
1062 }
1063 }
1064}
1065
1066void wxRibbonButtonBar::OnMouseUp(wxMouseEvent& evt)
1067{
1068 wxPoint cursor(evt.GetPosition());
1069
1070 if(m_active_button)
1071 {
1072 wxRibbonButtonBarButtonSizeInfo& size =
1073 m_active_button->base->sizes[m_active_button->size];
1074 wxRect btn_rect;
1075 btn_rect.SetTopLeft(m_layout_offset + m_active_button->position);
1076 btn_rect.SetSize(size.size);
1077 if(btn_rect.Contains(cursor))
1078 {
1079 int id = m_active_button->base->id;
1080 cursor -= btn_rect.GetTopLeft();
1081 wxEventType event_type;
1082 do
1083 {
1084 if(size.normal_region.Contains(cursor))
1085 event_type = wxEVT_COMMAND_RIBBONBUTTON_CLICKED;
1086 else if(size.dropdown_region.Contains(cursor))
1087 event_type = wxEVT_COMMAND_RIBBONBUTTON_DROPDOWN_CLICKED;
1088 else
1089 break;
1090 wxRibbonButtonBarEvent notification(event_type, id);
955bad41
PC		 1091 if(m_active_button->base->kind == wxRIBBON_BUTTON_TOGGLE)
1092 {
1093 m_active_button->base->state ^=
1094 wxRIBBON_BUTTONBAR_BUTTON_TOGGLED;
1095 notification.SetInt(m_active_button->base->state &
1096 wxRIBBON_BUTTONBAR_BUTTON_TOGGLED);
1097 }
3c3ead1d
PC		 1098 notification.SetEventObject(this);
1099 notification.SetBar(this);
1100 m_lock_active_state = true;
1101 ProcessWindowEvent(notification);
1102 m_lock_active_state = false;
1103 } while(false);
1104 if(m_active_button) // may have been NULLed by event handler
1105 {
1106 m_active_button->base->state &= ~wxRIBBON_BUTTONBAR_BUTTON_ACTIVE_MASK;
1107 m_active_button = NULL;
1108 }
1109 Refresh(false);
1110 }
1111 }
1112}
1113
1114void wxRibbonButtonBar::OnMouseEnter(wxMouseEvent& evt)
1115{
1116 if(m_active_button && !evt.LeftIsDown())
1117 {
1118 m_active_button = NULL;
1119 }
1120}
1121
1122void wxRibbonButtonBar::OnMouseLeave(wxMouseEvent& WXUNUSED(evt))
1123{
1124 bool repaint = false;
1125 if(m_hovered_button != NULL)
1126 {
1127 m_hovered_button->base->state &= ~wxRIBBON_BUTTONBAR_BUTTON_HOVER_MASK;
1128 m_hovered_button = NULL;
1129 repaint = true;
1130 }
1131 if(m_active_button != NULL && !m_lock_active_state)
1132 {
1133 m_active_button->base->state &= ~wxRIBBON_BUTTONBAR_BUTTON_ACTIVE_MASK;
1134 repaint = true;
1135 }
1136 if(repaint)
1137 Refresh(false);
1138}
1139
1140bool wxRibbonButtonBarEvent::PopupMenu(wxMenu* menu)
1141{
1142 wxPoint pos = wxDefaultPosition;
1143 if(m_bar->m_active_button)
1144 {
1145 wxRibbonButtonBarButtonSizeInfo& size =
1146 m_bar->m_active_button->base->sizes[m_bar->m_active_button->size];
1147 wxRect btn_rect;
1148 btn_rect.SetTopLeft(m_bar->m_layout_offset +
1149 m_bar->m_active_button->position);
1150 btn_rect.SetSize(size.size);
1151 pos = btn_rect.GetBottomLeft();
1152 pos.y++;
1153 }
1154 return m_bar->PopupMenu(menu, pos);
1155}
1156
1157#endif // wxUSE_RIBBON
wxWidgets (Impactor)