1 ///////////////////////////////////////////////////////////////////////////////
3 // Name: src/aui/auibar.cpp
4 // Purpose: wxaui: wx advanced user interface - docking window manager
5 // Author: Benjamin I. Williams
9 // Copyright: (C) Copyright 2005-2006, Kirix Corporation, All Rights Reserved
10 // Licence: wxWindows Library Licence, Version 3.1
11 ///////////////////////////////////////////////////////////////////////////////
13 // ============================================================================
15 // ============================================================================
17 // ----------------------------------------------------------------------------
19 // ----------------------------------------------------------------------------
21 #include "wx/wxprec.h"
29 #include "wx/statline.h"
30 #include "wx/dcbuffer.h"
33 #include "wx/settings.h"
36 #include "wx/aui/auibar.h"
37 #include "wx/aui/framemanager.h"
40 #include "wx/osx/private.h"
43 #include "wx/arrimpl.cpp"
44 WX_DEFINE_OBJARRAY(wxAuiToolBarItemArray
)
47 wxDEFINE_EVENT( wxEVT_COMMAND_AUITOOLBAR_TOOL_DROPDOWN
, wxAuiToolBarEvent
);
48 wxDEFINE_EVENT( wxEVT_COMMAND_AUITOOLBAR_OVERFLOW_CLICK
, wxAuiToolBarEvent
);
49 wxDEFINE_EVENT( wxEVT_COMMAND_AUITOOLBAR_RIGHT_CLICK
, wxAuiToolBarEvent
);
50 wxDEFINE_EVENT( wxEVT_COMMAND_AUITOOLBAR_MIDDLE_CLICK
, wxAuiToolBarEvent
);
51 wxDEFINE_EVENT( wxEVT_COMMAND_AUITOOLBAR_BEGIN_DRAG
, wxAuiToolBarEvent
);
54 IMPLEMENT_CLASS(wxAuiToolBar
, wxControl
)
55 IMPLEMENT_DYNAMIC_CLASS(wxAuiToolBarEvent
, wxEvent
)
58 // missing wxITEM_* items
61 wxITEM_CONTROL
= wxITEM_MAX
,
66 const int BUTTON_DROPDOWN_WIDTH
= 10;
69 wxBitmap
wxAuiBitmapFromBits(const unsigned char bits
[], int w
, int h
,
70 const wxColour
& color
);
72 static wxColor
GetBaseColor()
75 #if defined( __WXMAC__ ) && wxOSX_USE_COCOA_OR_CARBON
76 wxColor baseColour
= wxColour( wxMacCreateCGColorFromHITheme(kThemeBrushToolbarBackground
));
78 wxColor baseColour
= wxSystemSettings
::GetColour(wxSYS_COLOUR_3DFACE
);
81 // the baseColour is too pale to use as our base colour,
82 // so darken it a bit --
83 if ((255-baseColour
.Red()) +
84 (255-baseColour
.Green()) +
85 (255-baseColour
.Blue()) < 60)
87 baseColour
= baseColour
.ChangeLightness(92);
95 class ToolbarCommandCapture
: public wxEvtHandler
99 ToolbarCommandCapture() { m_lastId
= 0; }
100 int GetCommandId() const { return m_lastId
; }
102 bool ProcessEvent(wxEvent
& evt
)
104 if (evt
.GetEventType() == wxEVT_COMMAND_MENU_SELECTED
)
106 m_lastId
= evt
.GetId();
110 if (GetNextHandler())
111 return GetNextHandler()->ProcessEvent(evt
);
122 static const unsigned char
123 DISABLED_TEXT_GREY_HUE
= wxColour
::AlphaBlend(0, 255, 0.4);
124 const wxColour
DISABLED_TEXT_COLOR(DISABLED_TEXT_GREY_HUE
,
125 DISABLED_TEXT_GREY_HUE
,
126 DISABLED_TEXT_GREY_HUE
);
128 wxAuiDefaultToolBarArt
::wxAuiDefaultToolBarArt()
130 m_baseColour
= GetBaseColor();
133 m_textOrientation
= wxAUI_TBTOOL_TEXT_BOTTOM
;
134 m_highlightColour
= wxSystemSettings
::GetColour(wxSYS_COLOUR_HIGHLIGHT
);
140 wxColor darker1Colour
= m_baseColour
.ChangeLightness(85);
141 wxColor darker2Colour
= m_baseColour
.ChangeLightness(75);
142 wxColor darker3Colour
= m_baseColour
.ChangeLightness(60);
143 wxColor darker4Colour
= m_baseColour
.ChangeLightness(50);
144 wxColor darker5Colour
= m_baseColour
.ChangeLightness(40);
146 m_gripperPen1
= wxPen(darker5Colour
);
147 m_gripperPen2
= wxPen(darker3Colour
);
148 m_gripperPen3
= *wxWHITE_PEN
;
150 static const unsigned char buttonDropdownBits
[] = { 0xe0, 0xf1, 0xfb };
151 static const unsigned char overflowBits
[] = { 0x80, 0xff, 0x80, 0xc1, 0xe3, 0xf7 };
153 m_buttonDropDownBmp
= wxAuiBitmapFromBits(buttonDropdownBits
, 5, 3,
155 m_disabledButtonDropDownBmp
= wxAuiBitmapFromBits(
156 buttonDropdownBits
, 5, 3,
157 wxColor(128,128,128));
158 m_overflowBmp
= wxAuiBitmapFromBits(overflowBits
, 7, 6, *wxBLACK
);
159 m_disabledOverflowBmp
= wxAuiBitmapFromBits(overflowBits
, 7, 6, wxColor(128,128,128));
161 m_font
= *wxNORMAL_FONT
;
164 wxAuiDefaultToolBarArt
::~wxAuiDefaultToolBarArt()
166 m_font
= *wxNORMAL_FONT
;
170 wxAuiToolBarArt
* wxAuiDefaultToolBarArt
::Clone()
172 return static_cast<wxAuiToolBarArt
*>(new wxAuiDefaultToolBarArt
);
175 void wxAuiDefaultToolBarArt
::SetFlags(unsigned int flags
)
180 void wxAuiDefaultToolBarArt
::SetFont(const wxFont
& font
)
185 void wxAuiDefaultToolBarArt
::SetTextOrientation(int orientation
)
187 m_textOrientation
= orientation
;
190 unsigned int wxAuiDefaultToolBarArt
::GetFlags()
195 wxFont wxAuiDefaultToolBarArt
::GetFont()
200 int wxAuiDefaultToolBarArt
::GetTextOrientation()
202 return m_textOrientation
;
205 void wxAuiDefaultToolBarArt
::DrawBackground(
207 wxWindow
* WXUNUSED(wnd
),
212 wxColour startColour
= m_baseColour
.ChangeLightness(150);
213 wxColour endColour
= m_baseColour
.ChangeLightness(90);
214 dc
.GradientFillLinear(rect
, startColour
, endColour
, wxSOUTH
);
217 void wxAuiDefaultToolBarArt
::DrawLabel(
219 wxWindow
* WXUNUSED(wnd
),
220 const wxAuiToolBarItem
& item
,
224 dc
.SetTextForeground(*wxBLACK
);
226 // we only care about the text height here since the text
227 // will get cropped based on the width of the item
228 int textWidth
= 0, textHeight
= 0;
229 dc
.GetTextExtent(wxT("ABCDHgj"), &textWidth
, &textHeight
);
231 // set the clipping region
232 wxRect clipRect
= rect
;
234 dc
.SetClippingRegion(clipRect
);
238 textY
= rect
.y
+ (rect
.height
-textHeight
)/2;
239 dc
.DrawText(item
.GetLabel(), textX
, textY
);
240 dc
.DestroyClippingRegion();
244 void wxAuiDefaultToolBarArt
::DrawButton(
246 wxWindow
* WXUNUSED(wnd
),
247 const wxAuiToolBarItem
& item
,
250 int textWidth
= 0, textHeight
= 0;
252 if (m_flags
& wxAUI_TB_TEXT
)
258 dc
.GetTextExtent(wxT("ABCDHgj"), &tx
, &textHeight
);
260 dc
.GetTextExtent(item
.GetLabel(), &textWidth
, &ty
);
263 int bmpX
= 0, bmpY
= 0;
264 int textX
= 0, textY
= 0;
266 if (m_textOrientation
== wxAUI_TBTOOL_TEXT_BOTTOM
)
270 (item
.GetBitmap().GetWidth()/2);
273 ((rect
.height
-textHeight
)/2) -
274 (item
.GetBitmap().GetHeight()/2);
276 textX
= rect
.x
+ (rect
.width
/2) - (textWidth
/2) + 1;
277 textY
= rect
.y
+ rect
.height
- textHeight
- 1;
279 else if (m_textOrientation
== wxAUI_TBTOOL_TEXT_RIGHT
)
285 (item
.GetBitmap().GetHeight()/2);
287 textX
= bmpX
+ 3 + item
.GetBitmap().GetWidth();
294 if (!(item
.GetState() & wxAUI_BUTTON_STATE_DISABLED
))
296 if (item
.GetState() & wxAUI_BUTTON_STATE_PRESSED
)
298 dc
.SetPen(wxPen(m_highlightColour
));
299 dc
.SetBrush(wxBrush(m_highlightColour
.ChangeLightness(150)));
300 dc
.DrawRectangle(rect
);
302 else if ((item
.GetState() & wxAUI_BUTTON_STATE_HOVER
) || item
.IsSticky())
304 dc
.SetPen(wxPen(m_highlightColour
));
305 dc
.SetBrush(wxBrush(m_highlightColour
.ChangeLightness(170)));
307 // draw an even lighter background for checked item hovers (since
308 // the hover background is the same color as the check background)
309 if (item
.GetState() & wxAUI_BUTTON_STATE_CHECKED
)
310 dc
.SetBrush(wxBrush(m_highlightColour
.ChangeLightness(180)));
312 dc
.DrawRectangle(rect
);
314 else if (item
.GetState() & wxAUI_BUTTON_STATE_CHECKED
)
316 // it's important to put this code in an else statment after the
317 // hover, otherwise hovers won't draw properly for checked items
318 dc
.SetPen(wxPen(m_highlightColour
));
319 dc
.SetBrush(wxBrush(m_highlightColour
.ChangeLightness(170)));
320 dc
.DrawRectangle(rect
);
325 if (item
.GetState() & wxAUI_BUTTON_STATE_DISABLED
)
326 bmp
= item
.GetDisabledBitmap();
328 bmp
= item
.GetBitmap();
331 dc
.DrawBitmap(bmp
, bmpX
, bmpY
, true);
333 // set the item's text color based on if it is disabled
334 dc
.SetTextForeground(*wxBLACK
);
335 if (item
.GetState() & wxAUI_BUTTON_STATE_DISABLED
)
336 dc
.SetTextForeground(DISABLED_TEXT_COLOR
);
338 if ( (m_flags
& wxAUI_TB_TEXT
) && !item
.GetLabel().empty() )
340 dc
.DrawText(item
.GetLabel(), textX
, textY
);
345 void wxAuiDefaultToolBarArt
::DrawDropDownButton(
347 wxWindow
* WXUNUSED(wnd
),
348 const wxAuiToolBarItem
& item
,
351 int textWidth
= 0, textHeight
= 0, textX
= 0, textY
= 0;
352 int bmpX
= 0, bmpY
= 0, dropBmpX
= 0, dropBmpY
= 0;
354 wxRect buttonRect
= wxRect(rect
.x
,
356 rect
.width
-BUTTON_DROPDOWN_WIDTH
,
358 wxRect dropDownRect
= wxRect(rect
.x
+rect
.width
-BUTTON_DROPDOWN_WIDTH
-1,
360 BUTTON_DROPDOWN_WIDTH
+1,
363 if (m_flags
& wxAUI_TB_TEXT
)
368 if (m_flags
& wxAUI_TB_TEXT
)
370 dc
.GetTextExtent(wxT("ABCDHgj"), &tx
, &textHeight
);
374 dc
.GetTextExtent(item
.GetLabel(), &textWidth
, &ty
);
379 dropBmpX
= dropDownRect
.x
+
380 (dropDownRect
.width
/2) -
381 (m_buttonDropDownBmp
.GetWidth()/2);
382 dropBmpY
= dropDownRect
.y
+
383 (dropDownRect
.height
/2) -
384 (m_buttonDropDownBmp
.GetHeight()/2);
387 if (m_textOrientation
== wxAUI_TBTOOL_TEXT_BOTTOM
)
389 bmpX
= buttonRect
.x
+
390 (buttonRect
.width
/2) -
391 (item
.GetBitmap().GetWidth()/2);
392 bmpY
= buttonRect
.y
+
393 ((buttonRect
.height
-textHeight
)/2) -
394 (item
.GetBitmap().GetHeight()/2);
396 textX
= rect
.x
+ (rect
.width
/2) - (textWidth
/2) + 1;
397 textY
= rect
.y
+ rect
.height
- textHeight
- 1;
399 else if (m_textOrientation
== wxAUI_TBTOOL_TEXT_RIGHT
)
405 (item
.GetBitmap().GetHeight()/2);
407 textX
= bmpX
+ 3 + item
.GetBitmap().GetWidth();
414 if (item
.GetState() & wxAUI_BUTTON_STATE_PRESSED
)
416 dc
.SetPen(wxPen(m_highlightColour
));
417 dc
.SetBrush(wxBrush(m_highlightColour
.ChangeLightness(140)));
418 dc
.DrawRectangle(buttonRect
);
420 dc
.SetBrush(wxBrush(m_highlightColour
.ChangeLightness(170)));
421 dc
.DrawRectangle(dropDownRect
);
423 else if (item
.GetState() & wxAUI_BUTTON_STATE_HOVER
||
426 dc
.SetPen(wxPen(m_highlightColour
));
427 dc
.SetBrush(wxBrush(m_highlightColour
.ChangeLightness(170)));
428 dc
.DrawRectangle(buttonRect
);
429 dc
.DrawRectangle(dropDownRect
);
431 else if (item
.GetState() & wxAUI_BUTTON_STATE_CHECKED
)
433 // Notice that this branch must come after the hover one to ensure the
434 // correct appearance when the mouse hovers over a checked item.m_
435 dc
.SetPen(wxPen(m_highlightColour
));
436 dc
.SetBrush(wxBrush(m_highlightColour
.ChangeLightness(170)));
437 dc
.DrawRectangle(buttonRect
);
438 dc
.DrawRectangle(dropDownRect
);
443 if (item
.GetState() & wxAUI_BUTTON_STATE_DISABLED
)
445 bmp
= item
.GetDisabledBitmap();
446 dropbmp
= m_disabledButtonDropDownBmp
;
450 bmp
= item
.GetBitmap();
451 dropbmp
= m_buttonDropDownBmp
;
457 dc
.DrawBitmap(bmp
, bmpX
, bmpY
, true);
458 dc
.DrawBitmap(dropbmp
, dropBmpX
, dropBmpY
, true);
460 // set the item's text color based on if it is disabled
461 dc
.SetTextForeground(*wxBLACK
);
462 if (item
.GetState() & wxAUI_BUTTON_STATE_DISABLED
)
463 dc
.SetTextForeground(DISABLED_TEXT_COLOR
);
465 if ( (m_flags
& wxAUI_TB_TEXT
) && !item
.GetLabel().empty() )
467 dc
.DrawText(item
.GetLabel(), textX
, textY
);
471 void wxAuiDefaultToolBarArt
::DrawControlLabel(
473 wxWindow
* WXUNUSED(wnd
),
474 const wxAuiToolBarItem
& item
,
477 if (!(m_flags
& wxAUI_TB_TEXT
))
480 if (m_textOrientation
!= wxAUI_TBTOOL_TEXT_BOTTOM
)
483 int textX
= 0, textY
= 0;
484 int textWidth
= 0, textHeight
= 0;
489 if (m_flags
& wxAUI_TB_TEXT
)
491 dc
.GetTextExtent(wxT("ABCDHgj"), &tx
, &textHeight
);
495 dc
.GetTextExtent(item
.GetLabel(), &textWidth
, &ty
);
497 // don't draw the label if it is wider than the item width
498 if (textWidth
> rect
.width
)
501 // set the label's text color
502 dc
.SetTextForeground(*wxBLACK
);
504 textX
= rect
.x
+ (rect
.width
/2) - (textWidth
/2) + 1;
505 textY
= rect
.y
+ rect
.height
- textHeight
- 1;
507 if ( (m_flags
& wxAUI_TB_TEXT
) && !item
.GetLabel().empty() )
509 dc
.DrawText(item
.GetLabel(), textX
, textY
);
513 wxSize wxAuiDefaultToolBarArt
::GetLabelSize(
515 wxWindow
* WXUNUSED(wnd
),
516 const wxAuiToolBarItem
& item
)
520 // get label's height
521 int width
= 0, height
= 0;
522 dc
.GetTextExtent(wxT("ABCDHgj"), &width
, &height
);
525 width
= item
.GetMinSize().GetWidth();
529 // no width specified, measure the text ourselves
530 width
= dc
.GetTextExtent(item
.GetLabel()).GetX();
533 return wxSize(width
, height
);
536 wxSize wxAuiDefaultToolBarArt
::GetToolSize(
538 wxWindow
* WXUNUSED(wnd
),
539 const wxAuiToolBarItem
& item
)
541 if (!item
.GetBitmap().IsOk() && !(m_flags
& wxAUI_TB_TEXT
))
542 return wxSize(16,16);
544 int width
= item
.GetBitmap().GetWidth();
545 int height
= item
.GetBitmap().GetHeight();
547 if (m_flags
& wxAUI_TB_TEXT
)
552 if (m_textOrientation
== wxAUI_TBTOOL_TEXT_BOTTOM
)
554 dc
.GetTextExtent(wxT("ABCDHgj"), &tx
, &ty
);
557 if ( !item
.GetLabel().empty() )
559 dc
.GetTextExtent(item
.GetLabel(), &tx
, &ty
);
560 width
= wxMax(width
, tx
+6);
563 else if ( m_textOrientation
== wxAUI_TBTOOL_TEXT_RIGHT
&&
564 !item
.GetLabel().empty() )
566 width
+= 3; // space between left border and bitmap
567 width
+= 3; // space between bitmap and text
569 if ( !item
.GetLabel().empty() )
571 dc
.GetTextExtent(item
.GetLabel(), &tx
, &ty
);
573 height
= wxMax(height
, ty
);
578 // if the tool has a dropdown button, add it to the width
579 if (item
.HasDropDown())
580 width
+= (BUTTON_DROPDOWN_WIDTH
+4);
582 return wxSize(width
, height
);
585 void wxAuiDefaultToolBarArt
::DrawSeparator(
587 wxWindow
* WXUNUSED(wnd
),
590 bool horizontal
= true;
591 if (m_flags
& wxAUI_TB_VERTICAL
)
598 rect
.x
+= (rect
.width
/2);
600 int new_height
= (rect
.height
*3)/4;
601 rect
.y
+= (rect
.height
/2) - (new_height
/2);
602 rect
.height
= new_height
;
606 rect
.y
+= (rect
.height
/2);
608 int new_width
= (rect
.width
*3)/4;
609 rect
.x
+= (rect
.width
/2) - (new_width
/2);
610 rect
.width
= new_width
;
613 wxColour startColour
= m_baseColour
.ChangeLightness(80);
614 wxColour endColour
= m_baseColour
.ChangeLightness(80);
615 dc
.GradientFillLinear(rect
, startColour
, endColour
, horizontal ? wxSOUTH
: wxEAST
);
618 void wxAuiDefaultToolBarArt
::DrawGripper(wxDC
& dc
,
619 wxWindow
* WXUNUSED(wnd
),
627 if (m_flags
& wxAUI_TB_VERTICAL
)
629 x
= rect
.x
+ (i
*4) + 5;
631 if (x
> rect
.GetWidth()-5)
637 y
= rect
.y
+ (i
*4) + 5;
638 if (y
> rect
.GetHeight()-5)
642 dc
.SetPen(m_gripperPen1
);
644 dc
.SetPen(m_gripperPen2
);
645 dc
.DrawPoint(x
, y
+1);
646 dc
.DrawPoint(x
+1, y
);
647 dc
.SetPen(m_gripperPen3
);
648 dc
.DrawPoint(x
+2, y
+1);
649 dc
.DrawPoint(x
+2, y
+2);
650 dc
.DrawPoint(x
+1, y
+2);
657 void wxAuiDefaultToolBarArt
::DrawOverflowButton(wxDC
& dc
,
662 if (state
& wxAUI_BUTTON_STATE_HOVER
||
663 state
& wxAUI_BUTTON_STATE_PRESSED
)
665 wxRect cli_rect
= wnd
->GetClientRect();
666 wxColor light_gray_bg
= m_highlightColour
.ChangeLightness(170);
668 if (m_flags
& wxAUI_TB_VERTICAL
)
670 dc
.SetPen(wxPen(m_highlightColour
));
671 dc
.DrawLine(rect
.x
, rect
.y
, rect
.x
+rect
.width
, rect
.y
);
672 dc
.SetPen(wxPen(light_gray_bg
));
673 dc
.SetBrush(wxBrush(light_gray_bg
));
674 dc
.DrawRectangle(rect
.x
, rect
.y
+1, rect
.width
, rect
.height
);
678 dc
.SetPen(wxPen(m_highlightColour
));
679 dc
.DrawLine(rect
.x
, rect
.y
, rect
.x
, rect
.y
+rect
.height
);
680 dc
.SetPen(wxPen(light_gray_bg
));
681 dc
.SetBrush(wxBrush(light_gray_bg
));
682 dc
.DrawRectangle(rect
.x
+1, rect
.y
, rect
.width
, rect
.height
);
686 int x
= rect
.x
+1+(rect
.width
-m_overflowBmp
.GetWidth())/2;
687 int y
= rect
.y
+1+(rect
.height
-m_overflowBmp
.GetHeight())/2;
688 dc
.DrawBitmap(m_overflowBmp
, x
, y
, true);
691 int wxAuiDefaultToolBarArt
::GetElementSize(int element_id
)
695 case wxAUI_TBART_SEPARATOR_SIZE
: return m_separatorSize
;
696 case wxAUI_TBART_GRIPPER_SIZE
: return m_gripperSize
;
697 case wxAUI_TBART_OVERFLOW_SIZE
: return m_overflowSize
;
702 void wxAuiDefaultToolBarArt
::SetElementSize(int element_id
, int size
)
706 case wxAUI_TBART_SEPARATOR_SIZE
: m_separatorSize
= size
; break;
707 case wxAUI_TBART_GRIPPER_SIZE
: m_gripperSize
= size
; break;
708 case wxAUI_TBART_OVERFLOW_SIZE
: m_overflowSize
= size
; break;
712 int wxAuiDefaultToolBarArt
::ShowDropDown(wxWindow
* wnd
,
713 const wxAuiToolBarItemArray
& items
)
717 size_t items_added
= 0;
719 size_t i
, count
= items
.GetCount();
720 for (i
= 0; i
< count
; ++i
)
722 wxAuiToolBarItem
& item
= items
.Item(i
);
724 if (item
.GetKind() == wxITEM_NORMAL
)
726 wxString text
= item
.GetShortHelp();
728 text
= item
.GetLabel();
733 wxMenuItem
* m
= new wxMenuItem(&menuPopup
, item
.GetId(), text
, item
.GetShortHelp());
735 m
->SetBitmap(item
.GetBitmap());
739 else if (item
.GetKind() == wxITEM_SEPARATOR
)
742 menuPopup
.AppendSeparator();
746 // find out where to put the popup menu of window items
747 wxPoint pt
= ::wxGetMousePosition();
748 pt
= wnd
->ScreenToClient(pt
);
750 // find out the screen coordinate at the bottom of the tab ctrl
751 wxRect cli_rect
= wnd
->GetClientRect();
752 pt
.y
= cli_rect
.y
+ cli_rect
.height
;
754 ToolbarCommandCapture
* cc
= new ToolbarCommandCapture
;
755 wnd
->PushEventHandler(cc
);
756 wnd
->PopupMenu(&menuPopup
, pt
);
757 int command
= cc
->GetCommandId();
758 wnd
->PopEventHandler(true);
766 static wxOrientation
GetOrientation(long& style
)
768 switch (style
& wxAUI_ORIENTATION_MASK
)
770 case wxAUI_TB_HORIZONTAL
:
772 case wxAUI_TB_VERTICAL
:
775 wxFAIL_MSG("toolbar cannot be locked in both horizontal and vertical orientations (maybe no lock was intended?)");
782 BEGIN_EVENT_TABLE(wxAuiToolBar
, wxControl
)
783 EVT_SIZE(wxAuiToolBar
::OnSize
)
784 EVT_IDLE(wxAuiToolBar
::OnIdle
)
785 EVT_ERASE_BACKGROUND(wxAuiToolBar
::OnEraseBackground
)
786 EVT_PAINT(wxAuiToolBar
::OnPaint
)
787 EVT_LEFT_DOWN(wxAuiToolBar
::OnLeftDown
)
788 EVT_LEFT_DCLICK(wxAuiToolBar
::OnLeftDown
)
789 EVT_LEFT_UP(wxAuiToolBar
::OnLeftUp
)
790 EVT_RIGHT_DOWN(wxAuiToolBar
::OnRightDown
)
791 EVT_RIGHT_DCLICK(wxAuiToolBar
::OnRightDown
)
792 EVT_RIGHT_UP(wxAuiToolBar
::OnRightUp
)
793 EVT_MIDDLE_DOWN(wxAuiToolBar
::OnMiddleDown
)
794 EVT_MIDDLE_DCLICK(wxAuiToolBar
::OnMiddleDown
)
795 EVT_MIDDLE_UP(wxAuiToolBar
::OnMiddleUp
)
796 EVT_MOTION(wxAuiToolBar
::OnMotion
)
797 EVT_LEAVE_WINDOW(wxAuiToolBar
::OnLeaveWindow
)
798 EVT_MOUSE_CAPTURE_LOST(wxAuiToolBar
::OnCaptureLost
)
799 EVT_SET_CURSOR(wxAuiToolBar
::OnSetCursor
)
803 wxAuiToolBar
::wxAuiToolBar(wxWindow
* parent
,
805 const wxPoint
& position
,
812 style
| wxBORDER_NONE
)
814 m_sizer
= new wxBoxSizer(wxHORIZONTAL
);
817 m_sizerElementCount
= 0;
818 m_actionPos
= wxPoint(-1,-1);
821 m_art
= new wxAuiDefaultToolBarArt
;
823 m_toolBorderPadding
= 3;
824 m_toolTextOrientation
= wxAUI_TBTOOL_TEXT_BOTTOM
;
825 m_gripperSizerItem
= NULL
;
826 m_overflowSizerItem
= NULL
;
828 m_orientation
= GetOrientation(style
);
829 if (m_orientation
== wxBOTH
)
831 m_orientation
= wxHORIZONTAL
;
833 m_style
= style
| wxBORDER_NONE
;
834 m_gripperVisible
= (m_style
& wxAUI_TB_GRIPPER
) ?
true : false;
835 m_overflowVisible
= (m_style
& wxAUI_TB_OVERFLOW
) ?
true : false;
837 SetMargins(5, 5, 2, 2);
838 SetFont(*wxNORMAL_FONT
);
840 SetExtraStyle(wxWS_EX_PROCESS_IDLE
);
841 if (style
& wxAUI_TB_HORZ_LAYOUT
)
842 SetToolTextOrientation(wxAUI_TBTOOL_TEXT_RIGHT
);
843 SetBackgroundStyle(wxBG_STYLE_CUSTOM
);
847 wxAuiToolBar
::~wxAuiToolBar()
853 void wxAuiToolBar
::SetWindowStyleFlag(long style
)
855 GetOrientation(style
); // assert if style is invalid
856 wxCHECK_RET(IsPaneValid(style
),
857 "window settings and pane settings are incompatible");
859 wxControl
::SetWindowStyleFlag(style
);
868 if (m_style
& wxAUI_TB_GRIPPER
)
869 m_gripperVisible
= true;
871 m_gripperVisible
= false;
874 if (m_style
& wxAUI_TB_OVERFLOW
)
875 m_overflowVisible
= true;
877 m_overflowVisible
= false;
879 if (style
& wxAUI_TB_HORZ_LAYOUT
)
880 SetToolTextOrientation(wxAUI_TBTOOL_TEXT_RIGHT
);
882 SetToolTextOrientation(wxAUI_TBTOOL_TEXT_BOTTOM
);
885 long wxAuiToolBar
::GetWindowStyleFlag() const
890 void wxAuiToolBar
::SetArtProvider(wxAuiToolBarArt
* art
)
899 m_art
->SetTextOrientation(m_toolTextOrientation
);
903 wxAuiToolBarArt
* wxAuiToolBar
::GetArtProvider() const
911 wxAuiToolBarItem
* wxAuiToolBar
::AddTool(int tool_id
,
912 const wxString
& label
,
913 const wxBitmap
& bitmap
,
914 const wxString
& shortHelp_string
,
917 return AddTool(tool_id
,
928 wxAuiToolBarItem
* wxAuiToolBar
::AddTool(int tool_id
,
929 const wxString
& label
,
930 const wxBitmap
& bitmap
,
931 const wxBitmap
& disabledBitmap
,
933 const wxString
& shortHelpString
,
934 const wxString
& longHelpString
,
935 wxObject
* WXUNUSED(client_data
))
937 wxAuiToolBarItem item
;
938 item
.m_window
= NULL
;
939 item
.m_label
= label
;
940 item
.m_bitmap
= bitmap
;
941 item
.m_disabledBitmap
= disabledBitmap
;
942 item
.m_shortHelp
= shortHelpString
;
943 item
.m_longHelp
= longHelpString
;
944 item
.m_active
= true;
945 item
.m_dropDown
= false;
946 item
.m_spacerPixels
= 0;
947 item
.m_toolId
= tool_id
;
949 item
.m_proportion
= 0;
951 item
.m_sizerItem
= NULL
;
952 item
.m_minSize
= wxDefaultSize
;
954 item
.m_sticky
= false;
956 if (item
.m_toolId
== wxID_ANY
)
957 item
.m_toolId
= wxNewId();
959 if (!item
.m_disabledBitmap
.IsOk())
961 // no disabled bitmap specified, we need to make one
962 if (item
.m_bitmap
.IsOk())
964 item
.m_disabledBitmap
= item
.m_bitmap
.ConvertToDisabled();
968 return &m_items
.Last();
971 wxAuiToolBarItem
* wxAuiToolBar
::AddControl(wxControl
* control
,
972 const wxString
& label
)
974 wxAuiToolBarItem item
;
975 item
.m_window
= (wxWindow
*)control
;
976 item
.m_label
= label
;
977 item
.m_bitmap
= wxNullBitmap
;
978 item
.m_disabledBitmap
= wxNullBitmap
;
979 item
.m_active
= true;
980 item
.m_dropDown
= false;
981 item
.m_spacerPixels
= 0;
982 item
.m_toolId
= control
->GetId();
984 item
.m_proportion
= 0;
985 item
.m_kind
= wxITEM_CONTROL
;
986 item
.m_sizerItem
= NULL
;
987 item
.m_minSize
= control
->GetEffectiveMinSize();
989 item
.m_sticky
= false;
992 return &m_items
.Last();
995 wxAuiToolBarItem
* wxAuiToolBar
::AddLabel(int tool_id
,
996 const wxString
& label
,
999 wxSize min_size
= wxDefaultSize
;
1003 wxAuiToolBarItem item
;
1004 item
.m_window
= NULL
;
1005 item
.m_label
= label
;
1006 item
.m_bitmap
= wxNullBitmap
;
1007 item
.m_disabledBitmap
= wxNullBitmap
;
1008 item
.m_active
= true;
1009 item
.m_dropDown
= false;
1010 item
.m_spacerPixels
= 0;
1011 item
.m_toolId
= tool_id
;
1013 item
.m_proportion
= 0;
1014 item
.m_kind
= wxITEM_LABEL
;
1015 item
.m_sizerItem
= NULL
;
1016 item
.m_minSize
= min_size
;
1017 item
.m_userData
= 0;
1018 item
.m_sticky
= false;
1020 if (item
.m_toolId
== wxID_ANY
)
1021 item
.m_toolId
= wxNewId();
1024 return &m_items
.Last();
1027 wxAuiToolBarItem
* wxAuiToolBar
::AddSeparator()
1029 wxAuiToolBarItem item
;
1030 item
.m_window
= NULL
;
1031 item
.m_label
= wxEmptyString
;
1032 item
.m_bitmap
= wxNullBitmap
;
1033 item
.m_disabledBitmap
= wxNullBitmap
;
1034 item
.m_active
= true;
1035 item
.m_dropDown
= false;
1038 item
.m_proportion
= 0;
1039 item
.m_kind
= wxITEM_SEPARATOR
;
1040 item
.m_sizerItem
= NULL
;
1041 item
.m_minSize
= wxDefaultSize
;
1042 item
.m_userData
= 0;
1043 item
.m_sticky
= false;
1046 return &m_items
.Last();
1049 wxAuiToolBarItem
* wxAuiToolBar
::AddSpacer(int pixels
)
1051 wxAuiToolBarItem item
;
1052 item
.m_window
= NULL
;
1053 item
.m_label
= wxEmptyString
;
1054 item
.m_bitmap
= wxNullBitmap
;
1055 item
.m_disabledBitmap
= wxNullBitmap
;
1056 item
.m_active
= true;
1057 item
.m_dropDown
= false;
1058 item
.m_spacerPixels
= pixels
;
1061 item
.m_proportion
= 0;
1062 item
.m_kind
= wxITEM_SPACER
;
1063 item
.m_sizerItem
= NULL
;
1064 item
.m_minSize
= wxDefaultSize
;
1065 item
.m_userData
= 0;
1066 item
.m_sticky
= false;
1069 return &m_items
.Last();
1072 wxAuiToolBarItem
* wxAuiToolBar
::AddStretchSpacer(int proportion
)
1074 wxAuiToolBarItem item
;
1075 item
.m_window
= NULL
;
1076 item
.m_label
= wxEmptyString
;
1077 item
.m_bitmap
= wxNullBitmap
;
1078 item
.m_disabledBitmap
= wxNullBitmap
;
1079 item
.m_active
= true;
1080 item
.m_dropDown
= false;
1081 item
.m_spacerPixels
= 0;
1084 item
.m_proportion
= proportion
;
1085 item
.m_kind
= wxITEM_SPACER
;
1086 item
.m_sizerItem
= NULL
;
1087 item
.m_minSize
= wxDefaultSize
;
1088 item
.m_userData
= 0;
1089 item
.m_sticky
= false;
1092 return &m_items
.Last();
1095 void wxAuiToolBar
::Clear()
1098 m_sizerElementCount
= 0;
1101 bool wxAuiToolBar
::DeleteTool(int tool_id
)
1103 int idx
= GetToolIndex(tool_id
);
1104 if (idx
>= 0 && idx
< (int)m_items
.GetCount())
1106 m_items
.RemoveAt(idx
);
1114 bool wxAuiToolBar
::DeleteByIndex(int idx
)
1116 if (idx
>= 0 && idx
< (int)m_items
.GetCount())
1118 m_items
.RemoveAt(idx
);
1127 wxControl
* wxAuiToolBar
::FindControl(int id
)
1129 wxWindow
* wnd
= FindWindow(id
);
1130 return (wxControl
*)wnd
;
1133 wxAuiToolBarItem
* wxAuiToolBar
::FindTool(int tool_id
) const
1136 for (i
= 0, count
= m_items
.GetCount(); i
< count
; ++i
)
1138 wxAuiToolBarItem
& item
= m_items
.Item(i
);
1139 if (item
.m_toolId
== tool_id
)
1146 wxAuiToolBarItem
* wxAuiToolBar
::FindToolByPosition(wxCoord x
, wxCoord y
) const
1149 for (i
= 0, count
= m_items
.GetCount(); i
< count
; ++i
)
1151 wxAuiToolBarItem
& item
= m_items
.Item(i
);
1153 if (!item
.m_sizerItem
)
1156 wxRect rect
= item
.m_sizerItem
->GetRect();
1157 if (rect
.Contains(x
,y
))
1159 // if the item doesn't fit on the toolbar, return NULL
1160 if (!GetToolFitsByIndex(i
))
1170 wxAuiToolBarItem
* wxAuiToolBar
::FindToolByPositionWithPacking(wxCoord x
, wxCoord y
) const
1173 for (i
= 0, count
= m_items
.GetCount(); i
< count
; ++i
)
1175 wxAuiToolBarItem
& item
= m_items
.Item(i
);
1177 if (!item
.m_sizerItem
)
1180 wxRect rect
= item
.m_sizerItem
->GetRect();
1182 // apply tool packing
1184 rect
.width
+= m_toolPacking
;
1186 if (rect
.Contains(x
,y
))
1188 // if the item doesn't fit on the toolbar, return NULL
1189 if (!GetToolFitsByIndex(i
))
1199 wxAuiToolBarItem
* wxAuiToolBar
::FindToolByIndex(int idx
) const
1204 if (idx
>= (int)m_items
.size())
1207 return &(m_items
[idx
]);
1210 void wxAuiToolBar
::SetToolBitmapSize(const wxSize
& WXUNUSED(size
))
1212 // TODO: wxToolBar compatibility
1215 wxSize wxAuiToolBar
::GetToolBitmapSize() const
1217 // TODO: wxToolBar compatibility
1218 return wxSize(16,15);
1221 void wxAuiToolBar
::SetToolProportion(int tool_id
, int proportion
)
1223 wxAuiToolBarItem
* item
= FindTool(tool_id
);
1227 item
->m_proportion
= proportion
;
1230 int wxAuiToolBar
::GetToolProportion(int tool_id
) const
1232 wxAuiToolBarItem
* item
= FindTool(tool_id
);
1236 return item
->m_proportion
;
1239 void wxAuiToolBar
::SetToolSeparation(int separation
)
1242 m_art
->SetElementSize(wxAUI_TBART_SEPARATOR_SIZE
, separation
);
1245 int wxAuiToolBar
::GetToolSeparation() const
1248 return m_art
->GetElementSize(wxAUI_TBART_SEPARATOR_SIZE
);
1254 void wxAuiToolBar
::SetToolDropDown(int tool_id
, bool dropdown
)
1256 wxAuiToolBarItem
* item
= FindTool(tool_id
);
1260 item
->m_dropDown
= dropdown
;
1263 bool wxAuiToolBar
::GetToolDropDown(int tool_id
) const
1265 wxAuiToolBarItem
* item
= FindTool(tool_id
);
1269 return item
->m_dropDown
;
1272 void wxAuiToolBar
::SetToolSticky(int tool_id
, bool sticky
)
1274 // ignore separators
1278 wxAuiToolBarItem
* item
= FindTool(tool_id
);
1282 if (item
->m_sticky
== sticky
)
1285 item
->m_sticky
= sticky
;
1291 bool wxAuiToolBar
::GetToolSticky(int tool_id
) const
1293 wxAuiToolBarItem
* item
= FindTool(tool_id
);
1297 return item
->m_sticky
;
1303 void wxAuiToolBar
::SetToolBorderPadding(int padding
)
1305 m_toolBorderPadding
= padding
;
1308 int wxAuiToolBar
::GetToolBorderPadding() const
1310 return m_toolBorderPadding
;
1313 void wxAuiToolBar
::SetToolTextOrientation(int orientation
)
1315 m_toolTextOrientation
= orientation
;
1319 m_art
->SetTextOrientation(orientation
);
1323 int wxAuiToolBar
::GetToolTextOrientation() const
1325 return m_toolTextOrientation
;
1328 void wxAuiToolBar
::SetToolPacking(int packing
)
1330 m_toolPacking
= packing
;
1333 int wxAuiToolBar
::GetToolPacking() const
1335 return m_toolPacking
;
1339 void wxAuiToolBar
::SetOrientation(int orientation
)
1341 wxCHECK_RET(orientation
== wxHORIZONTAL
||
1342 orientation
== wxVERTICAL
,
1343 "invalid orientation value");
1344 if (orientation
!= m_orientation
)
1346 m_orientation
= wxOrientation(orientation
);
1351 void wxAuiToolBar
::SetMargins(int left
, int right
, int top
, int bottom
)
1354 m_leftPadding
= left
;
1356 m_rightPadding
= right
;
1360 m_bottomPadding
= bottom
;
1363 bool wxAuiToolBar
::GetGripperVisible() const
1365 return m_gripperVisible
;
1368 void wxAuiToolBar
::SetGripperVisible(bool visible
)
1370 m_gripperVisible
= visible
;
1372 m_style
|= wxAUI_TB_GRIPPER
;
1374 m_style
&= ~wxAUI_TB_GRIPPER
;
1380 bool wxAuiToolBar
::GetOverflowVisible() const
1382 return m_overflowVisible
;
1385 void wxAuiToolBar
::SetOverflowVisible(bool visible
)
1387 m_overflowVisible
= visible
;
1389 m_style
|= wxAUI_TB_OVERFLOW
;
1391 m_style
&= ~wxAUI_TB_OVERFLOW
;
1395 bool wxAuiToolBar
::SetFont(const wxFont
& font
)
1397 bool res
= wxWindow
::SetFont(font
);
1401 m_art
->SetFont(font
);
1408 void wxAuiToolBar
::SetHoverItem(wxAuiToolBarItem
* pitem
)
1410 wxAuiToolBarItem
* former_hover
= NULL
;
1413 for (i
= 0, count
= m_items
.GetCount(); i
< count
; ++i
)
1415 wxAuiToolBarItem
& item
= m_items
.Item(i
);
1416 if (item
.m_state
& wxAUI_BUTTON_STATE_HOVER
)
1417 former_hover
= &item
;
1418 item
.m_state
&= ~wxAUI_BUTTON_STATE_HOVER
;
1423 pitem
->m_state
|= wxAUI_BUTTON_STATE_HOVER
;
1426 if (former_hover
!= pitem
)
1433 void wxAuiToolBar
::SetPressedItem(wxAuiToolBarItem
* pitem
)
1435 wxAuiToolBarItem
* former_item
= NULL
;
1438 for (i
= 0, count
= m_items
.GetCount(); i
< count
; ++i
)
1440 wxAuiToolBarItem
& item
= m_items
.Item(i
);
1441 if (item
.m_state
& wxAUI_BUTTON_STATE_PRESSED
)
1442 former_item
= &item
;
1443 item
.m_state
&= ~wxAUI_BUTTON_STATE_PRESSED
;
1448 pitem
->m_state
&= ~wxAUI_BUTTON_STATE_HOVER
;
1449 pitem
->m_state
|= wxAUI_BUTTON_STATE_PRESSED
;
1452 if (former_item
!= pitem
)
1459 void wxAuiToolBar
::RefreshOverflowState()
1461 if (!m_overflowSizerItem
)
1463 m_overflowState
= 0;
1467 int overflow_state
= 0;
1469 wxRect overflow_rect
= GetOverflowRect();
1472 // find out the mouse's current position
1473 wxPoint pt
= ::wxGetMousePosition();
1474 pt
= this->ScreenToClient(pt
);
1476 // find out if the mouse cursor is inside the dropdown rectangle
1477 if (overflow_rect
.Contains(pt
.x
, pt
.y
))
1479 if (::wxGetMouseState().LeftIsDown())
1480 overflow_state
= wxAUI_BUTTON_STATE_PRESSED
;
1482 overflow_state
= wxAUI_BUTTON_STATE_HOVER
;
1485 if (overflow_state
!= m_overflowState
)
1487 m_overflowState
= overflow_state
;
1492 m_overflowState
= overflow_state
;
1495 void wxAuiToolBar
::ToggleTool(int tool_id
, bool state
)
1497 wxAuiToolBarItem
* tool
= FindTool(tool_id
);
1499 if (tool
&& (tool
->m_kind
== wxITEM_CHECK
|| tool
->m_kind
== wxITEM_RADIO
))
1501 if (tool
->m_kind
== wxITEM_RADIO
)
1504 idx
= GetToolIndex(tool_id
);
1505 count
= (int)m_items
.GetCount();
1507 if (idx
>= 0 && idx
< count
)
1509 for (i
= idx
+ 1; i
< count
; ++i
)
1511 if (m_items
[i
].m_kind
!= wxITEM_RADIO
)
1513 m_items
[i
].m_state
&= ~wxAUI_BUTTON_STATE_CHECKED
;
1515 for (i
= idx
- 1; i
>= 0; i
--)
1517 if (m_items
[i
].m_kind
!= wxITEM_RADIO
)
1519 m_items
[i
].m_state
&= ~wxAUI_BUTTON_STATE_CHECKED
;
1523 tool
->m_state
|= wxAUI_BUTTON_STATE_CHECKED
;
1525 else if (tool
->m_kind
== wxITEM_CHECK
)
1528 tool
->m_state
|= wxAUI_BUTTON_STATE_CHECKED
;
1530 tool
->m_state
&= ~wxAUI_BUTTON_STATE_CHECKED
;
1535 bool wxAuiToolBar
::GetToolToggled(int tool_id
) const
1537 wxAuiToolBarItem
* tool
= FindTool(tool_id
);
1541 if ( (tool
->m_kind
!= wxITEM_CHECK
) && (tool
->m_kind
!= wxITEM_RADIO
) )
1544 return (tool
->m_state
& wxAUI_BUTTON_STATE_CHECKED
) ?
true : false;
1550 void wxAuiToolBar
::EnableTool(int tool_id
, bool state
)
1552 wxAuiToolBarItem
* tool
= FindTool(tool_id
);
1557 tool
->m_state
&= ~wxAUI_BUTTON_STATE_DISABLED
;
1559 tool
->m_state
|= wxAUI_BUTTON_STATE_DISABLED
;
1563 bool wxAuiToolBar
::GetToolEnabled(int tool_id
) const
1565 wxAuiToolBarItem
* tool
= FindTool(tool_id
);
1568 return (tool
->m_state
& wxAUI_BUTTON_STATE_DISABLED
) ?
false : true;
1573 wxString wxAuiToolBar
::GetToolLabel(int tool_id
) const
1575 wxAuiToolBarItem
* tool
= FindTool(tool_id
);
1576 wxASSERT_MSG(tool
, wxT("can't find tool in toolbar item array"));
1578 return wxEmptyString
;
1580 return tool
->m_label
;
1583 void wxAuiToolBar
::SetToolLabel(int tool_id
, const wxString
& label
)
1585 wxAuiToolBarItem
* tool
= FindTool(tool_id
);
1588 tool
->m_label
= label
;
1592 wxBitmap wxAuiToolBar
::GetToolBitmap(int tool_id
) const
1594 wxAuiToolBarItem
* tool
= FindTool(tool_id
);
1595 wxASSERT_MSG(tool
, wxT("can't find tool in toolbar item array"));
1597 return wxNullBitmap
;
1599 return tool
->m_bitmap
;
1602 void wxAuiToolBar
::SetToolBitmap(int tool_id
, const wxBitmap
& bitmap
)
1604 wxAuiToolBarItem
* tool
= FindTool(tool_id
);
1607 tool
->m_bitmap
= bitmap
;
1611 wxString wxAuiToolBar
::GetToolShortHelp(int tool_id
) const
1613 wxAuiToolBarItem
* tool
= FindTool(tool_id
);
1614 wxASSERT_MSG(tool
, wxT("can't find tool in toolbar item array"));
1616 return wxEmptyString
;
1618 return tool
->m_shortHelp
;
1621 void wxAuiToolBar
::SetToolShortHelp(int tool_id
, const wxString
& help_string
)
1623 wxAuiToolBarItem
* tool
= FindTool(tool_id
);
1626 tool
->m_shortHelp
= help_string
;
1630 wxString wxAuiToolBar
::GetToolLongHelp(int tool_id
) const
1632 wxAuiToolBarItem
* tool
= FindTool(tool_id
);
1633 wxASSERT_MSG(tool
, wxT("can't find tool in toolbar item array"));
1635 return wxEmptyString
;
1637 return tool
->m_longHelp
;
1640 void wxAuiToolBar
::SetToolLongHelp(int tool_id
, const wxString
& help_string
)
1642 wxAuiToolBarItem
* tool
= FindTool(tool_id
);
1645 tool
->m_longHelp
= help_string
;
1649 void wxAuiToolBar
::SetCustomOverflowItems(const wxAuiToolBarItemArray
& prepend
,
1650 const wxAuiToolBarItemArray
& append
)
1652 m_customOverflowPrepend
= prepend
;
1653 m_customOverflowAppend
= append
;
1656 // get size of hint rectangle for a particular dock location
1657 wxSize wxAuiToolBar
::GetHintSize(int dock_direction
) const
1659 switch (dock_direction
)
1661 case wxAUI_DOCK_TOP
:
1662 case wxAUI_DOCK_BOTTOM
:
1663 return m_horzHintSize
;
1664 case wxAUI_DOCK_RIGHT
:
1665 case wxAUI_DOCK_LEFT
:
1666 return m_vertHintSize
;
1668 wxCHECK_MSG(false, wxDefaultSize
, "invalid dock location value");
1672 bool wxAuiToolBar
::IsPaneValid(const wxAuiPaneInfo
& pane
) const
1674 return IsPaneValid(m_style
, pane
);
1677 bool wxAuiToolBar
::IsPaneValid(long style
, const wxAuiPaneInfo
& pane
)
1679 if (style
& wxAUI_TB_HORIZONTAL
)
1681 if (pane
.IsLeftDockable() || pane
.IsRightDockable())
1686 else if (style
& wxAUI_TB_VERTICAL
)
1688 if (pane
.IsTopDockable() || pane
.IsBottomDockable())
1696 bool wxAuiToolBar
::IsPaneValid(long style
) const
1698 wxAuiManager
* manager
= wxAuiManager
::GetManager(const_cast<wxAuiToolBar
*>(this));
1701 return IsPaneValid(style
, manager
->GetPane(const_cast<wxAuiToolBar
*>(this)));
1706 void wxAuiToolBar
::SetArtFlags() const
1708 unsigned int artflags
= m_style
& ~wxAUI_ORIENTATION_MASK
;
1709 if (m_orientation
== wxVERTICAL
)
1711 artflags
|= wxAUI_TB_VERTICAL
;
1713 m_art
->SetFlags(artflags
);
1716 size_t wxAuiToolBar
::GetToolCount() const
1718 return m_items
.size();
1721 int wxAuiToolBar
::GetToolIndex(int tool_id
) const
1723 // this will prevent us from returning the index of the
1724 // first separator in the toolbar since its id is equal to -1
1728 size_t i
, count
= m_items
.GetCount();
1729 for (i
= 0; i
< count
; ++i
)
1731 wxAuiToolBarItem
& item
= m_items
.Item(i
);
1732 if (item
.m_toolId
== tool_id
)
1739 bool wxAuiToolBar
::GetToolFitsByIndex(int tool_idx
) const
1741 if (tool_idx
< 0 || tool_idx
>= (int)m_items
.GetCount())
1744 if (!m_items
[tool_idx
].m_sizerItem
)
1748 GetClientSize(&cli_w
, &cli_h
);
1750 wxRect rect
= m_items
[tool_idx
].m_sizerItem
->GetRect();
1752 if (m_orientation
== wxVERTICAL
)
1754 // take the dropdown size into account
1755 if (m_overflowVisible
)
1756 cli_h
-= m_overflowSizerItem
->GetSize().y
;
1758 if (rect
.y
+rect
.height
< cli_h
)
1763 // take the dropdown size into account
1764 if (m_overflowVisible
)
1765 cli_w
-= m_overflowSizerItem
->GetSize().x
;
1767 if (rect
.x
+rect
.width
< cli_w
)
1775 bool wxAuiToolBar
::GetToolFits(int tool_id
) const
1777 return GetToolFitsByIndex(GetToolIndex(tool_id
));
1780 wxRect wxAuiToolBar
::GetToolRect(int tool_id
) const
1782 wxAuiToolBarItem
* tool
= FindTool(tool_id
);
1783 if (tool
&& tool
->m_sizerItem
)
1785 return tool
->m_sizerItem
->GetRect();
1791 bool wxAuiToolBar
::GetToolBarFits() const
1793 if (m_items
.GetCount() == 0)
1795 // empty toolbar always 'fits'
1799 // entire toolbar content fits if the last tool fits
1800 return GetToolFitsByIndex(m_items
.GetCount() - 1);
1803 bool wxAuiToolBar
::Realize()
1805 wxClientDC
dc(this);
1809 // calculate hint sizes for both horizontal and vertical
1810 // in the order that leaves toolbar in correct final state
1811 bool retval
= false;
1812 if (m_orientation
== wxHORIZONTAL
)
1814 if (RealizeHelper(dc
, false))
1816 m_vertHintSize
= GetSize();
1817 if (RealizeHelper(dc
, true))
1819 m_horzHintSize
= GetSize();
1826 if (RealizeHelper(dc
, true))
1828 m_horzHintSize
= GetSize();
1829 if (RealizeHelper(dc
, false))
1831 m_vertHintSize
= GetSize();
1841 bool wxAuiToolBar
::RealizeHelper(wxClientDC
& dc
, bool horizontal
)
1843 // create the new sizer to add toolbar elements to
1844 wxBoxSizer
* sizer
= new wxBoxSizer(horizontal ? wxHORIZONTAL
: wxVERTICAL
);
1847 int separatorSize
= m_art
->GetElementSize(wxAUI_TBART_SEPARATOR_SIZE
);
1848 int gripperSize
= m_art
->GetElementSize(wxAUI_TBART_GRIPPER_SIZE
);
1849 if (gripperSize
> 0 && m_gripperVisible
)
1852 m_gripperSizerItem
= sizer
->Add(gripperSize
, 1, 0, wxEXPAND
);
1854 m_gripperSizerItem
= sizer
->Add(1, gripperSize
, 0, wxEXPAND
);
1858 m_gripperSizerItem
= NULL
;
1861 // add "left" padding
1862 if (m_leftPadding
> 0)
1865 sizer
->Add(m_leftPadding
, 1);
1867 sizer
->Add(1, m_leftPadding
);
1871 for (i
= 0, count
= m_items
.GetCount(); i
< count
; ++i
)
1873 wxAuiToolBarItem
& item
= m_items
.Item(i
);
1874 wxSizerItem
* m_sizerItem
= NULL
;
1876 switch (item
.m_kind
)
1880 wxSize size
= m_art
->GetLabelSize(dc
, this, item
);
1881 m_sizerItem
= sizer
->Add(size
.x
+ (m_toolBorderPadding
*2),
1882 size
.y
+ (m_toolBorderPadding
*2),
1887 sizer
->AddSpacer(m_toolPacking
);
1897 wxSize size
= m_art
->GetToolSize(dc
, this, item
);
1898 m_sizerItem
= sizer
->Add(size
.x
+ (m_toolBorderPadding
*2),
1899 size
.y
+ (m_toolBorderPadding
*2),
1905 sizer
->AddSpacer(m_toolPacking
);
1911 case wxITEM_SEPARATOR
:
1914 m_sizerItem
= sizer
->Add(separatorSize
, 1, 0, wxEXPAND
);
1916 m_sizerItem
= sizer
->Add(1, separatorSize
, 0, wxEXPAND
);
1921 sizer
->AddSpacer(m_toolPacking
);
1928 if (item
.m_proportion
> 0)
1929 m_sizerItem
= sizer
->AddStretchSpacer(item
.m_proportion
);
1931 m_sizerItem
= sizer
->Add(item
.m_spacerPixels
, 1);
1934 case wxITEM_CONTROL
:
1936 //m_sizerItem = sizer->Add(item.m_window, item.m_proportion, wxEXPAND);
1937 wxSizerItem
* ctrl_m_sizerItem
;
1939 wxBoxSizer
* vert_sizer
= new wxBoxSizer(wxVERTICAL
);
1940 vert_sizer
->AddStretchSpacer(1);
1941 ctrl_m_sizerItem
= vert_sizer
->Add(item
.m_window
, 0, wxEXPAND
);
1942 vert_sizer
->AddStretchSpacer(1);
1943 if ( (m_style
& wxAUI_TB_TEXT
) &&
1944 m_toolTextOrientation
== wxAUI_TBTOOL_TEXT_BOTTOM
&&
1945 !item
.GetLabel().empty() )
1947 wxSize s
= GetLabelSize(item
.GetLabel());
1948 vert_sizer
->Add(1, s
.y
);
1952 m_sizerItem
= sizer
->Add(vert_sizer
, item
.m_proportion
, wxEXPAND
);
1954 wxSize min_size
= item
.m_minSize
;
1957 // proportional items will disappear from the toolbar if
1958 // their min width is not set to something really small
1959 if (item
.m_proportion
!= 0)
1964 if (min_size
.IsFullySpecified())
1966 m_sizerItem
->SetMinSize(min_size
);
1967 ctrl_m_sizerItem
->SetMinSize(min_size
);
1973 sizer
->AddSpacer(m_toolPacking
);
1978 item
.m_sizerItem
= m_sizerItem
;
1981 // add "right" padding
1982 if (m_rightPadding
> 0)
1985 sizer
->Add(m_rightPadding
, 1);
1987 sizer
->Add(1, m_rightPadding
);
1990 // add drop down area
1991 m_overflowSizerItem
= NULL
;
1993 if (m_style
& wxAUI_TB_OVERFLOW
)
1995 int overflow_size
= m_art
->GetElementSize(wxAUI_TBART_OVERFLOW_SIZE
);
1996 if (overflow_size
> 0 && m_overflowVisible
)
1999 m_overflowSizerItem
= sizer
->Add(overflow_size
, 1, 0, wxEXPAND
);
2001 m_overflowSizerItem
= sizer
->Add(1, overflow_size
, 0, wxEXPAND
);
2005 m_overflowSizerItem
= NULL
;
2010 // the outside sizer helps us apply the "top" and "bottom" padding
2011 wxBoxSizer
* outside_sizer
= new wxBoxSizer(horizontal ? wxVERTICAL
: wxHORIZONTAL
);
2013 // add "top" padding
2014 if (m_topPadding
> 0)
2017 outside_sizer
->Add(1, m_topPadding
);
2019 outside_sizer
->Add(m_topPadding
, 1);
2022 // add the sizer that contains all of the toolbar elements
2023 outside_sizer
->Add(sizer
, 1, wxEXPAND
);
2025 // add "bottom" padding
2026 if (m_bottomPadding
> 0)
2029 outside_sizer
->Add(1, m_bottomPadding
);
2031 outside_sizer
->Add(m_bottomPadding
, 1);
2034 delete m_sizer
; // remove old sizer
2035 m_sizer
= outside_sizer
;
2037 // calculate the rock-bottom minimum size
2038 for (i
= 0, count
= m_items
.GetCount(); i
< count
; ++i
)
2040 wxAuiToolBarItem
& item
= m_items
.Item(i
);
2041 if (item
.m_sizerItem
&& item
.m_proportion
> 0 && item
.m_minSize
.IsFullySpecified())
2042 item
.m_sizerItem
->SetMinSize(0,0);
2045 m_absoluteMinSize
= m_sizer
->GetMinSize();
2047 // reset the min sizes to what they were
2048 for (i
= 0, count
= m_items
.GetCount(); i
< count
; ++i
)
2050 wxAuiToolBarItem
& item
= m_items
.Item(i
);
2051 if (item
.m_sizerItem
&& item
.m_proportion
> 0 && item
.m_minSize
.IsFullySpecified())
2052 item
.m_sizerItem
->SetMinSize(item
.m_minSize
);
2056 wxSize size
= m_sizer
->GetMinSize();
2057 m_minWidth
= size
.x
;
2058 m_minHeight
= size
.y
;
2060 if ((m_style
& wxAUI_TB_NO_AUTORESIZE
) == 0)
2062 wxSize curSize
= GetClientSize();
2063 wxSize new_size
= GetMinSize();
2064 if (new_size
!= curSize
)
2066 SetClientSize(new_size
);
2070 m_sizer
->SetDimension(0, 0, curSize
.x
, curSize
.y
);
2075 wxSize curSize
= GetClientSize();
2076 m_sizer
->SetDimension(0, 0, curSize
.x
, curSize
.y
);
2082 int wxAuiToolBar
::GetOverflowState() const
2084 return m_overflowState
;
2087 wxRect wxAuiToolBar
::GetOverflowRect() const
2089 wxRect
cli_rect(wxPoint(0,0), GetClientSize());
2090 wxRect overflow_rect
= m_overflowSizerItem
->GetRect();
2091 int overflow_size
= m_art
->GetElementSize(wxAUI_TBART_OVERFLOW_SIZE
);
2093 if (m_orientation
== wxVERTICAL
)
2095 overflow_rect
.y
= cli_rect
.height
- overflow_size
;
2096 overflow_rect
.x
= 0;
2097 overflow_rect
.width
= cli_rect
.width
;
2098 overflow_rect
.height
= overflow_size
;
2102 overflow_rect
.x
= cli_rect
.width
- overflow_size
;
2103 overflow_rect
.y
= 0;
2104 overflow_rect
.width
= overflow_size
;
2105 overflow_rect
.height
= cli_rect
.height
;
2108 return overflow_rect
;
2111 wxSize wxAuiToolBar
::GetLabelSize(const wxString
& label
)
2113 wxClientDC
dc(this);
2116 int textWidth
= 0, textHeight
= 0;
2120 // get the text height
2121 dc
.GetTextExtent(wxT("ABCDHgj"), &tx
, &textHeight
);
2123 // get the text width
2124 dc
.GetTextExtent(label
, &textWidth
, &ty
);
2126 return wxSize(textWidth
, textHeight
);
2130 void wxAuiToolBar
::DoIdleUpdate()
2132 wxEvtHandler
* handler
= GetEventHandler();
2134 bool need_refresh
= false;
2137 for (i
= 0, count
= m_items
.GetCount(); i
< count
; ++i
)
2139 wxAuiToolBarItem
& item
= m_items
.Item(i
);
2141 if (item
.m_toolId
== -1)
2144 wxUpdateUIEvent
evt(item
.m_toolId
);
2145 evt
.SetEventObject(this);
2147 if (handler
->ProcessEvent(evt
))
2149 if (evt
.GetSetEnabled())
2153 is_enabled
= item
.m_window
->IsEnabled();
2155 is_enabled
= (item
.m_state
& wxAUI_BUTTON_STATE_DISABLED
) ?
false : true;
2157 bool new_enabled
= evt
.GetEnabled();
2158 if (new_enabled
!= is_enabled
)
2162 item
.m_window
->Enable(new_enabled
);
2167 item
.m_state
&= ~wxAUI_BUTTON_STATE_DISABLED
;
2169 item
.m_state
|= wxAUI_BUTTON_STATE_DISABLED
;
2171 need_refresh
= true;
2175 if (evt
.GetSetChecked())
2177 // make sure we aren't checking an item that can't be
2178 if (item
.m_kind
!= wxITEM_CHECK
&& item
.m_kind
!= wxITEM_RADIO
)
2181 bool is_checked
= (item
.m_state
& wxAUI_BUTTON_STATE_CHECKED
) ?
true : false;
2182 bool new_checked
= evt
.GetChecked();
2184 if (new_checked
!= is_checked
)
2187 item
.m_state
|= wxAUI_BUTTON_STATE_CHECKED
;
2189 item
.m_state
&= ~wxAUI_BUTTON_STATE_CHECKED
;
2191 need_refresh
= true;
2206 void wxAuiToolBar
::OnSize(wxSizeEvent
& WXUNUSED(evt
))
2209 GetClientSize(&x
, &y
);
2211 if (((x
>= y
) && m_absoluteMinSize
.x
> x
) ||
2212 ((y
> x
) && m_absoluteMinSize
.y
> y
))
2214 // hide all flexible items
2216 for (i
= 0, count
= m_items
.GetCount(); i
< count
; ++i
)
2218 wxAuiToolBarItem
& item
= m_items
.Item(i
);
2219 if (item
.m_sizerItem
&& item
.m_proportion
> 0 && item
.m_sizerItem
->IsShown())
2221 item
.m_sizerItem
->Show(false);
2222 item
.m_sizerItem
->SetProportion(0);
2228 // show all flexible items
2230 for (i
= 0, count
= m_items
.GetCount(); i
< count
; ++i
)
2232 wxAuiToolBarItem
& item
= m_items
.Item(i
);
2233 if (item
.m_sizerItem
&& item
.m_proportion
> 0 && !item
.m_sizerItem
->IsShown())
2235 item
.m_sizerItem
->Show(true);
2236 item
.m_sizerItem
->SetProportion(item
.m_proportion
);
2241 m_sizer
->SetDimension(0, 0, x
, y
);
2246 // idle events aren't sent while user is resizing frame (why?),
2247 // but resizing toolbar here causes havoc,
2248 // so force idle handler to run after size handling complete
2249 QueueEvent(new wxIdleEvent
);
2254 void wxAuiToolBar
::DoSetSize(int x
,
2260 wxSize parent_size
= GetParent()->GetClientSize();
2261 if (x
+ width
> parent_size
.x
)
2262 width
= wxMax(0, parent_size
.x
- x
);
2263 if (y
+ height
> parent_size
.y
)
2264 height
= wxMax(0, parent_size
.y
- y
);
2266 wxWindow
::DoSetSize(x
, y
, width
, height
, sizeFlags
);
2270 void wxAuiToolBar
::OnIdle(wxIdleEvent
& evt
)
2272 // if orientation doesn't match dock, fix it
2273 wxAuiManager
* manager
= wxAuiManager
::GetManager(this);
2276 wxAuiPaneInfo
& pane
= manager
->GetPane(this);
2277 // pane state member is public, so it might have been changed
2278 // without going through wxPaneInfo::SetFlag() check
2279 bool ok
= pane
.IsOk();
2280 wxCHECK2_MSG(!ok
|| IsPaneValid(m_style
, pane
), ok
= false,
2281 "window settings and pane settings are incompatible");
2284 wxOrientation newOrientation
= m_orientation
;
2285 if (pane
.IsDocked())
2287 switch (pane
.dock_direction
)
2289 case wxAUI_DOCK_TOP
:
2290 case wxAUI_DOCK_BOTTOM
:
2291 newOrientation
= wxHORIZONTAL
;
2293 case wxAUI_DOCK_LEFT
:
2294 case wxAUI_DOCK_RIGHT
:
2295 newOrientation
= wxVERTICAL
;
2298 wxFAIL_MSG("invalid dock location value");
2301 else if (pane
.IsResizable() &&
2302 GetOrientation(m_style
) == wxBOTH
)
2304 // changing orientation in OnSize causes havoc
2306 GetClientSize(&x
, &y
);
2310 newOrientation
= wxHORIZONTAL
;
2314 newOrientation
= wxVERTICAL
;
2317 if (newOrientation
!= m_orientation
)
2319 SetOrientation(newOrientation
);
2321 if (newOrientation
== wxHORIZONTAL
)
2323 pane
.best_size
= GetHintSize(wxAUI_DOCK_TOP
);
2327 pane
.best_size
= GetHintSize(wxAUI_DOCK_LEFT
);
2329 if (pane
.IsDocked())
2331 pane
.floating_size
= wxDefaultSize
;
2335 SetSize(GetParent()->GetClientSize());
2346 void wxAuiToolBar
::OnPaint(wxPaintEvent
& WXUNUSED(evt
))
2348 wxAutoBufferedPaintDC
dc(this);
2349 wxRect
cli_rect(wxPoint(0,0), GetClientSize());
2352 bool horizontal
= m_orientation
== wxHORIZONTAL
;
2355 m_art
->DrawBackground(dc
, this, cli_rect
);
2357 int gripperSize
= m_art
->GetElementSize(wxAUI_TBART_GRIPPER_SIZE
);
2358 int dropdown_size
= m_art
->GetElementSize(wxAUI_TBART_OVERFLOW_SIZE
);
2360 // paint the gripper
2361 if (gripperSize
> 0 && m_gripperSizerItem
)
2363 wxRect gripper_rect
= m_gripperSizerItem
->GetRect();
2365 gripper_rect
.width
= gripperSize
;
2367 gripper_rect
.height
= gripperSize
;
2368 m_art
->DrawGripper(dc
, this, gripper_rect
);
2371 // calculated how far we can draw items
2374 last_extent
= cli_rect
.width
;
2376 last_extent
= cli_rect
.height
;
2377 if (m_overflowVisible
)
2378 last_extent
-= dropdown_size
;
2380 // paint each individual tool
2381 size_t i
, count
= m_items
.GetCount();
2382 for (i
= 0; i
< count
; ++i
)
2384 wxAuiToolBarItem
& item
= m_items
.Item(i
);
2386 if (!item
.m_sizerItem
)
2389 wxRect item_rect
= item
.m_sizerItem
->GetRect();
2392 if ((horizontal
&& item_rect
.x
+ item_rect
.width
>= last_extent
) ||
2393 (!horizontal
&& item_rect
.y
+ item_rect
.height
>= last_extent
))
2398 if (item
.m_kind
== wxITEM_SEPARATOR
)
2401 m_art
->DrawSeparator(dc
, this, item_rect
);
2403 else if (item
.m_kind
== wxITEM_LABEL
)
2405 // draw a text label only
2406 m_art
->DrawLabel(dc
, this, item
, item_rect
);
2408 else if (item
.m_kind
== wxITEM_NORMAL
)
2410 // draw a regular button or dropdown button
2411 if (!item
.m_dropDown
)
2412 m_art
->DrawButton(dc
, this, item
, item_rect
);
2414 m_art
->DrawDropDownButton(dc
, this, item
, item_rect
);
2416 else if (item
.m_kind
== wxITEM_CHECK
)
2418 // draw either a regular or dropdown toggle button
2419 if (!item
.m_dropDown
)
2420 m_art
->DrawButton(dc
, this, item
, item_rect
);
2422 m_art
->DrawDropDownButton(dc
, this, item
, item_rect
);
2424 else if (item
.m_kind
== wxITEM_RADIO
)
2426 // draw a toggle button
2427 m_art
->DrawButton(dc
, this, item
, item_rect
);
2429 else if (item
.m_kind
== wxITEM_CONTROL
)
2431 // draw the control's label
2432 m_art
->DrawControlLabel(dc
, this, item
, item_rect
);
2435 // fire a signal to see if the item wants to be custom-rendered
2436 OnCustomRender(dc
, item
, item_rect
);
2439 // paint the overflow button
2440 if (dropdown_size
> 0 && m_overflowSizerItem
)
2442 wxRect dropDownRect
= GetOverflowRect();
2443 m_art
->DrawOverflowButton(dc
, this, dropDownRect
, m_overflowState
);
2447 void wxAuiToolBar
::OnEraseBackground(wxEraseEvent
& WXUNUSED(evt
))
2452 void wxAuiToolBar
::OnLeftDown(wxMouseEvent
& evt
)
2454 wxRect
cli_rect(wxPoint(0,0), GetClientSize());
2456 if (m_gripperSizerItem
)
2458 wxRect gripper_rect
= m_gripperSizerItem
->GetRect();
2459 if (gripper_rect
.Contains(evt
.GetX(), evt
.GetY()))
2462 wxAuiManager
* manager
= wxAuiManager
::GetManager(this);
2466 int x_drag_offset
= evt
.GetX() - gripper_rect
.GetX();
2467 int y_drag_offset
= evt
.GetY() - gripper_rect
.GetY();
2469 // gripper was clicked
2470 manager
->StartPaneDrag(this, wxPoint(x_drag_offset
, y_drag_offset
));
2475 if (m_overflowSizerItem
)
2477 wxRect overflow_rect
= GetOverflowRect();
2480 m_overflowVisible
&&
2481 overflow_rect
.Contains(evt
.m_x
, evt
.m_y
))
2483 wxAuiToolBarEvent
e(wxEVT_COMMAND_AUITOOLBAR_OVERFLOW_CLICK
, -1);
2484 e
.SetEventObject(this);
2486 e
.SetClickPoint(wxPoint(evt
.GetX(), evt
.GetY()));
2487 bool processed
= GetEventHandler()->ProcessEvent(e
);
2496 wxAuiToolBarItemArray overflow_items
;
2499 // add custom overflow prepend items, if any
2500 count
= m_customOverflowPrepend
.GetCount();
2501 for (i
= 0; i
< count
; ++i
)
2502 overflow_items
.Add(m_customOverflowPrepend
[i
]);
2504 // only show items that don't fit in the dropdown
2505 count
= m_items
.GetCount();
2506 for (i
= 0; i
< count
; ++i
)
2508 if (!GetToolFitsByIndex(i
))
2509 overflow_items
.Add(m_items
[i
]);
2512 // add custom overflow append items, if any
2513 count
= m_customOverflowAppend
.GetCount();
2514 for (i
= 0; i
< count
; ++i
)
2515 overflow_items
.Add(m_customOverflowAppend
[i
]);
2517 int res
= m_art
->ShowDropDown(this, overflow_items
);
2518 m_overflowState
= 0;
2522 wxCommandEvent
e(wxEVT_COMMAND_MENU_SELECTED
, res
);
2523 e
.SetEventObject(this);
2524 GetParent()->GetEventHandler()->ProcessEvent(e
);
2533 m_actionPos
= wxPoint(evt
.GetX(), evt
.GetY());
2534 m_actionItem
= FindToolByPosition(evt
.GetX(), evt
.GetY());
2538 if (m_actionItem
->m_state
& wxAUI_BUTTON_STATE_DISABLED
)
2540 m_actionPos
= wxPoint(-1,-1);
2541 m_actionItem
= NULL
;
2547 // fire the tool dropdown event
2548 wxAuiToolBarEvent
e(wxEVT_COMMAND_AUITOOLBAR_TOOL_DROPDOWN
, m_actionItem
->m_toolId
);
2549 e
.SetEventObject(this);
2550 e
.SetToolId(m_actionItem
->m_toolId
);
2552 int mouse_x
= evt
.GetX();
2553 wxRect rect
= m_actionItem
->m_sizerItem
->GetRect();
2554 const bool dropDownHit
= m_actionItem
->m_dropDown
&&
2555 mouse_x
>= (rect
.x
+rect
.width
-BUTTON_DROPDOWN_WIDTH
-1) &&
2556 mouse_x
< (rect
.x
+rect
.width
);
2557 e
.SetDropDownClicked(dropDownHit
);
2559 e
.SetClickPoint(evt
.GetPosition());
2560 e
.SetItemRect(rect
);
2562 // we only set the 'pressed button' state if we hit the actual button
2563 // and not just the drop-down
2564 SetPressedItem(dropDownHit ?
0 : m_actionItem
);
2568 m_actionPos
= wxPoint(-1,-1);
2569 m_actionItem
= NULL
;
2572 if(!GetEventHandler()->ProcessEvent(e
) || e
.GetSkipped())
2579 void wxAuiToolBar
::OnLeftUp(wxMouseEvent
& evt
)
2584 SetPressedItem(NULL
);
2586 wxAuiToolBarItem
* hitItem
= FindToolByPosition(evt
.GetX(), evt
.GetY());
2587 if (hitItem
&& !(hitItem
->m_state
& wxAUI_BUTTON_STATE_DISABLED
))
2589 SetHoverItem(hitItem
);
2594 // TODO: it would make sense to send out an 'END_DRAG' event here,
2595 // otherwise a client would never know what to do with the 'BEGIN_DRAG'
2598 // OnCaptureLost() will be called now and this will reset all our state
2599 // tracking variables
2604 if (m_actionItem
&& hitItem
== m_actionItem
)
2608 wxCommandEvent
e(wxEVT_COMMAND_MENU_SELECTED
, m_actionItem
->m_toolId
);
2609 e
.SetEventObject(this);
2611 if (hitItem
->m_kind
== wxITEM_CHECK
|| hitItem
->m_kind
== wxITEM_RADIO
)
2613 const bool toggle
= !(m_actionItem
->m_state
& wxAUI_BUTTON_STATE_CHECKED
);
2615 ToggleTool(m_actionItem
->m_toolId
, toggle
);
2617 // repaint immediately
2624 // we have to release the mouse *before* sending the event, because
2625 // we don't know what a handler might do. It could open up a popup
2626 // menu for example and that would make us lose our capture anyway.
2630 GetEventHandler()->ProcessEvent(e
);
2638 void wxAuiToolBar
::OnRightDown(wxMouseEvent
& evt
)
2640 wxRect
cli_rect(wxPoint(0,0), GetClientSize());
2642 if (m_gripperSizerItem
)
2644 wxRect gripper_rect
= m_gripperSizerItem
->GetRect();
2645 if (gripper_rect
.Contains(evt
.GetX(), evt
.GetY()))
2649 if (m_overflowSizerItem
)
2651 int dropdown_size
= m_art
->GetElementSize(wxAUI_TBART_OVERFLOW_SIZE
);
2652 if (dropdown_size
> 0 &&
2653 evt
.m_x
> cli_rect
.width
- dropdown_size
&&
2655 evt
.m_y
< cli_rect
.height
&&
2662 m_actionPos
= wxPoint(evt
.GetX(), evt
.GetY());
2663 m_actionItem
= FindToolByPosition(evt
.GetX(), evt
.GetY());
2665 if (m_actionItem
&& m_actionItem
->m_state
& wxAUI_BUTTON_STATE_DISABLED
)
2667 m_actionPos
= wxPoint(-1,-1);
2668 m_actionItem
= NULL
;
2675 void wxAuiToolBar
::OnRightUp(wxMouseEvent
& evt
)
2677 wxAuiToolBarItem
* hitItem
;
2678 hitItem
= FindToolByPosition(evt
.GetX(), evt
.GetY());
2680 if (m_actionItem
&& hitItem
== m_actionItem
)
2682 wxAuiToolBarEvent
e(wxEVT_COMMAND_AUITOOLBAR_RIGHT_CLICK
, m_actionItem
->m_toolId
);
2683 e
.SetEventObject(this);
2684 e
.SetToolId(m_actionItem
->m_toolId
);
2685 e
.SetClickPoint(m_actionPos
);
2686 GetEventHandler()->ProcessEvent(e
);
2691 // right-clicked on the invalid area of the toolbar
2692 wxAuiToolBarEvent
e(wxEVT_COMMAND_AUITOOLBAR_RIGHT_CLICK
, -1);
2693 e
.SetEventObject(this);
2695 e
.SetClickPoint(m_actionPos
);
2696 GetEventHandler()->ProcessEvent(e
);
2700 // reset member variables
2701 m_actionPos
= wxPoint(-1,-1);
2702 m_actionItem
= NULL
;
2705 void wxAuiToolBar
::OnMiddleDown(wxMouseEvent
& evt
)
2707 wxRect
cli_rect(wxPoint(0,0), GetClientSize());
2709 if (m_gripperSizerItem
)
2711 wxRect gripper_rect
= m_gripperSizerItem
->GetRect();
2712 if (gripper_rect
.Contains(evt
.GetX(), evt
.GetY()))
2716 if (m_overflowSizerItem
)
2718 int dropdown_size
= m_art
->GetElementSize(wxAUI_TBART_OVERFLOW_SIZE
);
2719 if (dropdown_size
> 0 &&
2720 evt
.m_x
> cli_rect
.width
- dropdown_size
&&
2722 evt
.m_y
< cli_rect
.height
&&
2729 m_actionPos
= wxPoint(evt
.GetX(), evt
.GetY());
2730 m_actionItem
= FindToolByPosition(evt
.GetX(), evt
.GetY());
2734 if (m_actionItem
->m_state
& wxAUI_BUTTON_STATE_DISABLED
)
2736 m_actionPos
= wxPoint(-1,-1);
2737 m_actionItem
= NULL
;
2745 void wxAuiToolBar
::OnMiddleUp(wxMouseEvent
& evt
)
2747 wxAuiToolBarItem
* hitItem
;
2748 hitItem
= FindToolByPosition(evt
.GetX(), evt
.GetY());
2750 if (m_actionItem
&& hitItem
== m_actionItem
)
2752 if (hitItem
->m_kind
== wxITEM_NORMAL
)
2754 wxAuiToolBarEvent
e(wxEVT_COMMAND_AUITOOLBAR_MIDDLE_CLICK
, m_actionItem
->m_toolId
);
2755 e
.SetEventObject(this);
2756 e
.SetToolId(m_actionItem
->m_toolId
);
2757 e
.SetClickPoint(m_actionPos
);
2758 GetEventHandler()->ProcessEvent(e
);
2763 // reset member variables
2764 m_actionPos
= wxPoint(-1,-1);
2765 m_actionItem
= NULL
;
2768 void wxAuiToolBar
::OnMotion(wxMouseEvent
& evt
)
2770 const bool button_pressed
= HasCapture();
2772 // start a drag event
2773 if (!m_dragging
&& button_pressed
&&
2774 abs(evt
.GetX() - m_actionPos
.x
) + abs(evt
.GetY() - m_actionPos
.y
) > 5)
2776 // TODO: sending this event only makes sense if there is an 'END_DRAG'
2777 // event sent sometime in the future (see OnLeftUp())
2778 wxAuiToolBarEvent
e(wxEVT_COMMAND_AUITOOLBAR_BEGIN_DRAG
, GetId());
2779 e
.SetEventObject(this);
2780 e
.SetToolId(m_actionItem
->m_toolId
);
2781 m_dragging
= GetEventHandler()->ProcessEvent(e
) && !e
.GetSkipped();
2789 wxAuiToolBarItem
* hitItem
= FindToolByPosition(evt
.GetX(), evt
.GetY());
2792 // if we have a button pressed we want it to be shown in 'depressed'
2793 // state unless we move the mouse outside the button, then we want it
2794 // to show as just 'highlighted'
2795 if (hitItem
== m_actionItem
)
2796 SetPressedItem(m_actionItem
);
2799 SetPressedItem(NULL
);
2800 SetHoverItem(m_actionItem
);
2805 if (hitItem
&& (hitItem
->m_state
& wxAUI_BUTTON_STATE_DISABLED
))
2808 SetHoverItem(hitItem
);
2810 // tooltips handling
2811 wxAuiToolBarItem
* packingHitItem
;
2812 packingHitItem
= FindToolByPositionWithPacking(evt
.GetX(), evt
.GetY());
2815 if (packingHitItem
!= m_tipItem
)
2817 m_tipItem
= packingHitItem
;
2819 if ( !packingHitItem
->m_shortHelp
.empty() )
2820 SetToolTip(packingHitItem
->m_shortHelp
);
2831 // figure out the dropdown button state (are we hovering or pressing it?)
2832 RefreshOverflowState();
2836 void wxAuiToolBar
::DoResetMouseState()
2838 RefreshOverflowState();
2840 SetPressedItem(NULL
);
2844 // we have to reset those here, because the mouse-up handlers which do
2845 // it usually won't be called if we let go of a mouse button while we
2846 // are outside of the window
2847 m_actionPos
= wxPoint(-1,-1);
2848 m_actionItem
= NULL
;
2851 void wxAuiToolBar
::OnLeaveWindow(wxMouseEvent
& evt
)
2859 DoResetMouseState();
2862 void wxAuiToolBar
::OnCaptureLost(wxMouseCaptureLostEvent
& WXUNUSED(evt
))
2866 DoResetMouseState();
2869 void wxAuiToolBar
::OnSetCursor(wxSetCursorEvent
& evt
)
2871 wxCursor cursor
= wxNullCursor
;
2873 if (m_gripperSizerItem
)
2875 wxRect gripper_rect
= m_gripperSizerItem
->GetRect();
2876 if (gripper_rect
.Contains(evt
.GetX(), evt
.GetY()))
2878 cursor
= wxCursor(wxCURSOR_SIZING
);
2882 evt
.SetCursor(cursor
);