1 ///////////////////////////////////////////////////////////////////////////////
3 // Name: src/aui/dockart.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"
41 // for themeing support
42 #include <Carbon/Carbon.h>
45 #include "wx/arrimpl.cpp"
46 WX_DEFINE_OBJARRAY(wxAuiToolBarItemArray
)
49 wxDEFINE_EVENT( wxEVT_COMMAND_AUITOOLBAR_TOOL_DROPDOWN
, wxAuiToolBarEvent
);
50 wxDEFINE_EVENT( wxEVT_COMMAND_AUITOOLBAR_OVERFLOW_CLICK
, wxAuiToolBarEvent
);
51 wxDEFINE_EVENT( wxEVT_COMMAND_AUITOOLBAR_RIGHT_CLICK
, wxAuiToolBarEvent
);
52 wxDEFINE_EVENT( wxEVT_COMMAND_AUITOOLBAR_MIDDLE_CLICK
, wxAuiToolBarEvent
);
53 wxDEFINE_EVENT( wxEVT_COMMAND_AUITOOLBAR_BEGIN_DRAG
, wxAuiToolBarEvent
);
56 IMPLEMENT_CLASS(wxAuiToolBar
, wxControl
)
57 IMPLEMENT_DYNAMIC_CLASS(wxAuiToolBarEvent
, wxEvent
)
60 // missing wxITEM_* items
63 wxITEM_CONTROL
= wxITEM_MAX
,
68 const int BUTTON_DROPDOWN_WIDTH
= 10;
71 wxBitmap
wxAuiBitmapFromBits(const unsigned char bits
[], int w
, int h
,
72 const wxColour
& color
);
74 unsigned char wxAuiBlendColour(unsigned char fg
, unsigned char bg
, double alpha
);
75 wxColor
wxAuiStepColour(const wxColor
& c
, int percent
);
77 static wxBitmap
MakeDisabledBitmap(wxBitmap
& bmp
)
79 wxImage image
= bmp
.ConvertToImage();
82 mr
= image
.GetMaskRed();
83 mg
= image
.GetMaskGreen();
84 mb
= image
.GetMaskBlue();
86 unsigned char* data
= image
.GetData();
87 int width
= image
.GetWidth();
88 int height
= image
.GetHeight();
89 bool has_mask
= image
.HasMask();
91 for (int y
= height
-1; y
>= 0; --y
)
93 for (int x
= width
-1; x
>= 0; --x
)
95 data
= image
.GetData() + (y
*(width
*3))+(x
*3);
96 unsigned char* r
= data
;
97 unsigned char* g
= data
+1;
98 unsigned char* b
= data
+2;
100 if (has_mask
&& *r
== mr
&& *g
== mg
&& *b
== mb
)
103 *r
= wxAuiBlendColour(*r
, 255, 0.4);
104 *g
= wxAuiBlendColour(*g
, 255, 0.4);
105 *b
= wxAuiBlendColour(*b
, 255, 0.4);
109 return wxBitmap(image
);
112 static wxColor
GetBaseColor()
115 #if defined( __WXMAC__ ) && wxOSX_USE_COCOA_OR_CARBON
116 wxColor base_colour
= wxColour( wxMacCreateCGColorFromHITheme(kThemeBrushToolbarBackground
));
118 wxColor base_colour
= wxSystemSettings
::GetColour(wxSYS_COLOUR_3DFACE
);
121 // the base_colour is too pale to use as our base colour,
122 // so darken it a bit --
123 if ((255-base_colour
.Red()) +
124 (255-base_colour
.Green()) +
125 (255-base_colour
.Blue()) < 60)
127 base_colour
= wxAuiStepColour(base_colour
, 92);
135 class ToolbarCommandCapture
: public wxEvtHandler
139 ToolbarCommandCapture() { m_last_id
= 0; }
140 int GetCommandId() const { return m_last_id
; }
142 bool ProcessEvent(wxEvent
& evt
)
144 if (evt
.GetEventType() == wxEVT_COMMAND_MENU_SELECTED
)
146 m_last_id
= evt
.GetId();
150 if (GetNextHandler())
151 return GetNextHandler()->ProcessEvent(evt
);
162 static const unsigned char
163 DISABLED_TEXT_GREY_HUE
= wxAuiBlendColour(0, 255, 0.4);
164 const wxColour
DISABLED_TEXT_COLOR(DISABLED_TEXT_GREY_HUE
,
165 DISABLED_TEXT_GREY_HUE
,
166 DISABLED_TEXT_GREY_HUE
);
168 wxAuiDefaultToolBarArt
::wxAuiDefaultToolBarArt()
170 m_base_colour
= GetBaseColor();
173 m_text_orientation
= wxAUI_TBTOOL_TEXT_BOTTOM
;
174 m_highlight_colour
= wxSystemSettings
::GetColour(wxSYS_COLOUR_HIGHLIGHT
);
176 m_separator_size
= 7;
178 m_overflow_size
= 16;
180 wxColor darker1_colour
= wxAuiStepColour(m_base_colour
, 85);
181 wxColor darker2_colour
= wxAuiStepColour(m_base_colour
, 75);
182 wxColor darker3_colour
= wxAuiStepColour(m_base_colour
, 60);
183 wxColor darker4_colour
= wxAuiStepColour(m_base_colour
, 50);
184 wxColor darker5_colour
= wxAuiStepColour(m_base_colour
, 40);
186 m_gripper_pen1
= wxPen(darker5_colour
);
187 m_gripper_pen2
= wxPen(darker3_colour
);
188 m_gripper_pen3
= *wxWHITE_PEN
;
190 static unsigned char button_dropdown_bits
[] = { 0xe0, 0xf1, 0xfb };
191 static unsigned char overflow_bits
[] = { 0x80, 0xff, 0x80, 0xc1, 0xe3, 0xf7 };
193 m_button_dropdown_bmp
= wxAuiBitmapFromBits(button_dropdown_bits
, 5, 3,
195 m_disabled_button_dropdown_bmp
= wxAuiBitmapFromBits(
196 button_dropdown_bits
, 5, 3,
197 wxColor(128,128,128));
198 m_overflow_bmp
= wxAuiBitmapFromBits(overflow_bits
, 7, 6, *wxBLACK
);
199 m_disabled_overflow_bmp
= wxAuiBitmapFromBits(overflow_bits
, 7, 6, wxColor(128,128,128));
201 m_font
= *wxNORMAL_FONT
;
204 wxAuiDefaultToolBarArt
::~wxAuiDefaultToolBarArt()
206 m_font
= *wxNORMAL_FONT
;
210 wxAuiToolBarArt
* wxAuiDefaultToolBarArt
::Clone()
212 return static_cast<wxAuiToolBarArt
*>(new wxAuiDefaultToolBarArt
);
215 void wxAuiDefaultToolBarArt
::SetFlags(unsigned int flags
)
220 void wxAuiDefaultToolBarArt
::SetFont(const wxFont
& font
)
225 void wxAuiDefaultToolBarArt
::SetTextOrientation(int orientation
)
227 m_text_orientation
= orientation
;
230 void wxAuiDefaultToolBarArt
::DrawBackground(
232 wxWindow
* WXUNUSED(wnd
),
237 wxColour start_colour
= wxAuiStepColour(m_base_colour
, 150);
238 wxColour end_colour
= wxAuiStepColour(m_base_colour
, 90);
239 dc
.GradientFillLinear(rect
, start_colour
, end_colour
, wxSOUTH
);
242 void wxAuiDefaultToolBarArt
::DrawLabel(
244 wxWindow
* WXUNUSED(wnd
),
245 const wxAuiToolBarItem
& item
,
249 dc
.SetTextForeground(*wxBLACK
);
251 // we only care about the text height here since the text
252 // will get cropped based on the width of the item
253 int text_width
= 0, text_height
= 0;
254 dc
.GetTextExtent(wxT("ABCDHgj"), &text_width
, &text_height
);
256 // set the clipping region
257 wxRect clip_rect
= rect
;
258 clip_rect
.width
-= 1;
259 dc
.SetClippingRegion(clip_rect
);
263 text_y
= rect
.y
+ (rect
.height
-text_height
)/2;
264 dc
.DrawText(item
.GetLabel(), text_x
, text_y
);
265 dc
.DestroyClippingRegion();
269 void wxAuiDefaultToolBarArt
::DrawButton(
271 wxWindow
* WXUNUSED(wnd
),
272 const wxAuiToolBarItem
& item
,
275 int text_width
= 0, text_height
= 0;
277 if (m_flags
& wxAUI_TB_TEXT
)
283 dc
.GetTextExtent(wxT("ABCDHgj"), &tx
, &text_height
);
285 dc
.GetTextExtent(item
.GetLabel(), &text_width
, &ty
);
288 int bmp_x
= 0, bmp_y
= 0;
289 int text_x
= 0, text_y
= 0;
291 if (m_text_orientation
== wxAUI_TBTOOL_TEXT_BOTTOM
)
295 (item
.GetBitmap().GetWidth()/2);
298 ((rect
.height
-text_height
)/2) -
299 (item
.GetBitmap().GetHeight()/2);
301 text_x
= rect
.x
+ (rect
.width
/2) - (text_width
/2) + 1;
302 text_y
= rect
.y
+ rect
.height
- text_height
- 1;
304 else if (m_text_orientation
== wxAUI_TBTOOL_TEXT_RIGHT
)
310 (item
.GetBitmap().GetHeight()/2);
312 text_x
= bmp_x
+ 3 + item
.GetBitmap().GetWidth();
319 if (!(item
.GetState() & wxAUI_BUTTON_STATE_DISABLED
))
321 if (item
.GetState() & wxAUI_BUTTON_STATE_PRESSED
)
323 dc
.SetPen(wxPen(m_highlight_colour
));
324 dc
.SetBrush(wxBrush(wxAuiStepColour(m_highlight_colour
, 150)));
325 dc
.DrawRectangle(rect
);
327 else if ((item
.GetState() & wxAUI_BUTTON_STATE_HOVER
) || item
.IsSticky())
329 dc
.SetPen(wxPen(m_highlight_colour
));
330 dc
.SetBrush(wxBrush(wxAuiStepColour(m_highlight_colour
, 170)));
332 // draw an even lighter background for checked item hovers (since
333 // the hover background is the same color as the check background)
334 if (item
.GetState() & wxAUI_BUTTON_STATE_CHECKED
)
335 dc
.SetBrush(wxBrush(wxAuiStepColour(m_highlight_colour
, 180)));
337 dc
.DrawRectangle(rect
);
339 else if (item
.GetState() & wxAUI_BUTTON_STATE_CHECKED
)
341 // it's important to put this code in an else statment after the
342 // hover, otherwise hovers won't draw properly for checked items
343 dc
.SetPen(wxPen(m_highlight_colour
));
344 dc
.SetBrush(wxBrush(wxAuiStepColour(m_highlight_colour
, 170)));
345 dc
.DrawRectangle(rect
);
350 if (item
.GetState() & wxAUI_BUTTON_STATE_DISABLED
)
351 bmp
= item
.GetDisabledBitmap();
353 bmp
= item
.GetBitmap();
358 dc
.DrawBitmap(bmp
, bmp_x
, bmp_y
, true);
360 // set the item's text color based on if it is disabled
361 dc
.SetTextForeground(*wxBLACK
);
362 if (item
.GetState() & wxAUI_BUTTON_STATE_DISABLED
)
363 dc
.SetTextForeground(DISABLED_TEXT_COLOR
);
365 if ( (m_flags
& wxAUI_TB_TEXT
) && !item
.GetLabel().empty() )
367 dc
.DrawText(item
.GetLabel(), text_x
, text_y
);
372 void wxAuiDefaultToolBarArt
::DrawDropDownButton(
374 wxWindow
* WXUNUSED(wnd
),
375 const wxAuiToolBarItem
& item
,
378 int text_width
= 0, text_height
= 0, text_x
= 0, text_y
= 0;
379 int bmp_x
= 0, bmp_y
= 0, dropbmp_x
= 0, dropbmp_y
= 0;
381 wxRect button_rect
= wxRect(rect
.x
,
383 rect
.width
-BUTTON_DROPDOWN_WIDTH
,
385 wxRect dropdown_rect
= wxRect(rect
.x
+rect
.width
-BUTTON_DROPDOWN_WIDTH
-1,
387 BUTTON_DROPDOWN_WIDTH
+1,
390 if (m_flags
& wxAUI_TB_TEXT
)
395 if (m_flags
& wxAUI_TB_TEXT
)
397 dc
.GetTextExtent(wxT("ABCDHgj"), &tx
, &text_height
);
401 dc
.GetTextExtent(item
.GetLabel(), &text_width
, &ty
);
406 dropbmp_x
= dropdown_rect
.x
+
407 (dropdown_rect
.width
/2) -
408 (m_button_dropdown_bmp
.GetWidth()/2);
409 dropbmp_y
= dropdown_rect
.y
+
410 (dropdown_rect
.height
/2) -
411 (m_button_dropdown_bmp
.GetHeight()/2);
414 if (m_text_orientation
== wxAUI_TBTOOL_TEXT_BOTTOM
)
416 bmp_x
= button_rect
.x
+
417 (button_rect
.width
/2) -
418 (item
.GetBitmap().GetWidth()/2);
419 bmp_y
= button_rect
.y
+
420 ((button_rect
.height
-text_height
)/2) -
421 (item
.GetBitmap().GetHeight()/2);
423 text_x
= rect
.x
+ (rect
.width
/2) - (text_width
/2) + 1;
424 text_y
= rect
.y
+ rect
.height
- text_height
- 1;
426 else if (m_text_orientation
== wxAUI_TBTOOL_TEXT_RIGHT
)
432 (item
.GetBitmap().GetHeight()/2);
434 text_x
= bmp_x
+ 3 + item
.GetBitmap().GetWidth();
441 if (item
.GetState() & wxAUI_BUTTON_STATE_PRESSED
)
443 dc
.SetPen(wxPen(m_highlight_colour
));
444 dc
.SetBrush(wxBrush(wxAuiStepColour(m_highlight_colour
, 140)));
445 dc
.DrawRectangle(button_rect
);
446 dc
.DrawRectangle(dropdown_rect
);
448 else if (item
.GetState() & wxAUI_BUTTON_STATE_HOVER
||
451 dc
.SetPen(wxPen(m_highlight_colour
));
452 dc
.SetBrush(wxBrush(wxAuiStepColour(m_highlight_colour
, 170)));
453 dc
.DrawRectangle(button_rect
);
454 dc
.DrawRectangle(dropdown_rect
);
459 if (item
.GetState() & wxAUI_BUTTON_STATE_DISABLED
)
461 bmp
= item
.GetDisabledBitmap();
462 dropbmp
= m_disabled_button_dropdown_bmp
;
466 bmp
= item
.GetBitmap();
467 dropbmp
= m_button_dropdown_bmp
;
473 dc
.DrawBitmap(bmp
, bmp_x
, bmp_y
, true);
474 dc
.DrawBitmap(dropbmp
, dropbmp_x
, dropbmp_y
, true);
476 // set the item's text color based on if it is disabled
477 dc
.SetTextForeground(*wxBLACK
);
478 if (item
.GetState() & wxAUI_BUTTON_STATE_DISABLED
)
479 dc
.SetTextForeground(DISABLED_TEXT_COLOR
);
481 if ( (m_flags
& wxAUI_TB_TEXT
) && !item
.GetLabel().empty() )
483 dc
.DrawText(item
.GetLabel(), text_x
, text_y
);
487 void wxAuiDefaultToolBarArt
::DrawControlLabel(
489 wxWindow
* WXUNUSED(wnd
),
490 const wxAuiToolBarItem
& item
,
493 if (!(m_flags
& wxAUI_TB_TEXT
))
496 if (m_text_orientation
!= wxAUI_TBTOOL_TEXT_BOTTOM
)
499 int text_x
= 0, text_y
= 0;
500 int text_width
= 0, text_height
= 0;
505 if (m_flags
& wxAUI_TB_TEXT
)
507 dc
.GetTextExtent(wxT("ABCDHgj"), &tx
, &text_height
);
511 dc
.GetTextExtent(item
.GetLabel(), &text_width
, &ty
);
513 // don't draw the label if it is wider than the item width
514 if (text_width
> rect
.width
)
517 // set the label's text color
518 dc
.SetTextForeground(*wxBLACK
);
520 text_x
= rect
.x
+ (rect
.width
/2) - (text_width
/2) + 1;
521 text_y
= rect
.y
+ rect
.height
- text_height
- 1;
523 if ( (m_flags
& wxAUI_TB_TEXT
) && !item
.GetLabel().empty() )
525 dc
.DrawText(item
.GetLabel(), text_x
, text_y
);
529 wxSize wxAuiDefaultToolBarArt
::GetLabelSize(
531 wxWindow
* WXUNUSED(wnd
),
532 const wxAuiToolBarItem
& item
)
536 // get label's height
537 int width
= 0, height
= 0;
538 dc
.GetTextExtent(wxT("ABCDHgj"), &width
, &height
);
541 width
= item
.GetMinSize().GetWidth();
543 return wxSize(width
, height
);
546 wxSize wxAuiDefaultToolBarArt
::GetToolSize(
548 wxWindow
* WXUNUSED(wnd
),
549 const wxAuiToolBarItem
& item
)
551 if (!item
.GetBitmap().IsOk() && !(m_flags
& wxAUI_TB_TEXT
))
552 return wxSize(16,16);
554 int width
= item
.GetBitmap().GetWidth();
555 int height
= item
.GetBitmap().GetHeight();
557 if (m_flags
& wxAUI_TB_TEXT
)
562 if (m_text_orientation
== wxAUI_TBTOOL_TEXT_BOTTOM
)
564 dc
.GetTextExtent(wxT("ABCDHgj"), &tx
, &ty
);
567 if ( !item
.GetLabel().empty() )
569 dc
.GetTextExtent(item
.GetLabel(), &tx
, &ty
);
570 width
= wxMax(width
, tx
+6);
573 else if ( m_text_orientation
== wxAUI_TBTOOL_TEXT_RIGHT
&&
574 !item
.GetLabel().empty() )
576 width
+= 3; // space between left border and bitmap
577 width
+= 3; // space between bitmap and text
579 if ( !item
.GetLabel().empty() )
581 dc
.GetTextExtent(item
.GetLabel(), &tx
, &ty
);
583 height
= wxMax(height
, ty
);
588 // if the tool has a dropdown button, add it to the width
589 if (item
.HasDropDown())
590 width
+= (BUTTON_DROPDOWN_WIDTH
+4);
592 return wxSize(width
, height
);
595 void wxAuiDefaultToolBarArt
::DrawSeparator(
597 wxWindow
* WXUNUSED(wnd
),
600 bool horizontal
= true;
601 if (m_flags
& wxAUI_TB_VERTICAL
)
608 rect
.x
+= (rect
.width
/2);
610 int new_height
= (rect
.height
*3)/4;
611 rect
.y
+= (rect
.height
/2) - (new_height
/2);
612 rect
.height
= new_height
;
616 rect
.y
+= (rect
.height
/2);
618 int new_width
= (rect
.width
*3)/4;
619 rect
.x
+= (rect
.width
/2) - (new_width
/2);
620 rect
.width
= new_width
;
623 wxColour start_colour
= wxAuiStepColour(m_base_colour
, 80);
624 wxColour end_colour
= wxAuiStepColour(m_base_colour
, 80);
625 dc
.GradientFillLinear(rect
, start_colour
, end_colour
, horizontal ? wxSOUTH
: wxEAST
);
628 void wxAuiDefaultToolBarArt
::DrawGripper(wxDC
& dc
,
629 wxWindow
* WXUNUSED(wnd
),
637 if (m_flags
& wxAUI_TB_VERTICAL
)
639 x
= rect
.x
+ (i
*4) + 5;
641 if (x
> rect
.GetWidth()-5)
647 y
= rect
.y
+ (i
*4) + 5;
648 if (y
> rect
.GetHeight()-5)
652 dc
.SetPen(m_gripper_pen1
);
654 dc
.SetPen(m_gripper_pen2
);
655 dc
.DrawPoint(x
, y
+1);
656 dc
.DrawPoint(x
+1, y
);
657 dc
.SetPen(m_gripper_pen3
);
658 dc
.DrawPoint(x
+2, y
+1);
659 dc
.DrawPoint(x
+2, y
+2);
660 dc
.DrawPoint(x
+1, y
+2);
667 void wxAuiDefaultToolBarArt
::DrawOverflowButton(wxDC
& dc
,
672 if (state
& wxAUI_BUTTON_STATE_HOVER
||
673 state
& wxAUI_BUTTON_STATE_PRESSED
)
675 wxRect cli_rect
= wnd
->GetClientRect();
676 wxColor light_gray_bg
= wxAuiStepColour(m_highlight_colour
, 170);
678 if (m_flags
& wxAUI_TB_VERTICAL
)
680 dc
.SetPen(wxPen(m_highlight_colour
));
681 dc
.DrawLine(rect
.x
, rect
.y
, rect
.x
+rect
.width
, rect
.y
);
682 dc
.SetPen(wxPen(light_gray_bg
));
683 dc
.SetBrush(wxBrush(light_gray_bg
));
684 dc
.DrawRectangle(rect
.x
, rect
.y
+1, rect
.width
, rect
.height
);
688 dc
.SetPen(wxPen(m_highlight_colour
));
689 dc
.DrawLine(rect
.x
, rect
.y
, rect
.x
, rect
.y
+rect
.height
);
690 dc
.SetPen(wxPen(light_gray_bg
));
691 dc
.SetBrush(wxBrush(light_gray_bg
));
692 dc
.DrawRectangle(rect
.x
+1, rect
.y
, rect
.width
, rect
.height
);
696 int x
= rect
.x
+1+(rect
.width
-m_overflow_bmp
.GetWidth())/2;
697 int y
= rect
.y
+1+(rect
.height
-m_overflow_bmp
.GetHeight())/2;
698 dc
.DrawBitmap(m_overflow_bmp
, x
, y
, true);
701 int wxAuiDefaultToolBarArt
::GetElementSize(int element_id
)
705 case wxAUI_TBART_SEPARATOR_SIZE
: return m_separator_size
;
706 case wxAUI_TBART_GRIPPER_SIZE
: return m_gripper_size
;
707 case wxAUI_TBART_OVERFLOW_SIZE
: return m_overflow_size
;
712 void wxAuiDefaultToolBarArt
::SetElementSize(int element_id
, int size
)
716 case wxAUI_TBART_SEPARATOR_SIZE
: m_separator_size
= size
;
717 case wxAUI_TBART_GRIPPER_SIZE
: m_gripper_size
= size
;
718 case wxAUI_TBART_OVERFLOW_SIZE
: m_overflow_size
= size
;
722 int wxAuiDefaultToolBarArt
::ShowDropDown(wxWindow
* wnd
,
723 const wxAuiToolBarItemArray
& items
)
727 size_t items_added
= 0;
729 size_t i
, count
= items
.GetCount();
730 for (i
= 0; i
< count
; ++i
)
732 wxAuiToolBarItem
& item
= items
.Item(i
);
734 if (item
.GetKind() == wxITEM_NORMAL
)
736 wxString text
= item
.GetShortHelp();
738 text
= item
.GetLabel();
743 wxMenuItem
* m
= new wxMenuItem(&menuPopup
, item
.GetId(), text
, item
.GetShortHelp());
745 m
->SetBitmap(item
.GetBitmap());
749 else if (item
.GetKind() == wxITEM_SEPARATOR
)
752 menuPopup
.AppendSeparator();
756 // find out where to put the popup menu of window items
757 wxPoint pt
= ::wxGetMousePosition();
758 pt
= wnd
->ScreenToClient(pt
);
760 // find out the screen coordinate at the bottom of the tab ctrl
761 wxRect cli_rect
= wnd
->GetClientRect();
762 pt
.y
= cli_rect
.y
+ cli_rect
.height
;
764 ToolbarCommandCapture
* cc
= new ToolbarCommandCapture
;
765 wnd
->PushEventHandler(cc
);
766 wnd
->PopupMenu(&menuPopup
, pt
);
767 int command
= cc
->GetCommandId();
768 wnd
->PopEventHandler(true);
776 BEGIN_EVENT_TABLE(wxAuiToolBar
, wxControl
)
777 EVT_SIZE(wxAuiToolBar
::OnSize
)
778 EVT_IDLE(wxAuiToolBar
::OnIdle
)
779 EVT_ERASE_BACKGROUND(wxAuiToolBar
::OnEraseBackground
)
780 EVT_PAINT(wxAuiToolBar
::OnPaint
)
781 EVT_LEFT_DOWN(wxAuiToolBar
::OnLeftDown
)
782 EVT_LEFT_DCLICK(wxAuiToolBar
::OnLeftDown
)
783 EVT_LEFT_UP(wxAuiToolBar
::OnLeftUp
)
784 EVT_RIGHT_DOWN(wxAuiToolBar
::OnRightDown
)
785 EVT_RIGHT_DCLICK(wxAuiToolBar
::OnRightDown
)
786 EVT_RIGHT_UP(wxAuiToolBar
::OnRightUp
)
787 EVT_MIDDLE_DOWN(wxAuiToolBar
::OnMiddleDown
)
788 EVT_MIDDLE_DCLICK(wxAuiToolBar
::OnMiddleDown
)
789 EVT_MIDDLE_UP(wxAuiToolBar
::OnMiddleUp
)
790 EVT_MOTION(wxAuiToolBar
::OnMotion
)
791 EVT_LEAVE_WINDOW(wxAuiToolBar
::OnLeaveWindow
)
792 EVT_SET_CURSOR(wxAuiToolBar
::OnSetCursor
)
796 wxAuiToolBar
::wxAuiToolBar(wxWindow
* parent
,
798 const wxPoint
& position
,
805 style
| wxBORDER_NONE
)
807 m_sizer
= new wxBoxSizer(wxHORIZONTAL
);
809 m_button_height
= -1;
810 m_sizer_element_count
= 0;
811 m_action_pos
= wxPoint(-1,-1);
812 m_action_item
= NULL
;
814 m_art
= new wxAuiDefaultToolBarArt
;
816 m_tool_border_padding
= 3;
817 m_tool_text_orientation
= wxAUI_TBTOOL_TEXT_BOTTOM
;
818 m_gripper_sizer_item
= NULL
;
819 m_overflow_sizer_item
= NULL
;
822 m_gripper_visible
= (m_style
& wxAUI_TB_GRIPPER
) ?
true : false;
823 m_overflow_visible
= (m_style
& wxAUI_TB_OVERFLOW
) ?
true : false;
824 m_overflow_state
= 0;
825 SetMargins(5, 5, 2, 2);
826 SetFont(*wxNORMAL_FONT
);
827 m_art
->SetFlags((unsigned int)m_style
);
828 SetExtraStyle(wxWS_EX_PROCESS_IDLE
);
829 if (style
& wxAUI_TB_HORZ_LAYOUT
)
830 SetToolTextOrientation(wxAUI_TBTOOL_TEXT_RIGHT
);
834 wxAuiToolBar
::~wxAuiToolBar()
840 void wxAuiToolBar
::SetWindowStyleFlag(long style
)
842 wxControl
::SetWindowStyleFlag(style
);
848 m_art
->SetFlags((unsigned int)m_style
);
851 if (m_style
& wxAUI_TB_GRIPPER
)
852 m_gripper_visible
= true;
854 m_gripper_visible
= false;
857 if (m_style
& wxAUI_TB_OVERFLOW
)
858 m_overflow_visible
= true;
860 m_overflow_visible
= false;
862 if (style
& wxAUI_TB_HORZ_LAYOUT
)
863 SetToolTextOrientation(wxAUI_TBTOOL_TEXT_RIGHT
);
865 SetToolTextOrientation(wxAUI_TBTOOL_TEXT_BOTTOM
);
869 void wxAuiToolBar
::SetArtProvider(wxAuiToolBarArt
* art
)
877 m_art
->SetFlags((unsigned int)m_style
);
878 m_art
->SetTextOrientation(m_tool_text_orientation
);
882 wxAuiToolBarArt
* wxAuiToolBar
::GetArtProvider() const
890 wxAuiToolBarItem
* wxAuiToolBar
::AddTool(int tool_id
,
891 const wxString
& label
,
892 const wxBitmap
& bitmap
,
893 const wxString
& short_help_string
,
896 return AddTool(tool_id
,
907 wxAuiToolBarItem
* wxAuiToolBar
::AddTool(int tool_id
,
908 const wxString
& label
,
909 const wxBitmap
& bitmap
,
910 const wxBitmap
& disabled_bitmap
,
912 const wxString
& short_help_string
,
913 const wxString
& long_help_string
,
914 wxObject
* WXUNUSED(client_data
))
916 wxAuiToolBarItem item
;
919 item
.bitmap
= bitmap
;
920 item
.disabled_bitmap
= disabled_bitmap
;
921 item
.short_help
= short_help_string
;
922 item
.long_help
= long_help_string
;
924 item
.dropdown
= false;
925 item
.spacer_pixels
= 0;
930 item
.sizer_item
= NULL
;
931 item
.min_size
= wxDefaultSize
;
935 if (item
.id
== wxID_ANY
)
938 if (!item
.disabled_bitmap
.IsOk())
940 // no disabled bitmap specified, we need to make one
941 if (item
.bitmap
.IsOk())
943 //wxImage img = item.bitmap.ConvertToImage();
944 //wxImage grey_version = img.ConvertToGreyscale();
945 //item.disabled_bitmap = wxBitmap(grey_version);
946 item
.disabled_bitmap
= MakeDisabledBitmap(item
.bitmap
);
950 return &m_items
.Last();
953 wxAuiToolBarItem
* wxAuiToolBar
::AddControl(wxControl
* control
,
954 const wxString
& label
)
956 wxAuiToolBarItem item
;
957 item
.window
= (wxWindow
*)control
;
959 item
.bitmap
= wxNullBitmap
;
960 item
.disabled_bitmap
= wxNullBitmap
;
962 item
.dropdown
= false;
963 item
.spacer_pixels
= 0;
964 item
.id
= control
->GetId();
967 item
.kind
= wxITEM_CONTROL
;
968 item
.sizer_item
= NULL
;
969 item
.min_size
= control
->GetEffectiveMinSize();
974 return &m_items
.Last();
977 wxAuiToolBarItem
* wxAuiToolBar
::AddLabel(int tool_id
,
978 const wxString
& label
,
981 wxSize min_size
= wxDefaultSize
;
985 wxAuiToolBarItem item
;
988 item
.bitmap
= wxNullBitmap
;
989 item
.disabled_bitmap
= wxNullBitmap
;
991 item
.dropdown
= false;
992 item
.spacer_pixels
= 0;
996 item
.kind
= wxITEM_LABEL
;
997 item
.sizer_item
= NULL
;
998 item
.min_size
= min_size
;
1000 item
.sticky
= false;
1002 if (item
.id
== wxID_ANY
)
1003 item
.id
= wxNewId();
1006 return &m_items
.Last();
1009 wxAuiToolBarItem
* wxAuiToolBar
::AddSeparator()
1011 wxAuiToolBarItem item
;
1013 item
.label
= wxEmptyString
;
1014 item
.bitmap
= wxNullBitmap
;
1015 item
.disabled_bitmap
= wxNullBitmap
;
1017 item
.dropdown
= false;
1020 item
.proportion
= 0;
1021 item
.kind
= wxITEM_SEPARATOR
;
1022 item
.sizer_item
= NULL
;
1023 item
.min_size
= wxDefaultSize
;
1025 item
.sticky
= false;
1028 return &m_items
.Last();
1031 wxAuiToolBarItem
* wxAuiToolBar
::AddSpacer(int pixels
)
1033 wxAuiToolBarItem item
;
1035 item
.label
= wxEmptyString
;
1036 item
.bitmap
= wxNullBitmap
;
1037 item
.disabled_bitmap
= wxNullBitmap
;
1039 item
.dropdown
= false;
1040 item
.spacer_pixels
= pixels
;
1043 item
.proportion
= 0;
1044 item
.kind
= wxITEM_SPACER
;
1045 item
.sizer_item
= NULL
;
1046 item
.min_size
= wxDefaultSize
;
1048 item
.sticky
= false;
1051 return &m_items
.Last();
1054 wxAuiToolBarItem
* wxAuiToolBar
::AddStretchSpacer(int proportion
)
1056 wxAuiToolBarItem item
;
1058 item
.label
= wxEmptyString
;
1059 item
.bitmap
= wxNullBitmap
;
1060 item
.disabled_bitmap
= wxNullBitmap
;
1062 item
.dropdown
= false;
1063 item
.spacer_pixels
= 0;
1066 item
.proportion
= proportion
;
1067 item
.kind
= wxITEM_SPACER
;
1068 item
.sizer_item
= NULL
;
1069 item
.min_size
= wxDefaultSize
;
1071 item
.sticky
= false;
1074 return &m_items
.Last();
1077 void wxAuiToolBar
::Clear()
1080 m_sizer_element_count
= 0;
1083 bool wxAuiToolBar
::DeleteTool(int tool_id
)
1085 int idx
= GetToolIndex(tool_id
);
1086 if (idx
>= 0 && idx
< (int)m_items
.GetCount())
1088 m_items
.RemoveAt(idx
);
1096 bool wxAuiToolBar
::DeleteByIndex(int idx
)
1098 if (idx
>= 0 && idx
< (int)m_items
.GetCount())
1100 m_items
.RemoveAt(idx
);
1109 wxControl
* wxAuiToolBar
::FindControl(int id
)
1111 wxWindow
* wnd
= FindWindow(id
);
1112 return (wxControl
*)wnd
;
1115 wxAuiToolBarItem
* wxAuiToolBar
::FindTool(int tool_id
) const
1118 for (i
= 0, count
= m_items
.GetCount(); i
< count
; ++i
)
1120 wxAuiToolBarItem
& item
= m_items
.Item(i
);
1121 if (item
.id
== tool_id
)
1128 wxAuiToolBarItem
* wxAuiToolBar
::FindToolByPosition(wxCoord x
, wxCoord y
) const
1131 for (i
= 0, count
= m_items
.GetCount(); i
< count
; ++i
)
1133 wxAuiToolBarItem
& item
= m_items
.Item(i
);
1135 if (!item
.sizer_item
)
1138 wxRect rect
= item
.sizer_item
->GetRect();
1139 if (rect
.Contains(x
,y
))
1141 // if the item doesn't fit on the toolbar, return NULL
1142 if (!GetToolFitsByIndex(i
))
1152 wxAuiToolBarItem
* wxAuiToolBar
::FindToolByPositionWithPacking(wxCoord x
, wxCoord y
) const
1155 for (i
= 0, count
= m_items
.GetCount(); i
< count
; ++i
)
1157 wxAuiToolBarItem
& item
= m_items
.Item(i
);
1159 if (!item
.sizer_item
)
1162 wxRect rect
= item
.sizer_item
->GetRect();
1164 // apply tool packing
1166 rect
.width
+= m_tool_packing
;
1168 if (rect
.Contains(x
,y
))
1170 // if the item doesn't fit on the toolbar, return NULL
1171 if (!GetToolFitsByIndex(i
))
1181 wxAuiToolBarItem
* wxAuiToolBar
::FindToolByIndex(int idx
) const
1186 if (idx
>= (int)m_items
.size())
1189 return &(m_items
[idx
]);
1192 void wxAuiToolBar
::SetToolBitmapSize(const wxSize
& WXUNUSED(size
))
1194 // TODO: wxToolBar compatibility
1197 wxSize wxAuiToolBar
::GetToolBitmapSize() const
1199 // TODO: wxToolBar compatibility
1200 return wxSize(16,15);
1203 void wxAuiToolBar
::SetToolProportion(int tool_id
, int proportion
)
1205 wxAuiToolBarItem
* item
= FindTool(tool_id
);
1209 item
->proportion
= proportion
;
1212 int wxAuiToolBar
::GetToolProportion(int tool_id
) const
1214 wxAuiToolBarItem
* item
= FindTool(tool_id
);
1218 return item
->proportion
;
1221 void wxAuiToolBar
::SetToolSeparation(int separation
)
1224 m_art
->SetElementSize(wxAUI_TBART_SEPARATOR_SIZE
, separation
);
1227 int wxAuiToolBar
::GetToolSeparation() const
1230 return m_art
->GetElementSize(wxAUI_TBART_SEPARATOR_SIZE
);
1236 void wxAuiToolBar
::SetToolDropDown(int tool_id
, bool dropdown
)
1238 wxAuiToolBarItem
* item
= FindTool(tool_id
);
1242 item
->dropdown
= dropdown
;
1245 bool wxAuiToolBar
::GetToolDropDown(int tool_id
) const
1247 wxAuiToolBarItem
* item
= FindTool(tool_id
);
1251 return item
->dropdown
;
1254 void wxAuiToolBar
::SetToolSticky(int tool_id
, bool sticky
)
1256 // ignore separators
1260 wxAuiToolBarItem
* item
= FindTool(tool_id
);
1264 if (item
->sticky
== sticky
)
1267 item
->sticky
= sticky
;
1273 bool wxAuiToolBar
::GetToolSticky(int tool_id
) const
1275 wxAuiToolBarItem
* item
= FindTool(tool_id
);
1279 return item
->sticky
;
1285 void wxAuiToolBar
::SetToolBorderPadding(int padding
)
1287 m_tool_border_padding
= padding
;
1290 int wxAuiToolBar
::GetToolBorderPadding() const
1292 return m_tool_border_padding
;
1295 void wxAuiToolBar
::SetToolTextOrientation(int orientation
)
1297 m_tool_text_orientation
= orientation
;
1301 m_art
->SetTextOrientation(orientation
);
1305 int wxAuiToolBar
::GetToolTextOrientation() const
1307 return m_tool_text_orientation
;
1310 void wxAuiToolBar
::SetToolPacking(int packing
)
1312 m_tool_packing
= packing
;
1315 int wxAuiToolBar
::GetToolPacking() const
1317 return m_tool_packing
;
1321 void wxAuiToolBar
::SetOrientation(int WXUNUSED(orientation
))
1325 void wxAuiToolBar
::SetMargins(int left
, int right
, int top
, int bottom
)
1328 m_left_padding
= left
;
1330 m_right_padding
= right
;
1332 m_top_padding
= top
;
1334 m_bottom_padding
= bottom
;
1337 bool wxAuiToolBar
::GetGripperVisible() const
1339 return m_gripper_visible
;
1342 void wxAuiToolBar
::SetGripperVisible(bool visible
)
1344 m_gripper_visible
= visible
;
1346 m_style
|= wxAUI_TB_GRIPPER
;
1352 bool wxAuiToolBar
::GetOverflowVisible() const
1354 return m_overflow_visible
;
1357 void wxAuiToolBar
::SetOverflowVisible(bool visible
)
1359 m_overflow_visible
= visible
;
1361 m_style
|= wxAUI_TB_OVERFLOW
;
1365 bool wxAuiToolBar
::SetFont(const wxFont
& font
)
1367 bool res
= wxWindow
::SetFont(font
);
1371 m_art
->SetFont(font
);
1378 void wxAuiToolBar
::SetHoverItem(wxAuiToolBarItem
* pitem
)
1380 wxAuiToolBarItem
* former_hover
= NULL
;
1383 for (i
= 0, count
= m_items
.GetCount(); i
< count
; ++i
)
1385 wxAuiToolBarItem
& item
= m_items
.Item(i
);
1386 if (item
.state
& wxAUI_BUTTON_STATE_HOVER
)
1387 former_hover
= &item
;
1388 item
.state
&= ~wxAUI_BUTTON_STATE_HOVER
;
1393 pitem
->state
|= wxAUI_BUTTON_STATE_HOVER
;
1396 if (former_hover
!= pitem
)
1403 void wxAuiToolBar
::SetPressedItem(wxAuiToolBarItem
* pitem
)
1405 wxAuiToolBarItem
* former_item
= NULL
;
1408 for (i
= 0, count
= m_items
.GetCount(); i
< count
; ++i
)
1410 wxAuiToolBarItem
& item
= m_items
.Item(i
);
1411 if (item
.state
& wxAUI_BUTTON_STATE_PRESSED
)
1412 former_item
= &item
;
1413 item
.state
&= ~wxAUI_BUTTON_STATE_PRESSED
;
1418 pitem
->state
&= ~wxAUI_BUTTON_STATE_HOVER
;
1419 pitem
->state
|= wxAUI_BUTTON_STATE_PRESSED
;
1422 if (former_item
!= pitem
)
1429 void wxAuiToolBar
::RefreshOverflowState()
1431 if (!m_overflow_sizer_item
)
1433 m_overflow_state
= 0;
1437 int overflow_state
= 0;
1439 wxRect overflow_rect
= GetOverflowRect();
1442 // find out the mouse's current position
1443 wxPoint pt
= ::wxGetMousePosition();
1444 pt
= this->ScreenToClient(pt
);
1446 // find out if the mouse cursor is inside the dropdown rectangle
1447 if (overflow_rect
.Contains(pt
.x
, pt
.y
))
1449 if (::wxGetMouseState().LeftDown())
1450 overflow_state
= wxAUI_BUTTON_STATE_PRESSED
;
1452 overflow_state
= wxAUI_BUTTON_STATE_HOVER
;
1455 if (overflow_state
!= m_overflow_state
)
1457 m_overflow_state
= overflow_state
;
1462 m_overflow_state
= overflow_state
;
1465 void wxAuiToolBar
::ToggleTool(int tool_id
, bool state
)
1467 wxAuiToolBarItem
* tool
= FindTool(tool_id
);
1469 if (tool
&& (tool
->kind
== wxITEM_CHECK
|| tool
->kind
== wxITEM_RADIO
))
1471 if (tool
->kind
== wxITEM_RADIO
)
1474 idx
= GetToolIndex(tool_id
);
1475 count
= (int)m_items
.GetCount();
1477 if (idx
>= 0 && idx
< count
)
1479 for (i
= idx
; i
< count
; ++i
)
1481 if (m_items
[i
].kind
!= wxITEM_RADIO
)
1483 m_items
[i
].state
&= ~wxAUI_BUTTON_STATE_CHECKED
;
1485 for (i
= idx
; i
> 0; i
--)
1487 if (m_items
[i
].kind
!= wxITEM_RADIO
)
1489 m_items
[i
].state
&= ~wxAUI_BUTTON_STATE_CHECKED
;
1493 tool
->state
|= wxAUI_BUTTON_STATE_CHECKED
;
1495 else if (tool
->kind
== wxITEM_CHECK
)
1498 tool
->state
|= wxAUI_BUTTON_STATE_CHECKED
;
1500 tool
->state
&= ~wxAUI_BUTTON_STATE_CHECKED
;
1505 bool wxAuiToolBar
::GetToolToggled(int tool_id
) const
1507 wxAuiToolBarItem
* tool
= FindTool(tool_id
);
1511 if ( (tool
->kind
!= wxITEM_CHECK
) && (tool
->kind
!= wxITEM_RADIO
) )
1514 return (tool
->state
& wxAUI_BUTTON_STATE_CHECKED
) ?
true : false;
1520 void wxAuiToolBar
::EnableTool(int tool_id
, bool state
)
1522 wxAuiToolBarItem
* tool
= FindTool(tool_id
);
1527 tool
->state
&= ~wxAUI_BUTTON_STATE_DISABLED
;
1529 tool
->state
|= wxAUI_BUTTON_STATE_DISABLED
;
1533 bool wxAuiToolBar
::GetToolEnabled(int tool_id
) const
1535 wxAuiToolBarItem
* tool
= FindTool(tool_id
);
1538 return (tool
->state
& wxAUI_BUTTON_STATE_DISABLED
) ?
false : true;
1543 wxString wxAuiToolBar
::GetToolLabel(int tool_id
) const
1545 wxAuiToolBarItem
* tool
= FindTool(tool_id
);
1546 wxASSERT_MSG(tool
, wxT("can't find tool in toolbar item array"));
1548 return wxEmptyString
;
1553 void wxAuiToolBar
::SetToolLabel(int tool_id
, const wxString
& label
)
1555 wxAuiToolBarItem
* tool
= FindTool(tool_id
);
1558 tool
->label
= label
;
1562 wxBitmap wxAuiToolBar
::GetToolBitmap(int tool_id
) const
1564 wxAuiToolBarItem
* tool
= FindTool(tool_id
);
1565 wxASSERT_MSG(tool
, wxT("can't find tool in toolbar item array"));
1567 return wxNullBitmap
;
1569 return tool
->bitmap
;
1572 void wxAuiToolBar
::SetToolBitmap(int tool_id
, const wxBitmap
& bitmap
)
1574 wxAuiToolBarItem
* tool
= FindTool(tool_id
);
1577 tool
->bitmap
= bitmap
;
1581 wxString wxAuiToolBar
::GetToolShortHelp(int tool_id
) const
1583 wxAuiToolBarItem
* tool
= FindTool(tool_id
);
1584 wxASSERT_MSG(tool
, wxT("can't find tool in toolbar item array"));
1586 return wxEmptyString
;
1588 return tool
->short_help
;
1591 void wxAuiToolBar
::SetToolShortHelp(int tool_id
, const wxString
& help_string
)
1593 wxAuiToolBarItem
* tool
= FindTool(tool_id
);
1596 tool
->short_help
= help_string
;
1600 wxString wxAuiToolBar
::GetToolLongHelp(int tool_id
) const
1602 wxAuiToolBarItem
* tool
= FindTool(tool_id
);
1603 wxASSERT_MSG(tool
, wxT("can't find tool in toolbar item array"));
1605 return wxEmptyString
;
1607 return tool
->long_help
;
1610 void wxAuiToolBar
::SetToolLongHelp(int tool_id
, const wxString
& help_string
)
1612 wxAuiToolBarItem
* tool
= FindTool(tool_id
);
1615 tool
->long_help
= help_string
;
1619 void wxAuiToolBar
::SetCustomOverflowItems(const wxAuiToolBarItemArray
& prepend
,
1620 const wxAuiToolBarItemArray
& append
)
1622 m_custom_overflow_prepend
= prepend
;
1623 m_custom_overflow_append
= append
;
1627 size_t wxAuiToolBar
::GetToolCount() const
1629 return m_items
.size();
1632 int wxAuiToolBar
::GetToolIndex(int tool_id
) const
1634 // this will prevent us from returning the index of the
1635 // first separator in the toolbar since its id is equal to -1
1639 size_t i
, count
= m_items
.GetCount();
1640 for (i
= 0; i
< count
; ++i
)
1642 wxAuiToolBarItem
& item
= m_items
.Item(i
);
1643 if (item
.id
== tool_id
)
1650 bool wxAuiToolBar
::GetToolFitsByIndex(int tool_idx
) const
1652 if (tool_idx
< 0 || tool_idx
>= (int)m_items
.GetCount())
1655 if (!m_items
[tool_idx
].sizer_item
)
1659 GetClientSize(&cli_w
, &cli_h
);
1661 wxRect rect
= m_items
[tool_idx
].sizer_item
->GetRect();
1663 if (m_style
& wxAUI_TB_VERTICAL
)
1665 // take the dropdown size into account
1666 if (m_overflow_visible
)
1667 cli_h
-= m_overflow_sizer_item
->GetSize().y
;
1669 if (rect
.y
+rect
.height
< cli_h
)
1674 // take the dropdown size into account
1675 if (m_overflow_visible
)
1676 cli_w
-= m_overflow_sizer_item
->GetSize().x
;
1678 if (rect
.x
+rect
.width
< cli_w
)
1686 bool wxAuiToolBar
::GetToolFits(int tool_id
) const
1688 return GetToolFitsByIndex(GetToolIndex(tool_id
));
1691 wxRect wxAuiToolBar
::GetToolRect(int tool_id
) const
1693 wxAuiToolBarItem
* tool
= FindTool(tool_id
);
1694 if (tool
&& tool
->sizer_item
)
1696 return tool
->sizer_item
->GetRect();
1702 bool wxAuiToolBar
::GetToolBarFits() const
1704 if (m_items
.GetCount() == 0)
1706 // empty toolbar always 'fits'
1710 // entire toolbar content fits if the last tool fits
1711 return GetToolFitsByIndex(m_items
.GetCount() - 1);
1714 bool wxAuiToolBar
::Realize()
1716 wxClientDC
dc(this);
1720 bool horizontal
= true;
1721 if (m_style
& wxAUI_TB_VERTICAL
)
1725 // create the new sizer to add toolbar elements to
1726 wxBoxSizer
* sizer
= new wxBoxSizer(horizontal ? wxHORIZONTAL
: wxVERTICAL
);
1729 int separator_size
= m_art
->GetElementSize(wxAUI_TBART_SEPARATOR_SIZE
);
1730 int gripper_size
= m_art
->GetElementSize(wxAUI_TBART_GRIPPER_SIZE
);
1731 if (gripper_size
> 0 && m_gripper_visible
)
1734 m_gripper_sizer_item
= sizer
->Add(gripper_size
, 1, 0, wxEXPAND
);
1736 m_gripper_sizer_item
= sizer
->Add(1, gripper_size
, 0, wxEXPAND
);
1740 m_gripper_sizer_item
= NULL
;
1743 // add "left" padding
1744 if (m_left_padding
> 0)
1747 sizer
->Add(m_left_padding
, 1);
1749 sizer
->Add(1, m_left_padding
);
1753 for (i
= 0, count
= m_items
.GetCount(); i
< count
; ++i
)
1755 wxAuiToolBarItem
& item
= m_items
.Item(i
);
1756 wxSizerItem
* sizer_item
= NULL
;
1762 wxSize size
= m_art
->GetLabelSize(dc
, this, item
);
1763 sizer_item
= sizer
->Add(size
.x
+ (m_tool_border_padding
*2),
1764 size
.y
+ (m_tool_border_padding
*2),
1769 sizer
->AddSpacer(m_tool_packing
);
1779 wxSize size
= m_art
->GetToolSize(dc
, this, item
);
1780 sizer_item
= sizer
->Add(size
.x
+ (m_tool_border_padding
*2),
1781 size
.y
+ (m_tool_border_padding
*2),
1787 sizer
->AddSpacer(m_tool_packing
);
1793 case wxITEM_SEPARATOR
:
1796 sizer_item
= sizer
->Add(separator_size
, 1, 0, wxEXPAND
);
1798 sizer_item
= sizer
->Add(1, separator_size
, 0, wxEXPAND
);
1803 sizer
->AddSpacer(m_tool_packing
);
1810 if (item
.proportion
> 0)
1811 sizer_item
= sizer
->AddStretchSpacer(item
.proportion
);
1813 sizer_item
= sizer
->Add(item
.spacer_pixels
, 1);
1816 case wxITEM_CONTROL
:
1818 //sizer_item = sizer->Add(item.window, item.proportion, wxEXPAND);
1819 wxSizerItem
* ctrl_sizer_item
;
1821 wxBoxSizer
* vert_sizer
= new wxBoxSizer(wxVERTICAL
);
1822 vert_sizer
->AddStretchSpacer(1);
1823 ctrl_sizer_item
= vert_sizer
->Add(item
.window
, 0, wxEXPAND
);
1824 vert_sizer
->AddStretchSpacer(1);
1825 if ( (m_style
& wxAUI_TB_TEXT
) &&
1826 m_tool_text_orientation
== wxAUI_TBTOOL_TEXT_BOTTOM
&&
1827 !item
.GetLabel().empty() )
1829 wxSize s
= GetLabelSize(item
.GetLabel());
1830 vert_sizer
->Add(1, s
.y
);
1834 sizer_item
= sizer
->Add(vert_sizer
, item
.proportion
, wxEXPAND
);
1836 wxSize min_size
= item
.min_size
;
1839 // proportional items will disappear from the toolbar if
1840 // their min width is not set to something really small
1841 if (item
.proportion
!= 0)
1846 if (min_size
.IsFullySpecified())
1848 sizer_item
->SetMinSize(min_size
);
1849 ctrl_sizer_item
->SetMinSize(min_size
);
1855 sizer
->AddSpacer(m_tool_packing
);
1860 item
.sizer_item
= sizer_item
;
1863 // add "right" padding
1864 if (m_right_padding
> 0)
1867 sizer
->Add(m_right_padding
, 1);
1869 sizer
->Add(1, m_right_padding
);
1872 // add drop down area
1873 m_overflow_sizer_item
= NULL
;
1875 if (m_style
& wxAUI_TB_OVERFLOW
)
1877 int overflow_size
= m_art
->GetElementSize(wxAUI_TBART_OVERFLOW_SIZE
);
1878 if (overflow_size
> 0 && m_overflow_visible
)
1881 m_overflow_sizer_item
= sizer
->Add(overflow_size
, 1, 0, wxEXPAND
);
1883 m_overflow_sizer_item
= sizer
->Add(1, overflow_size
, 0, wxEXPAND
);
1887 m_overflow_sizer_item
= NULL
;
1892 // the outside sizer helps us apply the "top" and "bottom" padding
1893 wxBoxSizer
* outside_sizer
= new wxBoxSizer(horizontal ? wxVERTICAL
: wxHORIZONTAL
);
1895 // add "top" padding
1896 if (m_top_padding
> 0)
1899 outside_sizer
->Add(1, m_top_padding
);
1901 outside_sizer
->Add(m_top_padding
, 1);
1904 // add the sizer that contains all of the toolbar elements
1905 outside_sizer
->Add(sizer
, 1, wxEXPAND
);
1907 // add "bottom" padding
1908 if (m_bottom_padding
> 0)
1911 outside_sizer
->Add(1, m_bottom_padding
);
1913 outside_sizer
->Add(m_bottom_padding
, 1);
1916 delete m_sizer
; // remove old sizer
1917 m_sizer
= outside_sizer
;
1919 // calculate the rock-bottom minimum size
1920 for (i
= 0, count
= m_items
.GetCount(); i
< count
; ++i
)
1922 wxAuiToolBarItem
& item
= m_items
.Item(i
);
1923 if (item
.sizer_item
&& item
.proportion
> 0 && item
.min_size
.IsFullySpecified())
1924 item
.sizer_item
->SetMinSize(0,0);
1927 m_absolute_min_size
= m_sizer
->GetMinSize();
1929 // reset the min sizes to what they were
1930 for (i
= 0, count
= m_items
.GetCount(); i
< count
; ++i
)
1932 wxAuiToolBarItem
& item
= m_items
.Item(i
);
1933 if (item
.sizer_item
&& item
.proportion
> 0 && item
.min_size
.IsFullySpecified())
1934 item
.sizer_item
->SetMinSize(item
.min_size
);
1938 wxSize size
= m_sizer
->GetMinSize();
1939 m_minWidth
= size
.x
;
1940 m_minHeight
= size
.y
;
1942 if ((m_style
& wxAUI_TB_NO_AUTORESIZE
) == 0)
1944 wxSize cur_size
= GetClientSize();
1945 wxSize new_size
= GetMinSize();
1946 if (new_size
!= cur_size
)
1948 SetClientSize(new_size
);
1952 m_sizer
->SetDimension(0, 0, cur_size
.x
, cur_size
.y
);
1957 wxSize cur_size
= GetClientSize();
1958 m_sizer
->SetDimension(0, 0, cur_size
.x
, cur_size
.y
);
1965 int wxAuiToolBar
::GetOverflowState() const
1967 return m_overflow_state
;
1970 wxRect wxAuiToolBar
::GetOverflowRect() const
1972 wxRect
cli_rect(wxPoint(0,0), GetClientSize());
1973 wxRect overflow_rect
= m_overflow_sizer_item
->GetRect();
1974 int overflow_size
= m_art
->GetElementSize(wxAUI_TBART_OVERFLOW_SIZE
);
1976 if (m_style
& wxAUI_TB_VERTICAL
)
1978 overflow_rect
.y
= cli_rect
.height
- overflow_size
;
1979 overflow_rect
.x
= 0;
1980 overflow_rect
.width
= cli_rect
.width
;
1981 overflow_rect
.height
= overflow_size
;
1985 overflow_rect
.x
= cli_rect
.width
- overflow_size
;
1986 overflow_rect
.y
= 0;
1987 overflow_rect
.width
= overflow_size
;
1988 overflow_rect
.height
= cli_rect
.height
;
1991 return overflow_rect
;
1994 wxSize wxAuiToolBar
::GetLabelSize(const wxString
& label
)
1996 wxClientDC
dc(this);
1999 int text_width
= 0, text_height
= 0;
2003 // get the text height
2004 dc
.GetTextExtent(wxT("ABCDHgj"), &tx
, &text_height
);
2006 // get the text width
2007 dc
.GetTextExtent(label
, &text_width
, &ty
);
2009 return wxSize(text_width
, text_height
);
2013 void wxAuiToolBar
::DoIdleUpdate()
2015 wxEvtHandler
* handler
= GetEventHandler();
2017 bool need_refresh
= false;
2020 for (i
= 0, count
= m_items
.GetCount(); i
< count
; ++i
)
2022 wxAuiToolBarItem
& item
= m_items
.Item(i
);
2027 wxUpdateUIEvent
evt(item
.id
);
2028 evt
.SetEventObject(this);
2030 if (handler
->ProcessEvent(evt
))
2032 if (evt
.GetSetEnabled())
2036 is_enabled
= item
.window
->IsEnabled();
2038 is_enabled
= (item
.state
& wxAUI_BUTTON_STATE_DISABLED
) ?
false : true;
2040 bool new_enabled
= evt
.GetEnabled();
2041 if (new_enabled
!= is_enabled
)
2045 item
.window
->Enable(new_enabled
);
2050 item
.state
&= ~wxAUI_BUTTON_STATE_DISABLED
;
2052 item
.state
|= wxAUI_BUTTON_STATE_DISABLED
;
2054 need_refresh
= true;
2058 if (evt
.GetSetChecked())
2060 // make sure we aren't checking an item that can't be
2061 if (item
.kind
!= wxITEM_CHECK
&& item
.kind
!= wxITEM_RADIO
)
2064 bool is_checked
= (item
.state
& wxAUI_BUTTON_STATE_CHECKED
) ?
true : false;
2065 bool new_checked
= evt
.GetChecked();
2067 if (new_checked
!= is_checked
)
2070 item
.state
|= wxAUI_BUTTON_STATE_CHECKED
;
2072 item
.state
&= ~wxAUI_BUTTON_STATE_CHECKED
;
2074 need_refresh
= true;
2089 void wxAuiToolBar
::OnSize(wxSizeEvent
& WXUNUSED(evt
))
2092 GetClientSize(&x
, &y
);
2095 SetOrientation(wxHORIZONTAL
);
2097 SetOrientation(wxVERTICAL
);
2099 if (((x
>= y
) && m_absolute_min_size
.x
> x
) ||
2100 ((y
> x
) && m_absolute_min_size
.y
> y
))
2102 // hide all flexible items
2104 for (i
= 0, count
= m_items
.GetCount(); i
< count
; ++i
)
2106 wxAuiToolBarItem
& item
= m_items
.Item(i
);
2107 if (item
.sizer_item
&& item
.proportion
> 0 && item
.sizer_item
->IsShown())
2109 item
.sizer_item
->Show(false);
2110 item
.sizer_item
->SetProportion(0);
2116 // show all flexible items
2118 for (i
= 0, count
= m_items
.GetCount(); i
< count
; ++i
)
2120 wxAuiToolBarItem
& item
= m_items
.Item(i
);
2121 if (item
.sizer_item
&& item
.proportion
> 0 && !item
.sizer_item
->IsShown())
2123 item
.sizer_item
->Show(true);
2124 item
.sizer_item
->SetProportion(item
.proportion
);
2129 m_sizer
->SetDimension(0, 0, x
, y
);
2137 void wxAuiToolBar
::DoSetSize(int x
,
2143 wxSize parent_size
= GetParent()->GetClientSize();
2144 if (x
+ width
> parent_size
.x
)
2145 width
= wxMax(0, parent_size
.x
- x
);
2146 if (y
+ height
> parent_size
.y
)
2147 height
= wxMax(0, parent_size
.y
- y
);
2149 wxWindow
::DoSetSize(x
, y
, width
, height
, sizeFlags
);
2153 void wxAuiToolBar
::OnIdle(wxIdleEvent
& evt
)
2159 void wxAuiToolBar
::OnPaint(wxPaintEvent
& WXUNUSED(evt
))
2161 wxBufferedPaintDC
dc(this);
2162 wxRect
cli_rect(wxPoint(0,0), GetClientSize());
2165 bool horizontal
= true;
2166 if (m_style
& wxAUI_TB_VERTICAL
)
2170 m_art
->DrawBackground(dc
, this, cli_rect
);
2172 int gripper_size
= m_art
->GetElementSize(wxAUI_TBART_GRIPPER_SIZE
);
2173 int dropdown_size
= m_art
->GetElementSize(wxAUI_TBART_OVERFLOW_SIZE
);
2175 // paint the gripper
2176 if (gripper_size
> 0 && m_gripper_sizer_item
)
2178 wxRect gripper_rect
= m_gripper_sizer_item
->GetRect();
2180 gripper_rect
.width
= gripper_size
;
2182 gripper_rect
.height
= gripper_size
;
2183 m_art
->DrawGripper(dc
, this, gripper_rect
);
2186 // calculated how far we can draw items
2189 last_extent
= cli_rect
.width
;
2191 last_extent
= cli_rect
.height
;
2192 if (m_overflow_visible
)
2193 last_extent
-= dropdown_size
;
2195 // paint each individual tool
2196 size_t i
, count
= m_items
.GetCount();
2197 for (i
= 0; i
< count
; ++i
)
2199 wxAuiToolBarItem
& item
= m_items
.Item(i
);
2201 if (!item
.sizer_item
)
2204 wxRect item_rect
= item
.sizer_item
->GetRect();
2207 if ((horizontal
&& item_rect
.x
+ item_rect
.width
>= last_extent
) ||
2208 (!horizontal
&& item_rect
.y
+ item_rect
.height
>= last_extent
))
2213 if (item
.kind
== wxITEM_SEPARATOR
)
2216 m_art
->DrawSeparator(dc
, this, item_rect
);
2218 else if (item
.kind
== wxITEM_LABEL
)
2220 // draw a text label only
2221 m_art
->DrawLabel(dc
, this, item
, item_rect
);
2223 else if (item
.kind
== wxITEM_NORMAL
)
2225 // draw a regular button or dropdown button
2227 m_art
->DrawButton(dc
, this, item
, item_rect
);
2229 m_art
->DrawDropDownButton(dc
, this, item
, item_rect
);
2231 else if (item
.kind
== wxITEM_CHECK
)
2233 // draw a toggle button
2234 m_art
->DrawButton(dc
, this, item
, item_rect
);
2236 else if (item
.kind
== wxITEM_RADIO
)
2238 // draw a toggle button
2239 m_art
->DrawButton(dc
, this, item
, item_rect
);
2241 else if (item
.kind
== wxITEM_CONTROL
)
2243 // draw the control's label
2244 m_art
->DrawControlLabel(dc
, this, item
, item_rect
);
2247 // fire a signal to see if the item wants to be custom-rendered
2248 OnCustomRender(dc
, item
, item_rect
);
2251 // paint the overflow button
2252 if (dropdown_size
> 0 && m_overflow_sizer_item
)
2254 wxRect dropdown_rect
= GetOverflowRect();
2255 m_art
->DrawOverflowButton(dc
, this, dropdown_rect
, m_overflow_state
);
2259 void wxAuiToolBar
::OnEraseBackground(wxEraseEvent
& WXUNUSED(evt
))
2264 void wxAuiToolBar
::OnLeftDown(wxMouseEvent
& evt
)
2266 wxRect
cli_rect(wxPoint(0,0), GetClientSize());
2268 if (m_gripper_sizer_item
)
2270 wxRect gripper_rect
= m_gripper_sizer_item
->GetRect();
2271 if (gripper_rect
.Contains(evt
.GetX(), evt
.GetY()))
2274 wxAuiManager
* manager
= wxAuiManager
::GetManager(this);
2278 int x_drag_offset
= evt
.GetX() - gripper_rect
.GetX();
2279 int y_drag_offset
= evt
.GetY() - gripper_rect
.GetY();
2281 // gripper was clicked
2282 manager
->StartPaneDrag(this, wxPoint(x_drag_offset
, y_drag_offset
));
2287 if (m_overflow_sizer_item
)
2289 wxRect overflow_rect
= GetOverflowRect();
2292 m_overflow_visible
&&
2293 overflow_rect
.Contains(evt
.m_x
, evt
.m_y
))
2295 wxAuiToolBarEvent
e(wxEVT_COMMAND_AUITOOLBAR_OVERFLOW_CLICK
, -1);
2296 e
.SetEventObject(this);
2298 e
.SetClickPoint(wxPoint(evt
.GetX(), evt
.GetY()));
2299 bool processed
= GetEventHandler()->ProcessEvent(e
);
2308 wxAuiToolBarItemArray overflow_items
;
2311 // add custom overflow prepend items, if any
2312 count
= m_custom_overflow_prepend
.GetCount();
2313 for (i
= 0; i
< count
; ++i
)
2314 overflow_items
.Add(m_custom_overflow_prepend
[i
]);
2316 // only show items that don't fit in the dropdown
2317 count
= m_items
.GetCount();
2318 for (i
= 0; i
< count
; ++i
)
2320 if (!GetToolFitsByIndex(i
))
2321 overflow_items
.Add(m_items
[i
]);
2324 // add custom overflow append items, if any
2325 count
= m_custom_overflow_append
.GetCount();
2326 for (i
= 0; i
< count
; ++i
)
2327 overflow_items
.Add(m_custom_overflow_append
[i
]);
2329 int res
= m_art
->ShowDropDown(this, overflow_items
);
2330 m_overflow_state
= 0;
2334 wxCommandEvent
e(wxEVT_COMMAND_MENU_SELECTED
, res
);
2335 e
.SetEventObject(this);
2336 GetParent()->GetEventHandler()->ProcessEvent(e
);
2345 m_action_pos
= wxPoint(evt
.GetX(), evt
.GetY());
2346 m_action_item
= FindToolByPosition(evt
.GetX(), evt
.GetY());
2350 if (m_action_item
->state
& wxAUI_BUTTON_STATE_DISABLED
)
2352 m_action_pos
= wxPoint(-1,-1);
2353 m_action_item
= NULL
;
2357 SetPressedItem(m_action_item
);
2359 // fire the tool dropdown event
2360 wxAuiToolBarEvent
e(wxEVT_COMMAND_AUITOOLBAR_TOOL_DROPDOWN
, m_action_item
->id
);
2361 e
.SetEventObject(this);
2362 e
.SetToolId(m_action_item
->id
);
2363 e
.SetDropDownClicked(false);
2365 int mouse_x
= evt
.GetX();
2366 wxRect rect
= m_action_item
->sizer_item
->GetRect();
2368 if (m_action_item
->dropdown
&&
2369 mouse_x
>= (rect
.x
+rect
.width
-BUTTON_DROPDOWN_WIDTH
-1) &&
2370 mouse_x
< (rect
.x
+rect
.width
))
2372 e
.SetDropDownClicked(true);
2375 e
.SetClickPoint(evt
.GetPosition());
2376 e
.SetItemRect(rect
);
2377 GetEventHandler()->ProcessEvent(e
);
2382 void wxAuiToolBar
::OnLeftUp(wxMouseEvent
& evt
)
2384 SetPressedItem(NULL
);
2386 wxAuiToolBarItem
* hit_item
= FindToolByPosition(evt
.GetX(), evt
.GetY());
2387 if (hit_item
&& !(hit_item
->state
& wxAUI_BUTTON_STATE_DISABLED
))
2389 SetHoverItem(hit_item
);
2395 // reset drag and drop member variables
2397 m_action_pos
= wxPoint(-1,-1);
2398 m_action_item
= NULL
;
2403 wxAuiToolBarItem
* hit_item
;
2404 hit_item
= FindToolByPosition(evt
.GetX(), evt
.GetY());
2406 if (m_action_item
&& hit_item
== m_action_item
)
2410 if (hit_item
->kind
== wxITEM_CHECK
|| hit_item
->kind
== wxITEM_RADIO
)
2412 bool toggle
= false;
2414 if (m_action_item
->state
& wxAUI_BUTTON_STATE_CHECKED
)
2419 ToggleTool(m_action_item
->id
, toggle
);
2421 // repaint immediately
2425 wxCommandEvent
e(wxEVT_COMMAND_MENU_SELECTED
, m_action_item
->id
);
2426 e
.SetEventObject(this);
2427 GetEventHandler()->ProcessEvent(e
);
2432 wxCommandEvent
e(wxEVT_COMMAND_MENU_SELECTED
, m_action_item
->id
);
2433 e
.SetEventObject(this);
2434 GetEventHandler()->ProcessEvent(e
);
2440 // reset drag and drop member variables
2442 m_action_pos
= wxPoint(-1,-1);
2443 m_action_item
= NULL
;
2446 void wxAuiToolBar
::OnRightDown(wxMouseEvent
& evt
)
2448 wxRect
cli_rect(wxPoint(0,0), GetClientSize());
2450 if (m_gripper_sizer_item
)
2452 wxRect gripper_rect
= m_gripper_sizer_item
->GetRect();
2453 if (gripper_rect
.Contains(evt
.GetX(), evt
.GetY()))
2457 if (m_overflow_sizer_item
)
2459 int dropdown_size
= m_art
->GetElementSize(wxAUI_TBART_OVERFLOW_SIZE
);
2460 if (dropdown_size
> 0 &&
2461 evt
.m_x
> cli_rect
.width
- dropdown_size
&&
2463 evt
.m_y
< cli_rect
.height
&&
2470 m_action_pos
= wxPoint(evt
.GetX(), evt
.GetY());
2471 m_action_item
= FindToolByPosition(evt
.GetX(), evt
.GetY());
2475 if (m_action_item
->state
& wxAUI_BUTTON_STATE_DISABLED
)
2477 m_action_pos
= wxPoint(-1,-1);
2478 m_action_item
= NULL
;
2484 void wxAuiToolBar
::OnRightUp(wxMouseEvent
& evt
)
2486 wxAuiToolBarItem
* hit_item
;
2487 hit_item
= FindToolByPosition(evt
.GetX(), evt
.GetY());
2489 if (m_action_item
&& hit_item
== m_action_item
)
2491 if (hit_item
->kind
== wxITEM_NORMAL
)
2493 wxAuiToolBarEvent
e(wxEVT_COMMAND_AUITOOLBAR_RIGHT_CLICK
, m_action_item
->id
);
2494 e
.SetEventObject(this);
2495 e
.SetToolId(m_action_item
->id
);
2496 e
.SetClickPoint(m_action_pos
);
2497 GetEventHandler()->ProcessEvent(e
);
2503 // right-clicked on the invalid area of the toolbar
2504 wxAuiToolBarEvent
e(wxEVT_COMMAND_AUITOOLBAR_RIGHT_CLICK
, -1);
2505 e
.SetEventObject(this);
2507 e
.SetClickPoint(m_action_pos
);
2508 GetEventHandler()->ProcessEvent(e
);
2512 // reset member variables
2513 m_action_pos
= wxPoint(-1,-1);
2514 m_action_item
= NULL
;
2517 void wxAuiToolBar
::OnMiddleDown(wxMouseEvent
& evt
)
2519 wxRect
cli_rect(wxPoint(0,0), GetClientSize());
2521 if (m_gripper_sizer_item
)
2523 wxRect gripper_rect
= m_gripper_sizer_item
->GetRect();
2524 if (gripper_rect
.Contains(evt
.GetX(), evt
.GetY()))
2528 if (m_overflow_sizer_item
)
2530 int dropdown_size
= m_art
->GetElementSize(wxAUI_TBART_OVERFLOW_SIZE
);
2531 if (dropdown_size
> 0 &&
2532 evt
.m_x
> cli_rect
.width
- dropdown_size
&&
2534 evt
.m_y
< cli_rect
.height
&&
2541 m_action_pos
= wxPoint(evt
.GetX(), evt
.GetY());
2542 m_action_item
= FindToolByPosition(evt
.GetX(), evt
.GetY());
2546 if (m_action_item
->state
& wxAUI_BUTTON_STATE_DISABLED
)
2548 m_action_pos
= wxPoint(-1,-1);
2549 m_action_item
= NULL
;
2555 void wxAuiToolBar
::OnMiddleUp(wxMouseEvent
& evt
)
2557 wxAuiToolBarItem
* hit_item
;
2558 hit_item
= FindToolByPosition(evt
.GetX(), evt
.GetY());
2560 if (m_action_item
&& hit_item
== m_action_item
)
2562 if (hit_item
->kind
== wxITEM_NORMAL
)
2564 wxAuiToolBarEvent
e(wxEVT_COMMAND_AUITOOLBAR_MIDDLE_CLICK
, m_action_item
->id
);
2565 e
.SetEventObject(this);
2566 e
.SetToolId(m_action_item
->id
);
2567 e
.SetClickPoint(m_action_pos
);
2568 GetEventHandler()->ProcessEvent(e
);
2573 // reset member variables
2574 m_action_pos
= wxPoint(-1,-1);
2575 m_action_item
= NULL
;
2578 void wxAuiToolBar
::OnMotion(wxMouseEvent
& evt
)
2580 // start a drag event
2582 m_action_item
!= NULL
&&
2583 m_action_pos
!= wxPoint(-1,-1) &&
2584 abs(evt
.m_x
- m_action_pos
.x
) + abs(evt
.m_y
- m_action_pos
.y
) > 5)
2590 wxAuiToolBarEvent
e(wxEVT_COMMAND_AUITOOLBAR_BEGIN_DRAG
, GetId());
2591 e
.SetEventObject(this);
2592 e
.SetToolId(m_action_item
->id
);
2593 GetEventHandler()->ProcessEvent(e
);
2598 wxAuiToolBarItem
* hit_item
= FindToolByPosition(evt
.GetX(), evt
.GetY());
2601 if (!(hit_item
->state
& wxAUI_BUTTON_STATE_DISABLED
))
2602 SetHoverItem(hit_item
);
2608 // no hit item, remove any hit item
2609 SetHoverItem(hit_item
);
2612 // figure out tooltips
2613 wxAuiToolBarItem
* packing_hit_item
;
2614 packing_hit_item
= FindToolByPositionWithPacking(evt
.GetX(), evt
.GetY());
2615 if (packing_hit_item
)
2617 if (packing_hit_item
!= m_tip_item
)
2619 m_tip_item
= packing_hit_item
;
2621 if ( !packing_hit_item
->short_help
.empty() )
2622 SetToolTip(packing_hit_item
->short_help
);
2633 // if we've pressed down an item and we're hovering
2634 // over it, make sure it's state is set to pressed
2637 if (m_action_item
== hit_item
)
2638 SetPressedItem(m_action_item
);
2640 SetPressedItem(NULL
);
2643 // figure out the dropdown button state (are we hovering or pressing it?)
2644 RefreshOverflowState();
2647 void wxAuiToolBar
::OnLeaveWindow(wxMouseEvent
& WXUNUSED(evt
))
2649 RefreshOverflowState();
2651 SetPressedItem(NULL
);
2657 void wxAuiToolBar
::OnSetCursor(wxSetCursorEvent
& evt
)
2659 wxCursor cursor
= wxNullCursor
;
2661 if (m_gripper_sizer_item
)
2663 wxRect gripper_rect
= m_gripper_sizer_item
->GetRect();
2664 if (gripper_rect
.Contains(evt
.GetX(), evt
.GetY()))
2666 cursor
= wxCursor(wxCURSOR_SIZING
);
2670 evt
.SetCursor(cursor
);