]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/aui/auibar.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Rename wxWebFileHandler name from test to file.
[wxWidgets.git] / src / aui / auibar.cpp
... / ...
CommitLineData
1///////////////////////////////////////////////////////////////////////////////
2
3// Name: src/aui/auibar.cpp
4// Purpose: wxaui: wx advanced user interface - docking window manager
5// Author: Benjamin I. Williams
6// Modified by:
7// Created: 2005-05-17
8// RCS-ID: $Id$
9// Copyright: (C) Copyright 2005-2006, Kirix Corporation, All Rights Reserved
10// Licence: wxWindows Library Licence, Version 3.1
11///////////////////////////////////////////////////////////////////////////////
12
13// ============================================================================
14// declarations
15// ============================================================================
16
17// ----------------------------------------------------------------------------
18// headers
19// ----------------------------------------------------------------------------
20
21#include "wx/wxprec.h"
22
23#ifdef __BORLANDC__
24 #pragma hdrstop
25#endif
26
27#if wxUSE_AUI
28
29#include "wx/statline.h"
30#include "wx/dcbuffer.h"
31#include "wx/sizer.h"
32#include "wx/image.h"
33#include "wx/settings.h"
34#include "wx/menu.h"
35
36#include "wx/aui/auibar.h"
37#include "wx/aui/framemanager.h"
38
39#ifdef __WXMAC__
40#include "wx/osx/private.h"
41#endif
42
43#include "wx/arrimpl.cpp"
44WX_DEFINE_OBJARRAY(wxAuiToolBarItemArray)
45
46
47wxDEFINE_EVENT( wxEVT_COMMAND_AUITOOLBAR_TOOL_DROPDOWN, wxAuiToolBarEvent );
48wxDEFINE_EVENT( wxEVT_COMMAND_AUITOOLBAR_OVERFLOW_CLICK, wxAuiToolBarEvent );
49wxDEFINE_EVENT( wxEVT_COMMAND_AUITOOLBAR_RIGHT_CLICK, wxAuiToolBarEvent );
50wxDEFINE_EVENT( wxEVT_COMMAND_AUITOOLBAR_MIDDLE_CLICK, wxAuiToolBarEvent );
51wxDEFINE_EVENT( wxEVT_COMMAND_AUITOOLBAR_BEGIN_DRAG, wxAuiToolBarEvent );
52
53
54IMPLEMENT_CLASS(wxAuiToolBar, wxControl)
55IMPLEMENT_DYNAMIC_CLASS(wxAuiToolBarEvent, wxEvent)
56
57
58// missing wxITEM_* items
59enum
60{
61 wxITEM_CONTROL = wxITEM_MAX,
62 wxITEM_LABEL,
63 wxITEM_SPACER
64};
65
66const int BUTTON_DROPDOWN_WIDTH = 10;
67
68
69wxBitmap wxAuiBitmapFromBits(const unsigned char bits[], int w, int h,
70 const wxColour& color);
71
72static wxColor GetBaseColor()
73{
74
75#if defined( __WXMAC__ ) && wxOSX_USE_COCOA_OR_CARBON
76 wxColor base_colour = wxColour( wxMacCreateCGColorFromHITheme(kThemeBrushToolbarBackground));
77#else
78 wxColor base_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
79#endif
80
81 // the base_colour is too pale to use as our base colour,
82 // so darken it a bit --
83 if ((255-base_colour.Red()) +
84 (255-base_colour.Green()) +
85 (255-base_colour.Blue()) < 60)
86 {
87 base_colour = base_colour.ChangeLightness(92);
88 }
89
90 return base_colour;
91}
92
93
94
95class ToolbarCommandCapture : public wxEvtHandler
96{
97public:
98
99 ToolbarCommandCapture() { m_last_id = 0; }
100 int GetCommandId() const { return m_last_id; }
101
102 bool ProcessEvent(wxEvent& evt)
103 {
104 if (evt.GetEventType() == wxEVT_COMMAND_MENU_SELECTED)
105 {
106 m_last_id = evt.GetId();
107 return true;
108 }
109
110 if (GetNextHandler())
111 return GetNextHandler()->ProcessEvent(evt);
112
113 return false;
114 }
115
116private:
117 int m_last_id;
118};
119
120
121
122static const unsigned char
123 DISABLED_TEXT_GREY_HUE = wxColour::AlphaBlend(0, 255, 0.4);
124const wxColour DISABLED_TEXT_COLOR(DISABLED_TEXT_GREY_HUE,
125 DISABLED_TEXT_GREY_HUE,
126 DISABLED_TEXT_GREY_HUE);
127
128wxAuiDefaultToolBarArt::wxAuiDefaultToolBarArt()
129{
130 m_base_colour = GetBaseColor();
131
132 m_flags = 0;
133 m_text_orientation = wxAUI_TBTOOL_TEXT_BOTTOM;
134 m_highlight_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
135
136 m_separator_size = 7;
137 m_gripper_size = 7;
138 m_overflow_size = 16;
139
140 wxColor darker1_colour = m_base_colour.ChangeLightness(85);
141 wxColor darker2_colour = m_base_colour.ChangeLightness(75);
142 wxColor darker3_colour = m_base_colour.ChangeLightness(60);
143 wxColor darker4_colour = m_base_colour.ChangeLightness(50);
144 wxColor darker5_colour = m_base_colour.ChangeLightness(40);
145
146 m_gripper_pen1 = wxPen(darker5_colour);
147 m_gripper_pen2 = wxPen(darker3_colour);
148 m_gripper_pen3 = *wxWHITE_PEN;
149
150 static const unsigned char button_dropdown_bits[] = { 0xe0, 0xf1, 0xfb };
151 static const unsigned char overflow_bits[] = { 0x80, 0xff, 0x80, 0xc1, 0xe3, 0xf7 };
152
153 m_button_dropdown_bmp = wxAuiBitmapFromBits(button_dropdown_bits, 5, 3,
154 *wxBLACK);
155 m_disabled_button_dropdown_bmp = wxAuiBitmapFromBits(
156 button_dropdown_bits, 5, 3,
157 wxColor(128,128,128));
158 m_overflow_bmp = wxAuiBitmapFromBits(overflow_bits, 7, 6, *wxBLACK);
159 m_disabled_overflow_bmp = wxAuiBitmapFromBits(overflow_bits, 7, 6, wxColor(128,128,128));
160
161 m_font = *wxNORMAL_FONT;
162}
163
164wxAuiDefaultToolBarArt::~wxAuiDefaultToolBarArt()
165{
166 m_font = *wxNORMAL_FONT;
167}
168
169
170wxAuiToolBarArt* wxAuiDefaultToolBarArt::Clone()
171{
172 return static_cast<wxAuiToolBarArt*>(new wxAuiDefaultToolBarArt);
173}
174
175void wxAuiDefaultToolBarArt::SetFlags(unsigned int flags)
176{
177 m_flags = flags;
178}
179
180void wxAuiDefaultToolBarArt::SetFont(const wxFont& font)
181{
182 m_font = font;
183}
184
185void wxAuiDefaultToolBarArt::SetTextOrientation(int orientation)
186{
187 m_text_orientation = orientation;
188}
189
190unsigned int wxAuiDefaultToolBarArt::GetFlags()
191{
192 return m_flags;
193}
194
195wxFont wxAuiDefaultToolBarArt::GetFont()
196{
197 return m_font;
198}
199
200int wxAuiDefaultToolBarArt::GetTextOrientation()
201{
202 return m_text_orientation;
203}
204
205void wxAuiDefaultToolBarArt::DrawBackground(
206 wxDC& dc,
207 wxWindow* WXUNUSED(wnd),
208 const wxRect& _rect)
209{
210 wxRect rect = _rect;
211 rect.height++;
212 wxColour start_colour = m_base_colour.ChangeLightness(150);
213 wxColour end_colour = m_base_colour.ChangeLightness(90);
214 dc.GradientFillLinear(rect, start_colour, end_colour, wxSOUTH);
215}
216
217void wxAuiDefaultToolBarArt::DrawLabel(
218 wxDC& dc,
219 wxWindow* WXUNUSED(wnd),
220 const wxAuiToolBarItem& item,
221 const wxRect& rect)
222{
223 dc.SetFont(m_font);
224 dc.SetTextForeground(*wxBLACK);
225
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 text_width = 0, text_height = 0;
229 dc.GetTextExtent(wxT("ABCDHgj"), &text_width, &text_height);
230
231 // set the clipping region
232 wxRect clip_rect = rect;
233 clip_rect.width -= 1;
234 dc.SetClippingRegion(clip_rect);
235
236 int text_x, text_y;
237 text_x = rect.x + 1;
238 text_y = rect.y + (rect.height-text_height)/2;
239 dc.DrawText(item.GetLabel(), text_x, text_y);
240 dc.DestroyClippingRegion();
241}
242
243
244void wxAuiDefaultToolBarArt::DrawButton(
245 wxDC& dc,
246 wxWindow* WXUNUSED(wnd),
247 const wxAuiToolBarItem& item,
248 const wxRect& rect)
249{
250 int text_width = 0, text_height = 0;
251
252 if (m_flags & wxAUI_TB_TEXT)
253 {
254 dc.SetFont(m_font);
255
256 int tx, ty;
257
258 dc.GetTextExtent(wxT("ABCDHgj"), &tx, &text_height);
259 text_width = 0;
260 dc.GetTextExtent(item.GetLabel(), &text_width, &ty);
261 }
262
263 int bmp_x = 0, bmp_y = 0;
264 int text_x = 0, text_y = 0;
265
266 if (m_text_orientation == wxAUI_TBTOOL_TEXT_BOTTOM)
267 {
268 bmp_x = rect.x +
269 (rect.width/2) -
270 (item.GetBitmap().GetWidth()/2);
271
272 bmp_y = rect.y +
273 ((rect.height-text_height)/2) -
274 (item.GetBitmap().GetHeight()/2);
275
276 text_x = rect.x + (rect.width/2) - (text_width/2) + 1;
277 text_y = rect.y + rect.height - text_height - 1;
278 }
279 else if (m_text_orientation == wxAUI_TBTOOL_TEXT_RIGHT)
280 {
281 bmp_x = rect.x + 3;
282
283 bmp_y = rect.y +
284 (rect.height/2) -
285 (item.GetBitmap().GetHeight()/2);
286
287 text_x = bmp_x + 3 + item.GetBitmap().GetWidth();
288 text_y = rect.y +
289 (rect.height/2) -
290 (text_height/2);
291 }
292
293
294 if (!(item.GetState() & wxAUI_BUTTON_STATE_DISABLED))
295 {
296 if (item.GetState() & wxAUI_BUTTON_STATE_PRESSED)
297 {
298 dc.SetPen(wxPen(m_highlight_colour));
299 dc.SetBrush(wxBrush(m_highlight_colour.ChangeLightness(150)));
300 dc.DrawRectangle(rect);
301 }
302 else if ((item.GetState() & wxAUI_BUTTON_STATE_HOVER) || item.IsSticky())
303 {
304 dc.SetPen(wxPen(m_highlight_colour));
305 dc.SetBrush(wxBrush(m_highlight_colour.ChangeLightness(170)));
306
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_highlight_colour.ChangeLightness(180)));
311
312 dc.DrawRectangle(rect);
313 }
314 else if (item.GetState() & wxAUI_BUTTON_STATE_CHECKED)
315 {
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_highlight_colour));
319 dc.SetBrush(wxBrush(m_highlight_colour.ChangeLightness(170)));
320 dc.DrawRectangle(rect);
321 }
322 }
323
324 wxBitmap bmp;
325 if (item.GetState() & wxAUI_BUTTON_STATE_DISABLED)
326 bmp = item.GetDisabledBitmap();
327 else
328 bmp = item.GetBitmap();
329
330 if ( bmp.IsOk() )
331 dc.DrawBitmap(bmp, bmp_x, bmp_y, true);
332
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);
337
338 if ( (m_flags & wxAUI_TB_TEXT) && !item.GetLabel().empty() )
339 {
340 dc.DrawText(item.GetLabel(), text_x, text_y);
341 }
342}
343
344
345void wxAuiDefaultToolBarArt::DrawDropDownButton(
346 wxDC& dc,
347 wxWindow* WXUNUSED(wnd),
348 const wxAuiToolBarItem& item,
349 const wxRect& rect)
350{
351 int text_width = 0, text_height = 0, text_x = 0, text_y = 0;
352 int bmp_x = 0, bmp_y = 0, dropbmp_x = 0, dropbmp_y = 0;
353
354 wxRect button_rect = wxRect(rect.x,
355 rect.y,
356 rect.width-BUTTON_DROPDOWN_WIDTH,
357 rect.height);
358 wxRect dropdown_rect = wxRect(rect.x+rect.width-BUTTON_DROPDOWN_WIDTH-1,
359 rect.y,
360 BUTTON_DROPDOWN_WIDTH+1,
361 rect.height);
362
363 if (m_flags & wxAUI_TB_TEXT)
364 {
365 dc.SetFont(m_font);
366
367 int tx, ty;
368 if (m_flags & wxAUI_TB_TEXT)
369 {
370 dc.GetTextExtent(wxT("ABCDHgj"), &tx, &text_height);
371 text_width = 0;
372 }
373
374 dc.GetTextExtent(item.GetLabel(), &text_width, &ty);
375 }
376
377
378
379 dropbmp_x = dropdown_rect.x +
380 (dropdown_rect.width/2) -
381 (m_button_dropdown_bmp.GetWidth()/2);
382 dropbmp_y = dropdown_rect.y +
383 (dropdown_rect.height/2) -
384 (m_button_dropdown_bmp.GetHeight()/2);
385
386
387 if (m_text_orientation == wxAUI_TBTOOL_TEXT_BOTTOM)
388 {
389 bmp_x = button_rect.x +
390 (button_rect.width/2) -
391 (item.GetBitmap().GetWidth()/2);
392 bmp_y = button_rect.y +
393 ((button_rect.height-text_height)/2) -
394 (item.GetBitmap().GetHeight()/2);
395
396 text_x = rect.x + (rect.width/2) - (text_width/2) + 1;
397 text_y = rect.y + rect.height - text_height - 1;
398 }
399 else if (m_text_orientation == wxAUI_TBTOOL_TEXT_RIGHT)
400 {
401 bmp_x = rect.x + 3;
402
403 bmp_y = rect.y +
404 (rect.height/2) -
405 (item.GetBitmap().GetHeight()/2);
406
407 text_x = bmp_x + 3 + item.GetBitmap().GetWidth();
408 text_y = rect.y +
409 (rect.height/2) -
410 (text_height/2);
411 }
412
413
414 if (item.GetState() & wxAUI_BUTTON_STATE_PRESSED)
415 {
416 dc.SetPen(wxPen(m_highlight_colour));
417 dc.SetBrush(wxBrush(m_highlight_colour.ChangeLightness(140)));
418 dc.DrawRectangle(button_rect);
419
420 dc.SetBrush(wxBrush(m_highlight_colour.ChangeLightness(170)));
421 dc.DrawRectangle(dropdown_rect);
422 }
423 else if (item.GetState() & wxAUI_BUTTON_STATE_HOVER ||
424 item.IsSticky())
425 {
426 dc.SetPen(wxPen(m_highlight_colour));
427 dc.SetBrush(wxBrush(m_highlight_colour.ChangeLightness(170)));
428 dc.DrawRectangle(button_rect);
429 dc.DrawRectangle(dropdown_rect);
430 }
431 else if (item.GetState() & wxAUI_BUTTON_STATE_CHECKED)
432 {
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.
435 dc.SetPen(wxPen(m_highlight_colour));
436 dc.SetBrush(wxBrush(m_highlight_colour.ChangeLightness(170)));
437 dc.DrawRectangle(button_rect);
438 dc.DrawRectangle(dropdown_rect);
439 }
440
441 wxBitmap bmp;
442 wxBitmap dropbmp;
443 if (item.GetState() & wxAUI_BUTTON_STATE_DISABLED)
444 {
445 bmp = item.GetDisabledBitmap();
446 dropbmp = m_disabled_button_dropdown_bmp;
447 }
448 else
449 {
450 bmp = item.GetBitmap();
451 dropbmp = m_button_dropdown_bmp;
452 }
453
454 if (!bmp.IsOk())
455 return;
456
457 dc.DrawBitmap(bmp, bmp_x, bmp_y, true);
458 dc.DrawBitmap(dropbmp, dropbmp_x, dropbmp_y, true);
459
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);
464
465 if ( (m_flags & wxAUI_TB_TEXT) && !item.GetLabel().empty() )
466 {
467 dc.DrawText(item.GetLabel(), text_x, text_y);
468 }
469}
470
471void wxAuiDefaultToolBarArt::DrawControlLabel(
472 wxDC& dc,
473 wxWindow* WXUNUSED(wnd),
474 const wxAuiToolBarItem& item,
475 const wxRect& rect)
476{
477 if (!(m_flags & wxAUI_TB_TEXT))
478 return;
479
480 if (m_text_orientation != wxAUI_TBTOOL_TEXT_BOTTOM)
481 return;
482
483 int text_x = 0, text_y = 0;
484 int text_width = 0, text_height = 0;
485
486 dc.SetFont(m_font);
487
488 int tx, ty;
489 if (m_flags & wxAUI_TB_TEXT)
490 {
491 dc.GetTextExtent(wxT("ABCDHgj"), &tx, &text_height);
492 text_width = 0;
493 }
494
495 dc.GetTextExtent(item.GetLabel(), &text_width, &ty);
496
497 // don't draw the label if it is wider than the item width
498 if (text_width > rect.width)
499 return;
500
501 // set the label's text color
502 dc.SetTextForeground(*wxBLACK);
503
504 text_x = rect.x + (rect.width/2) - (text_width/2) + 1;
505 text_y = rect.y + rect.height - text_height - 1;
506
507 if ( (m_flags & wxAUI_TB_TEXT) && !item.GetLabel().empty() )
508 {
509 dc.DrawText(item.GetLabel(), text_x, text_y);
510 }
511}
512
513wxSize wxAuiDefaultToolBarArt::GetLabelSize(
514 wxDC& dc,
515 wxWindow* WXUNUSED(wnd),
516 const wxAuiToolBarItem& item)
517{
518 dc.SetFont(m_font);
519
520 // get label's height
521 int width = 0, height = 0;
522 dc.GetTextExtent(wxT("ABCDHgj"), &width, &height);
523
524 // get item's width
525 width = item.GetMinSize().GetWidth();
526
527 if (width == -1)
528 {
529 // no width specified, measure the text ourselves
530 width = dc.GetTextExtent(item.GetLabel()).GetX();
531 }
532
533 return wxSize(width, height);
534}
535
536wxSize wxAuiDefaultToolBarArt::GetToolSize(
537 wxDC& dc,
538 wxWindow* WXUNUSED(wnd),
539 const wxAuiToolBarItem& item)
540{
541 if (!item.GetBitmap().IsOk() && !(m_flags & wxAUI_TB_TEXT))
542 return wxSize(16,16);
543
544 int width = item.GetBitmap().GetWidth();
545 int height = item.GetBitmap().GetHeight();
546
547 if (m_flags & wxAUI_TB_TEXT)
548 {
549 dc.SetFont(m_font);
550 int tx, ty;
551
552 if (m_text_orientation == wxAUI_TBTOOL_TEXT_BOTTOM)
553 {
554 dc.GetTextExtent(wxT("ABCDHgj"), &tx, &ty);
555 height += ty;
556
557 if ( !item.GetLabel().empty() )
558 {
559 dc.GetTextExtent(item.GetLabel(), &tx, &ty);
560 width = wxMax(width, tx+6);
561 }
562 }
563 else if ( m_text_orientation == wxAUI_TBTOOL_TEXT_RIGHT &&
564 !item.GetLabel().empty() )
565 {
566 width += 3; // space between left border and bitmap
567 width += 3; // space between bitmap and text
568
569 if ( !item.GetLabel().empty() )
570 {
571 dc.GetTextExtent(item.GetLabel(), &tx, &ty);
572 width += tx;
573 height = wxMax(height, ty);
574 }
575 }
576 }
577
578 // if the tool has a dropdown button, add it to the width
579 if (item.HasDropDown())
580 width += (BUTTON_DROPDOWN_WIDTH+4);
581
582 return wxSize(width, height);
583}
584
585void wxAuiDefaultToolBarArt::DrawSeparator(
586 wxDC& dc,
587 wxWindow* WXUNUSED(wnd),
588 const wxRect& _rect)
589{
590 bool horizontal = true;
591 if (m_flags & wxAUI_TB_VERTICAL)
592 horizontal = false;
593
594 wxRect rect = _rect;
595
596 if (horizontal)
597 {
598 rect.x += (rect.width/2);
599 rect.width = 1;
600 int new_height = (rect.height*3)/4;
601 rect.y += (rect.height/2) - (new_height/2);
602 rect.height = new_height;
603 }
604 else
605 {
606 rect.y += (rect.height/2);
607 rect.height = 1;
608 int new_width = (rect.width*3)/4;
609 rect.x += (rect.width/2) - (new_width/2);
610 rect.width = new_width;
611 }
612
613 wxColour start_colour = m_base_colour.ChangeLightness(80);
614 wxColour end_colour = m_base_colour.ChangeLightness(80);
615 dc.GradientFillLinear(rect, start_colour, end_colour, horizontal ? wxSOUTH : wxEAST);
616}
617
618void wxAuiDefaultToolBarArt::DrawGripper(wxDC& dc,
619 wxWindow* WXUNUSED(wnd),
620 const wxRect& rect)
621{
622 int i = 0;
623 while (1)
624 {
625 int x, y;
626
627 if (m_flags & wxAUI_TB_VERTICAL)
628 {
629 x = rect.x + (i*4) + 5;
630 y = rect.y + 3;
631 if (x > rect.GetWidth()-5)
632 break;
633 }
634 else
635 {
636 x = rect.x + 3;
637 y = rect.y + (i*4) + 5;
638 if (y > rect.GetHeight()-5)
639 break;
640 }
641
642 dc.SetPen(m_gripper_pen1);
643 dc.DrawPoint(x, y);
644 dc.SetPen(m_gripper_pen2);
645 dc.DrawPoint(x, y+1);
646 dc.DrawPoint(x+1, y);
647 dc.SetPen(m_gripper_pen3);
648 dc.DrawPoint(x+2, y+1);
649 dc.DrawPoint(x+2, y+2);
650 dc.DrawPoint(x+1, y+2);
651
652 i++;
653 }
654
655}
656
657void wxAuiDefaultToolBarArt::DrawOverflowButton(wxDC& dc,
658 wxWindow* wnd,
659 const wxRect& rect,
660 int state)
661{
662 if (state & wxAUI_BUTTON_STATE_HOVER ||
663 state & wxAUI_BUTTON_STATE_PRESSED)
664 {
665 wxRect cli_rect = wnd->GetClientRect();
666 wxColor light_gray_bg = m_highlight_colour.ChangeLightness(170);
667
668 if (m_flags & wxAUI_TB_VERTICAL)
669 {
670 dc.SetPen(wxPen(m_highlight_colour));
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);
675 }
676 else
677 {
678 dc.SetPen(wxPen(m_highlight_colour));
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);
683 }
684 }
685
686 int x = rect.x+1+(rect.width-m_overflow_bmp.GetWidth())/2;
687 int y = rect.y+1+(rect.height-m_overflow_bmp.GetHeight())/2;
688 dc.DrawBitmap(m_overflow_bmp, x, y, true);
689}
690
691int wxAuiDefaultToolBarArt::GetElementSize(int element_id)
692{
693 switch (element_id)
694 {
695 case wxAUI_TBART_SEPARATOR_SIZE: return m_separator_size;
696 case wxAUI_TBART_GRIPPER_SIZE: return m_gripper_size;
697 case wxAUI_TBART_OVERFLOW_SIZE: return m_overflow_size;
698 default: return 0;
699 }
700}
701
702void wxAuiDefaultToolBarArt::SetElementSize(int element_id, int size)
703{
704 switch (element_id)
705 {
706 case wxAUI_TBART_SEPARATOR_SIZE: m_separator_size = size; break;
707 case wxAUI_TBART_GRIPPER_SIZE: m_gripper_size = size; break;
708 case wxAUI_TBART_OVERFLOW_SIZE: m_overflow_size = size; break;
709 }
710}
711
712int wxAuiDefaultToolBarArt::ShowDropDown(wxWindow* wnd,
713 const wxAuiToolBarItemArray& items)
714{
715 wxMenu menuPopup;
716
717 size_t items_added = 0;
718
719 size_t i, count = items.GetCount();
720 for (i = 0; i < count; ++i)
721 {
722 wxAuiToolBarItem& item = items.Item(i);
723
724 if (item.GetKind() == wxITEM_NORMAL)
725 {
726 wxString text = item.GetShortHelp();
727 if (text.empty())
728 text = item.GetLabel();
729
730 if (text.empty())
731 text = wxT(" ");
732
733 wxMenuItem* m = new wxMenuItem(&menuPopup, item.GetId(), text, item.GetShortHelp());
734
735 m->SetBitmap(item.GetBitmap());
736 menuPopup.Append(m);
737 items_added++;
738 }
739 else if (item.GetKind() == wxITEM_SEPARATOR)
740 {
741 if (items_added > 0)
742 menuPopup.AppendSeparator();
743 }
744 }
745
746 // find out where to put the popup menu of window items
747 wxPoint pt = ::wxGetMousePosition();
748 pt = wnd->ScreenToClient(pt);
749
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;
753
754 ToolbarCommandCapture* cc = new ToolbarCommandCapture;
755 wnd->PushEventHandler(cc);
756 wnd->PopupMenu(&menuPopup, pt);
757 int command = cc->GetCommandId();
758 wnd->PopEventHandler(true);
759
760 return command;
761}
762
763
764
765
766static wxOrientation GetOrientation(long& style)
767{
768 switch (style & wxAUI_ORIENTATION_MASK)
769 {
770 case wxAUI_TB_HORIZONTAL:
771 return wxHORIZONTAL;
772 case wxAUI_TB_VERTICAL:
773 return wxVERTICAL;
774 default:
775 wxFAIL_MSG("toolbar cannot be locked in both horizontal and vertical orientations (maybe no lock was intended?)");
776 // fall through
777 case 0:
778 return wxBOTH;
779 }
780}
781
782BEGIN_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)
800END_EVENT_TABLE()
801
802
803wxAuiToolBar::wxAuiToolBar(wxWindow* parent,
804 wxWindowID id,
805 const wxPoint& position,
806 const wxSize& size,
807 long style)
808 : wxControl(parent,
809 id,
810 position,
811 size,
812 style | wxBORDER_NONE)
813{
814 m_sizer = new wxBoxSizer(wxHORIZONTAL);
815 m_button_width = -1;
816 m_button_height = -1;
817 m_sizer_element_count = 0;
818 m_action_pos = wxPoint(-1,-1);
819 m_action_item = NULL;
820 m_tip_item = NULL;
821 m_art = new wxAuiDefaultToolBarArt;
822 m_tool_packing = 2;
823 m_tool_border_padding = 3;
824 m_tool_text_orientation = wxAUI_TBTOOL_TEXT_BOTTOM;
825 m_gripper_sizer_item = NULL;
826 m_overflow_sizer_item = NULL;
827 m_dragging = false;
828 m_orientation = GetOrientation(style);
829 if (m_orientation == wxBOTH)
830 {
831 m_orientation = wxHORIZONTAL;
832 }
833 m_style = style | wxBORDER_NONE;
834 m_gripper_visible = (m_style & wxAUI_TB_GRIPPER) ? true : false;
835 m_overflow_visible = (m_style & wxAUI_TB_OVERFLOW) ? true : false;
836 m_overflow_state = 0;
837 SetMargins(5, 5, 2, 2);
838 SetFont(*wxNORMAL_FONT);
839 SetArtFlags();
840 SetExtraStyle(wxWS_EX_PROCESS_IDLE);
841 if (style & wxAUI_TB_HORZ_LAYOUT)
842 SetToolTextOrientation(wxAUI_TBTOOL_TEXT_RIGHT);
843 SetBackgroundStyle(wxBG_STYLE_CUSTOM);
844}
845
846
847wxAuiToolBar::~wxAuiToolBar()
848{
849 delete m_art;
850 delete m_sizer;
851}
852
853void wxAuiToolBar::SetWindowStyleFlag(long style)
854{
855 GetOrientation(style); // assert if style is invalid
856 wxCHECK_RET(IsPaneValid(style),
857 "window settings and pane settings are incompatible");
858
859 wxControl::SetWindowStyleFlag(style);
860
861 m_style = style;
862
863 if (m_art)
864 {
865 SetArtFlags();
866 }
867
868 if (m_style & wxAUI_TB_GRIPPER)
869 m_gripper_visible = true;
870 else
871 m_gripper_visible = false;
872
873
874 if (m_style & wxAUI_TB_OVERFLOW)
875 m_overflow_visible = true;
876 else
877 m_overflow_visible = false;
878
879 if (style & wxAUI_TB_HORZ_LAYOUT)
880 SetToolTextOrientation(wxAUI_TBTOOL_TEXT_RIGHT);
881 else
882 SetToolTextOrientation(wxAUI_TBTOOL_TEXT_BOTTOM);
883}
884
885long wxAuiToolBar::GetWindowStyleFlag() const
886{
887 return m_style;
888}
889
890void wxAuiToolBar::SetArtProvider(wxAuiToolBarArt* art)
891{
892 delete m_art;
893
894 m_art = art;
895
896 if (m_art)
897 {
898 SetArtFlags();
899 m_art->SetTextOrientation(m_tool_text_orientation);
900 }
901}
902
903wxAuiToolBarArt* wxAuiToolBar::GetArtProvider() const
904{
905 return m_art;
906}
907
908
909
910
911wxAuiToolBarItem* wxAuiToolBar::AddTool(int tool_id,
912 const wxString& label,
913 const wxBitmap& bitmap,
914 const wxString& short_help_string,
915 wxItemKind kind)
916{
917 return AddTool(tool_id,
918 label,
919 bitmap,
920 wxNullBitmap,
921 kind,
922 short_help_string,
923 wxEmptyString,
924 NULL);
925}
926
927
928wxAuiToolBarItem* wxAuiToolBar::AddTool(int tool_id,
929 const wxString& label,
930 const wxBitmap& bitmap,
931 const wxBitmap& disabled_bitmap,
932 wxItemKind kind,
933 const wxString& short_help_string,
934 const wxString& long_help_string,
935 wxObject* WXUNUSED(client_data))
936{
937 wxAuiToolBarItem item;
938 item.window = NULL;
939 item.label = label;
940 item.bitmap = bitmap;
941 item.disabled_bitmap = disabled_bitmap;
942 item.short_help = short_help_string;
943 item.long_help = long_help_string;
944 item.active = true;
945 item.dropdown = false;
946 item.spacer_pixels = 0;
947 item.toolid = tool_id;
948 item.state = 0;
949 item.proportion = 0;
950 item.kind = kind;
951 item.sizer_item = NULL;
952 item.min_size = wxDefaultSize;
953 item.user_data = 0;
954 item.sticky = false;
955
956 if (item.toolid == wxID_ANY)
957 item.toolid = wxNewId();
958
959 if (!item.disabled_bitmap.IsOk())
960 {
961 // no disabled bitmap specified, we need to make one
962 if (item.bitmap.IsOk())
963 {
964 item.disabled_bitmap = item.bitmap.ConvertToDisabled();
965 }
966 }
967 m_items.Add(item);
968 return &m_items.Last();
969}
970
971wxAuiToolBarItem* wxAuiToolBar::AddControl(wxControl* control,
972 const wxString& label)
973{
974 wxAuiToolBarItem item;
975 item.window = (wxWindow*)control;
976 item.label = label;
977 item.bitmap = wxNullBitmap;
978 item.disabled_bitmap = wxNullBitmap;
979 item.active = true;
980 item.dropdown = false;
981 item.spacer_pixels = 0;
982 item.toolid = control->GetId();
983 item.state = 0;
984 item.proportion = 0;
985 item.kind = wxITEM_CONTROL;
986 item.sizer_item = NULL;
987 item.min_size = control->GetEffectiveMinSize();
988 item.user_data = 0;
989 item.sticky = false;
990
991 m_items.Add(item);
992 return &m_items.Last();
993}
994
995wxAuiToolBarItem* wxAuiToolBar::AddLabel(int tool_id,
996 const wxString& label,
997 const int width)
998{
999 wxSize min_size = wxDefaultSize;
1000 if (width != -1)
1001 min_size.x = width;
1002
1003 wxAuiToolBarItem item;
1004 item.window = NULL;
1005 item.label = label;
1006 item.bitmap = wxNullBitmap;
1007 item.disabled_bitmap = wxNullBitmap;
1008 item.active = true;
1009 item.dropdown = false;
1010 item.spacer_pixels = 0;
1011 item.toolid = tool_id;
1012 item.state = 0;
1013 item.proportion = 0;
1014 item.kind = wxITEM_LABEL;
1015 item.sizer_item = NULL;
1016 item.min_size = min_size;
1017 item.user_data = 0;
1018 item.sticky = false;
1019
1020 if (item.toolid == wxID_ANY)
1021 item.toolid = wxNewId();
1022
1023 m_items.Add(item);
1024 return &m_items.Last();
1025}
1026
1027wxAuiToolBarItem* wxAuiToolBar::AddSeparator()
1028{
1029 wxAuiToolBarItem item;
1030 item.window = NULL;
1031 item.label = wxEmptyString;
1032 item.bitmap = wxNullBitmap;
1033 item.disabled_bitmap = wxNullBitmap;
1034 item.active = true;
1035 item.dropdown = false;
1036 item.toolid = -1;
1037 item.state = 0;
1038 item.proportion = 0;
1039 item.kind = wxITEM_SEPARATOR;
1040 item.sizer_item = NULL;
1041 item.min_size = wxDefaultSize;
1042 item.user_data = 0;
1043 item.sticky = false;
1044
1045 m_items.Add(item);
1046 return &m_items.Last();
1047}
1048
1049wxAuiToolBarItem* wxAuiToolBar::AddSpacer(int pixels)
1050{
1051 wxAuiToolBarItem item;
1052 item.window = NULL;
1053 item.label = wxEmptyString;
1054 item.bitmap = wxNullBitmap;
1055 item.disabled_bitmap = wxNullBitmap;
1056 item.active = true;
1057 item.dropdown = false;
1058 item.spacer_pixels = pixels;
1059 item.toolid = -1;
1060 item.state = 0;
1061 item.proportion = 0;
1062 item.kind = wxITEM_SPACER;
1063 item.sizer_item = NULL;
1064 item.min_size = wxDefaultSize;
1065 item.user_data = 0;
1066 item.sticky = false;
1067
1068 m_items.Add(item);
1069 return &m_items.Last();
1070}
1071
1072wxAuiToolBarItem* wxAuiToolBar::AddStretchSpacer(int proportion)
1073{
1074 wxAuiToolBarItem item;
1075 item.window = NULL;
1076 item.label = wxEmptyString;
1077 item.bitmap = wxNullBitmap;
1078 item.disabled_bitmap = wxNullBitmap;
1079 item.active = true;
1080 item.dropdown = false;
1081 item.spacer_pixels = 0;
1082 item.toolid = -1;
1083 item.state = 0;
1084 item.proportion = proportion;
1085 item.kind = wxITEM_SPACER;
1086 item.sizer_item = NULL;
1087 item.min_size = wxDefaultSize;
1088 item.user_data = 0;
1089 item.sticky = false;
1090
1091 m_items.Add(item);
1092 return &m_items.Last();
1093}
1094
1095void wxAuiToolBar::Clear()
1096{
1097 m_items.Clear();
1098 m_sizer_element_count = 0;
1099}
1100
1101bool wxAuiToolBar::DeleteTool(int tool_id)
1102{
1103 int idx = GetToolIndex(tool_id);
1104 if (idx >= 0 && idx < (int)m_items.GetCount())
1105 {
1106 m_items.RemoveAt(idx);
1107 Realize();
1108 return true;
1109 }
1110
1111 return false;
1112}
1113
1114bool wxAuiToolBar::DeleteByIndex(int idx)
1115{
1116 if (idx >= 0 && idx < (int)m_items.GetCount())
1117 {
1118 m_items.RemoveAt(idx);
1119 Realize();
1120 return true;
1121 }
1122
1123 return false;
1124}
1125
1126
1127wxControl* wxAuiToolBar::FindControl(int id)
1128{
1129 wxWindow* wnd = FindWindow(id);
1130 return (wxControl*)wnd;
1131}
1132
1133wxAuiToolBarItem* wxAuiToolBar::FindTool(int tool_id) const
1134{
1135 size_t i, count;
1136 for (i = 0, count = m_items.GetCount(); i < count; ++i)
1137 {
1138 wxAuiToolBarItem& item = m_items.Item(i);
1139 if (item.toolid == tool_id)
1140 return &item;
1141 }
1142
1143 return NULL;
1144}
1145
1146wxAuiToolBarItem* wxAuiToolBar::FindToolByPosition(wxCoord x, wxCoord y) const
1147{
1148 size_t i, count;
1149 for (i = 0, count = m_items.GetCount(); i < count; ++i)
1150 {
1151 wxAuiToolBarItem& item = m_items.Item(i);
1152
1153 if (!item.sizer_item)
1154 continue;
1155
1156 wxRect rect = item.sizer_item->GetRect();
1157 if (rect.Contains(x,y))
1158 {
1159 // if the item doesn't fit on the toolbar, return NULL
1160 if (!GetToolFitsByIndex(i))
1161 return NULL;
1162
1163 return &item;
1164 }
1165 }
1166
1167 return NULL;
1168}
1169
1170wxAuiToolBarItem* wxAuiToolBar::FindToolByPositionWithPacking(wxCoord x, wxCoord y) const
1171{
1172 size_t i, count;
1173 for (i = 0, count = m_items.GetCount(); i < count; ++i)
1174 {
1175 wxAuiToolBarItem& item = m_items.Item(i);
1176
1177 if (!item.sizer_item)
1178 continue;
1179
1180 wxRect rect = item.sizer_item->GetRect();
1181
1182 // apply tool packing
1183 if (i+1 < count)
1184 rect.width += m_tool_packing;
1185
1186 if (rect.Contains(x,y))
1187 {
1188 // if the item doesn't fit on the toolbar, return NULL
1189 if (!GetToolFitsByIndex(i))
1190 return NULL;
1191
1192 return &item;
1193 }
1194 }
1195
1196 return NULL;
1197}
1198
1199wxAuiToolBarItem* wxAuiToolBar::FindToolByIndex(int idx) const
1200{
1201 if (idx < 0)
1202 return NULL;
1203
1204 if (idx >= (int)m_items.size())
1205 return NULL;
1206
1207 return &(m_items[idx]);
1208}
1209
1210void wxAuiToolBar::SetToolBitmapSize(const wxSize& WXUNUSED(size))
1211{
1212 // TODO: wxToolBar compatibility
1213}
1214
1215wxSize wxAuiToolBar::GetToolBitmapSize() const
1216{
1217 // TODO: wxToolBar compatibility
1218 return wxSize(16,15);
1219}
1220
1221void wxAuiToolBar::SetToolProportion(int tool_id, int proportion)
1222{
1223 wxAuiToolBarItem* item = FindTool(tool_id);
1224 if (!item)
1225 return;
1226
1227 item->proportion = proportion;
1228}
1229
1230int wxAuiToolBar::GetToolProportion(int tool_id) const
1231{
1232 wxAuiToolBarItem* item = FindTool(tool_id);
1233 if (!item)
1234 return 0;
1235
1236 return item->proportion;
1237}
1238
1239void wxAuiToolBar::SetToolSeparation(int separation)
1240{
1241 if (m_art)
1242 m_art->SetElementSize(wxAUI_TBART_SEPARATOR_SIZE, separation);
1243}
1244
1245int wxAuiToolBar::GetToolSeparation() const
1246{
1247 if (m_art)
1248 return m_art->GetElementSize(wxAUI_TBART_SEPARATOR_SIZE);
1249 else
1250 return 5;
1251}
1252
1253
1254void wxAuiToolBar::SetToolDropDown(int tool_id, bool dropdown)
1255{
1256 wxAuiToolBarItem* item = FindTool(tool_id);
1257 if (!item)
1258 return;
1259
1260 item->dropdown = dropdown;
1261}
1262
1263bool wxAuiToolBar::GetToolDropDown(int tool_id) const
1264{
1265 wxAuiToolBarItem* item = FindTool(tool_id);
1266 if (!item)
1267 return 0;
1268
1269 return item->dropdown;
1270}
1271
1272void wxAuiToolBar::SetToolSticky(int tool_id, bool sticky)
1273{
1274 // ignore separators
1275 if (tool_id == -1)
1276 return;
1277
1278 wxAuiToolBarItem* item = FindTool(tool_id);
1279 if (!item)
1280 return;
1281
1282 if (item->sticky == sticky)
1283 return;
1284
1285 item->sticky = sticky;
1286
1287 Refresh(false);
1288 Update();
1289}
1290
1291bool wxAuiToolBar::GetToolSticky(int tool_id) const
1292{
1293 wxAuiToolBarItem* item = FindTool(tool_id);
1294 if (!item)
1295 return 0;
1296
1297 return item->sticky;
1298}
1299
1300
1301
1302
1303void wxAuiToolBar::SetToolBorderPadding(int padding)
1304{
1305 m_tool_border_padding = padding;
1306}
1307
1308int wxAuiToolBar::GetToolBorderPadding() const
1309{
1310 return m_tool_border_padding;
1311}
1312
1313void wxAuiToolBar::SetToolTextOrientation(int orientation)
1314{
1315 m_tool_text_orientation = orientation;
1316
1317 if (m_art)
1318 {
1319 m_art->SetTextOrientation(orientation);
1320 }
1321}
1322
1323int wxAuiToolBar::GetToolTextOrientation() const
1324{
1325 return m_tool_text_orientation;
1326}
1327
1328void wxAuiToolBar::SetToolPacking(int packing)
1329{
1330 m_tool_packing = packing;
1331}
1332
1333int wxAuiToolBar::GetToolPacking() const
1334{
1335 return m_tool_packing;
1336}
1337
1338
1339void wxAuiToolBar::SetOrientation(int orientation)
1340{
1341 wxCHECK_RET(orientation == wxHORIZONTAL ||
1342 orientation == wxVERTICAL,
1343 "invalid orientation value");
1344 if (orientation != m_orientation)
1345 {
1346 m_orientation = wxOrientation(orientation);
1347 SetArtFlags();
1348 }
1349}
1350
1351void wxAuiToolBar::SetMargins(int left, int right, int top, int bottom)
1352{
1353 if (left != -1)
1354 m_left_padding = left;
1355 if (right != -1)
1356 m_right_padding = right;
1357 if (top != -1)
1358 m_top_padding = top;
1359 if (bottom != -1)
1360 m_bottom_padding = bottom;
1361}
1362
1363bool wxAuiToolBar::GetGripperVisible() const
1364{
1365 return m_gripper_visible;
1366}
1367
1368void wxAuiToolBar::SetGripperVisible(bool visible)
1369{
1370 m_gripper_visible = visible;
1371 if (visible)
1372 m_style |= wxAUI_TB_GRIPPER;
1373 else
1374 m_style &= ~wxAUI_TB_GRIPPER;
1375 Realize();
1376 Refresh(false);
1377}
1378
1379
1380bool wxAuiToolBar::GetOverflowVisible() const
1381{
1382 return m_overflow_visible;
1383}
1384
1385void wxAuiToolBar::SetOverflowVisible(bool visible)
1386{
1387 m_overflow_visible = visible;
1388 if (visible)
1389 m_style |= wxAUI_TB_OVERFLOW;
1390 else
1391 m_style &= ~wxAUI_TB_OVERFLOW;
1392 Refresh(false);
1393}
1394
1395bool wxAuiToolBar::SetFont(const wxFont& font)
1396{
1397 bool res = wxWindow::SetFont(font);
1398
1399 if (m_art)
1400 {
1401 m_art->SetFont(font);
1402 }
1403
1404 return res;
1405}
1406
1407
1408void wxAuiToolBar::SetHoverItem(wxAuiToolBarItem* pitem)
1409{
1410 wxAuiToolBarItem* former_hover = NULL;
1411
1412 size_t i, count;
1413 for (i = 0, count = m_items.GetCount(); i < count; ++i)
1414 {
1415 wxAuiToolBarItem& item = m_items.Item(i);
1416 if (item.state & wxAUI_BUTTON_STATE_HOVER)
1417 former_hover = &item;
1418 item.state &= ~wxAUI_BUTTON_STATE_HOVER;
1419 }
1420
1421 if (pitem)
1422 {
1423 pitem->state |= wxAUI_BUTTON_STATE_HOVER;
1424 }
1425
1426 if (former_hover != pitem)
1427 {
1428 Refresh(false);
1429 Update();
1430 }
1431}
1432
1433void wxAuiToolBar::SetPressedItem(wxAuiToolBarItem* pitem)
1434{
1435 wxAuiToolBarItem* former_item = NULL;
1436
1437 size_t i, count;
1438 for (i = 0, count = m_items.GetCount(); i < count; ++i)
1439 {
1440 wxAuiToolBarItem& item = m_items.Item(i);
1441 if (item.state & wxAUI_BUTTON_STATE_PRESSED)
1442 former_item = &item;
1443 item.state &= ~wxAUI_BUTTON_STATE_PRESSED;
1444 }
1445
1446 if (pitem)
1447 {
1448 pitem->state &= ~wxAUI_BUTTON_STATE_HOVER;
1449 pitem->state |= wxAUI_BUTTON_STATE_PRESSED;
1450 }
1451
1452 if (former_item != pitem)
1453 {
1454 Refresh(false);
1455 Update();
1456 }
1457}
1458
1459void wxAuiToolBar::RefreshOverflowState()
1460{
1461 if (!m_overflow_sizer_item)
1462 {
1463 m_overflow_state = 0;
1464 return;
1465 }
1466
1467 int overflow_state = 0;
1468
1469 wxRect overflow_rect = GetOverflowRect();
1470
1471
1472 // find out the mouse's current position
1473 wxPoint pt = ::wxGetMousePosition();
1474 pt = this->ScreenToClient(pt);
1475
1476 // find out if the mouse cursor is inside the dropdown rectangle
1477 if (overflow_rect.Contains(pt.x, pt.y))
1478 {
1479 if (::wxGetMouseState().LeftIsDown())
1480 overflow_state = wxAUI_BUTTON_STATE_PRESSED;
1481 else
1482 overflow_state = wxAUI_BUTTON_STATE_HOVER;
1483 }
1484
1485 if (overflow_state != m_overflow_state)
1486 {
1487 m_overflow_state = overflow_state;
1488 Refresh(false);
1489 Update();
1490 }
1491
1492 m_overflow_state = overflow_state;
1493}
1494
1495void wxAuiToolBar::ToggleTool(int tool_id, bool state)
1496{
1497 wxAuiToolBarItem* tool = FindTool(tool_id);
1498
1499 if (tool && (tool->kind == wxITEM_CHECK || tool->kind == wxITEM_RADIO))
1500 {
1501 if (tool->kind == wxITEM_RADIO)
1502 {
1503 int i, idx, count;
1504 idx = GetToolIndex(tool_id);
1505 count = (int)m_items.GetCount();
1506
1507 if (idx >= 0 && idx < count)
1508 {
1509 for (i = idx + 1; i < count; ++i)
1510 {
1511 if (m_items[i].kind != wxITEM_RADIO)
1512 break;
1513 m_items[i].state &= ~wxAUI_BUTTON_STATE_CHECKED;
1514 }
1515 for (i = idx - 1; i >= 0; i--)
1516 {
1517 if (m_items[i].kind != wxITEM_RADIO)
1518 break;
1519 m_items[i].state &= ~wxAUI_BUTTON_STATE_CHECKED;
1520 }
1521 }
1522
1523 tool->state |= wxAUI_BUTTON_STATE_CHECKED;
1524 }
1525 else if (tool->kind == wxITEM_CHECK)
1526 {
1527 if (state == true)
1528 tool->state |= wxAUI_BUTTON_STATE_CHECKED;
1529 else
1530 tool->state &= ~wxAUI_BUTTON_STATE_CHECKED;
1531 }
1532 }
1533}
1534
1535bool wxAuiToolBar::GetToolToggled(int tool_id) const
1536{
1537 wxAuiToolBarItem* tool = FindTool(tool_id);
1538
1539 if (tool)
1540 {
1541 if ( (tool->kind != wxITEM_CHECK) && (tool->kind != wxITEM_RADIO) )
1542 return false;
1543
1544 return (tool->state & wxAUI_BUTTON_STATE_CHECKED) ? true : false;
1545 }
1546
1547 return false;
1548}
1549
1550void wxAuiToolBar::EnableTool(int tool_id, bool state)
1551{
1552 wxAuiToolBarItem* tool = FindTool(tool_id);
1553
1554 if (tool)
1555 {
1556 if (state == true)
1557 tool->state &= ~wxAUI_BUTTON_STATE_DISABLED;
1558 else
1559 tool->state |= wxAUI_BUTTON_STATE_DISABLED;
1560 }
1561}
1562
1563bool wxAuiToolBar::GetToolEnabled(int tool_id) const
1564{
1565 wxAuiToolBarItem* tool = FindTool(tool_id);
1566
1567 if (tool)
1568 return (tool->state & wxAUI_BUTTON_STATE_DISABLED) ? false : true;
1569
1570 return false;
1571}
1572
1573wxString wxAuiToolBar::GetToolLabel(int tool_id) const
1574{
1575 wxAuiToolBarItem* tool = FindTool(tool_id);
1576 wxASSERT_MSG(tool, wxT("can't find tool in toolbar item array"));
1577 if (!tool)
1578 return wxEmptyString;
1579
1580 return tool->label;
1581}
1582
1583void wxAuiToolBar::SetToolLabel(int tool_id, const wxString& label)
1584{
1585 wxAuiToolBarItem* tool = FindTool(tool_id);
1586 if (tool)
1587 {
1588 tool->label = label;
1589 }
1590}
1591
1592wxBitmap wxAuiToolBar::GetToolBitmap(int tool_id) const
1593{
1594 wxAuiToolBarItem* tool = FindTool(tool_id);
1595 wxASSERT_MSG(tool, wxT("can't find tool in toolbar item array"));
1596 if (!tool)
1597 return wxNullBitmap;
1598
1599 return tool->bitmap;
1600}
1601
1602void wxAuiToolBar::SetToolBitmap(int tool_id, const wxBitmap& bitmap)
1603{
1604 wxAuiToolBarItem* tool = FindTool(tool_id);
1605 if (tool)
1606 {
1607 tool->bitmap = bitmap;
1608 }
1609}
1610
1611wxString wxAuiToolBar::GetToolShortHelp(int tool_id) const
1612{
1613 wxAuiToolBarItem* tool = FindTool(tool_id);
1614 wxASSERT_MSG(tool, wxT("can't find tool in toolbar item array"));
1615 if (!tool)
1616 return wxEmptyString;
1617
1618 return tool->short_help;
1619}
1620
1621void wxAuiToolBar::SetToolShortHelp(int tool_id, const wxString& help_string)
1622{
1623 wxAuiToolBarItem* tool = FindTool(tool_id);
1624 if (tool)
1625 {
1626 tool->short_help = help_string;
1627 }
1628}
1629
1630wxString wxAuiToolBar::GetToolLongHelp(int tool_id) const
1631{
1632 wxAuiToolBarItem* tool = FindTool(tool_id);
1633 wxASSERT_MSG(tool, wxT("can't find tool in toolbar item array"));
1634 if (!tool)
1635 return wxEmptyString;
1636
1637 return tool->long_help;
1638}
1639
1640void wxAuiToolBar::SetToolLongHelp(int tool_id, const wxString& help_string)
1641{
1642 wxAuiToolBarItem* tool = FindTool(tool_id);
1643 if (tool)
1644 {
1645 tool->long_help = help_string;
1646 }
1647}
1648
1649void wxAuiToolBar::SetCustomOverflowItems(const wxAuiToolBarItemArray& prepend,
1650 const wxAuiToolBarItemArray& append)
1651{
1652 m_custom_overflow_prepend = prepend;
1653 m_custom_overflow_append = append;
1654}
1655
1656// get size of hint rectangle for a particular dock location
1657wxSize wxAuiToolBar::GetHintSize(int dock_direction) const
1658{
1659 switch (dock_direction)
1660 {
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;
1667 default:
1668 wxCHECK_MSG(false, wxDefaultSize, "invalid dock location value");
1669 }
1670}
1671
1672bool wxAuiToolBar::IsPaneValid(const wxAuiPaneInfo& pane) const
1673{
1674 return IsPaneValid(m_style, pane);
1675}
1676
1677bool wxAuiToolBar::IsPaneValid(long style, const wxAuiPaneInfo& pane)
1678{
1679 if (style & wxAUI_TB_HORIZONTAL)
1680 {
1681 if (pane.IsLeftDockable() || pane.IsRightDockable())
1682 {
1683 return false;
1684 }
1685 }
1686 else if (style & wxAUI_TB_VERTICAL)
1687 {
1688 if (pane.IsTopDockable() || pane.IsBottomDockable())
1689 {
1690 return false;
1691 }
1692 }
1693 return true;
1694}
1695
1696bool wxAuiToolBar::IsPaneValid(long style) const
1697{
1698 wxAuiManager* manager = wxAuiManager::GetManager(const_cast<wxAuiToolBar*>(this));
1699 if (manager)
1700 {
1701 return IsPaneValid(style, manager->GetPane(const_cast<wxAuiToolBar*>(this)));
1702 }
1703 return true;
1704}
1705
1706void wxAuiToolBar::SetArtFlags() const
1707{
1708 unsigned int artflags = m_style & ~wxAUI_ORIENTATION_MASK;
1709 if (m_orientation == wxVERTICAL)
1710 {
1711 artflags |= wxAUI_TB_VERTICAL;
1712 }
1713 m_art->SetFlags(artflags);
1714}
1715
1716size_t wxAuiToolBar::GetToolCount() const
1717{
1718 return m_items.size();
1719}
1720
1721int wxAuiToolBar::GetToolIndex(int tool_id) const
1722{
1723 // this will prevent us from returning the index of the
1724 // first separator in the toolbar since its id is equal to -1
1725 if (tool_id == -1)
1726 return wxNOT_FOUND;
1727
1728 size_t i, count = m_items.GetCount();
1729 for (i = 0; i < count; ++i)
1730 {
1731 wxAuiToolBarItem& item = m_items.Item(i);
1732 if (item.toolid == tool_id)
1733 return i;
1734 }
1735
1736 return wxNOT_FOUND;
1737}
1738
1739bool wxAuiToolBar::GetToolFitsByIndex(int tool_idx) const
1740{
1741 if (tool_idx < 0 || tool_idx >= (int)m_items.GetCount())
1742 return false;
1743
1744 if (!m_items[tool_idx].sizer_item)
1745 return false;
1746
1747 int cli_w, cli_h;
1748 GetClientSize(&cli_w, &cli_h);
1749
1750 wxRect rect = m_items[tool_idx].sizer_item->GetRect();
1751
1752 if (m_orientation == wxVERTICAL)
1753 {
1754 // take the dropdown size into account
1755 if (m_overflow_visible)
1756 cli_h -= m_overflow_sizer_item->GetSize().y;
1757
1758 if (rect.y+rect.height < cli_h)
1759 return true;
1760 }
1761 else
1762 {
1763 // take the dropdown size into account
1764 if (m_overflow_visible)
1765 cli_w -= m_overflow_sizer_item->GetSize().x;
1766
1767 if (rect.x+rect.width < cli_w)
1768 return true;
1769 }
1770
1771 return false;
1772}
1773
1774
1775bool wxAuiToolBar::GetToolFits(int tool_id) const
1776{
1777 return GetToolFitsByIndex(GetToolIndex(tool_id));
1778}
1779
1780wxRect wxAuiToolBar::GetToolRect(int tool_id) const
1781{
1782 wxAuiToolBarItem* tool = FindTool(tool_id);
1783 if (tool && tool->sizer_item)
1784 {
1785 return tool->sizer_item->GetRect();
1786 }
1787
1788 return wxRect();
1789}
1790
1791bool wxAuiToolBar::GetToolBarFits() const
1792{
1793 if (m_items.GetCount() == 0)
1794 {
1795 // empty toolbar always 'fits'
1796 return true;
1797 }
1798
1799 // entire toolbar content fits if the last tool fits
1800 return GetToolFitsByIndex(m_items.GetCount() - 1);
1801}
1802
1803bool wxAuiToolBar::Realize()
1804{
1805 wxClientDC dc(this);
1806 if (!dc.IsOk())
1807 return false;
1808
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)
1813 {
1814 if (RealizeHelper(dc, false))
1815 {
1816 m_vertHintSize = GetSize();
1817 if (RealizeHelper(dc, true))
1818 {
1819 m_horzHintSize = GetSize();
1820 retval = true;
1821 }
1822 }
1823 }
1824 else
1825 {
1826 if (RealizeHelper(dc, true))
1827 {
1828 m_horzHintSize = GetSize();
1829 if (RealizeHelper(dc, false))
1830 {
1831 m_vertHintSize = GetSize();
1832 retval = true;
1833 }
1834 }
1835 }
1836
1837 Refresh(false);
1838 return retval;
1839}
1840
1841bool wxAuiToolBar::RealizeHelper(wxClientDC& dc, bool horizontal)
1842{
1843 // create the new sizer to add toolbar elements to
1844 wxBoxSizer* sizer = new wxBoxSizer(horizontal ? wxHORIZONTAL : wxVERTICAL);
1845
1846 // add gripper area
1847 int separator_size = m_art->GetElementSize(wxAUI_TBART_SEPARATOR_SIZE);
1848 int gripper_size = m_art->GetElementSize(wxAUI_TBART_GRIPPER_SIZE);
1849 if (gripper_size > 0 && m_gripper_visible)
1850 {
1851 if (horizontal)
1852 m_gripper_sizer_item = sizer->Add(gripper_size, 1, 0, wxEXPAND);
1853 else
1854 m_gripper_sizer_item = sizer->Add(1, gripper_size, 0, wxEXPAND);
1855 }
1856 else
1857 {
1858 m_gripper_sizer_item = NULL;
1859 }
1860
1861 // add "left" padding
1862 if (m_left_padding > 0)
1863 {
1864 if (horizontal)
1865 sizer->Add(m_left_padding, 1);
1866 else
1867 sizer->Add(1, m_left_padding);
1868 }
1869
1870 size_t i, count;
1871 for (i = 0, count = m_items.GetCount(); i < count; ++i)
1872 {
1873 wxAuiToolBarItem& item = m_items.Item(i);
1874 wxSizerItem* sizer_item = NULL;
1875
1876 switch (item.kind)
1877 {
1878 case wxITEM_LABEL:
1879 {
1880 wxSize size = m_art->GetLabelSize(dc, this, item);
1881 sizer_item = sizer->Add(size.x + (m_tool_border_padding*2),
1882 size.y + (m_tool_border_padding*2),
1883 item.proportion,
1884 item.alignment);
1885 if (i+1 < count)
1886 {
1887 sizer->AddSpacer(m_tool_packing);
1888 }
1889
1890 break;
1891 }
1892
1893 case wxITEM_CHECK:
1894 case wxITEM_NORMAL:
1895 case wxITEM_RADIO:
1896 {
1897 wxSize size = m_art->GetToolSize(dc, this, item);
1898 sizer_item = sizer->Add(size.x + (m_tool_border_padding*2),
1899 size.y + (m_tool_border_padding*2),
1900 0,
1901 item.alignment);
1902 // add tool packing
1903 if (i+1 < count)
1904 {
1905 sizer->AddSpacer(m_tool_packing);
1906 }
1907
1908 break;
1909 }
1910
1911 case wxITEM_SEPARATOR:
1912 {
1913 if (horizontal)
1914 sizer_item = sizer->Add(separator_size, 1, 0, wxEXPAND);
1915 else
1916 sizer_item = sizer->Add(1, separator_size, 0, wxEXPAND);
1917
1918 // add tool packing
1919 if (i+1 < count)
1920 {
1921 sizer->AddSpacer(m_tool_packing);
1922 }
1923
1924 break;
1925 }
1926
1927 case wxITEM_SPACER:
1928 if (item.proportion > 0)
1929 sizer_item = sizer->AddStretchSpacer(item.proportion);
1930 else
1931 sizer_item = sizer->Add(item.spacer_pixels, 1);
1932 break;
1933
1934 case wxITEM_CONTROL:
1935 {
1936 //sizer_item = sizer->Add(item.window, item.proportion, wxEXPAND);
1937 wxSizerItem* ctrl_sizer_item;
1938
1939 wxBoxSizer* vert_sizer = new wxBoxSizer(wxVERTICAL);
1940 vert_sizer->AddStretchSpacer(1);
1941 ctrl_sizer_item = vert_sizer->Add(item.window, 0, wxEXPAND);
1942 vert_sizer->AddStretchSpacer(1);
1943 if ( (m_style & wxAUI_TB_TEXT) &&
1944 m_tool_text_orientation == wxAUI_TBTOOL_TEXT_BOTTOM &&
1945 !item.GetLabel().empty() )
1946 {
1947 wxSize s = GetLabelSize(item.GetLabel());
1948 vert_sizer->Add(1, s.y);
1949 }
1950
1951
1952 sizer_item = sizer->Add(vert_sizer, item.proportion, wxEXPAND);
1953
1954 wxSize min_size = item.min_size;
1955
1956
1957 // proportional items will disappear from the toolbar if
1958 // their min width is not set to something really small
1959 if (item.proportion != 0)
1960 {
1961 min_size.x = 1;
1962 }
1963
1964 if (min_size.IsFullySpecified())
1965 {
1966 sizer_item->SetMinSize(min_size);
1967 ctrl_sizer_item->SetMinSize(min_size);
1968 }
1969
1970 // add tool packing
1971 if (i+1 < count)
1972 {
1973 sizer->AddSpacer(m_tool_packing);
1974 }
1975 }
1976 }
1977
1978 item.sizer_item = sizer_item;
1979 }
1980
1981 // add "right" padding
1982 if (m_right_padding > 0)
1983 {
1984 if (horizontal)
1985 sizer->Add(m_right_padding, 1);
1986 else
1987 sizer->Add(1, m_right_padding);
1988 }
1989
1990 // add drop down area
1991 m_overflow_sizer_item = NULL;
1992
1993 if (m_style & wxAUI_TB_OVERFLOW)
1994 {
1995 int overflow_size = m_art->GetElementSize(wxAUI_TBART_OVERFLOW_SIZE);
1996 if (overflow_size > 0 && m_overflow_visible)
1997 {
1998 if (horizontal)
1999 m_overflow_sizer_item = sizer->Add(overflow_size, 1, 0, wxEXPAND);
2000 else
2001 m_overflow_sizer_item = sizer->Add(1, overflow_size, 0, wxEXPAND);
2002 }
2003 else
2004 {
2005 m_overflow_sizer_item = NULL;
2006 }
2007 }
2008
2009
2010 // the outside sizer helps us apply the "top" and "bottom" padding
2011 wxBoxSizer* outside_sizer = new wxBoxSizer(horizontal ? wxVERTICAL : wxHORIZONTAL);
2012
2013 // add "top" padding
2014 if (m_top_padding > 0)
2015 {
2016 if (horizontal)
2017 outside_sizer->Add(1, m_top_padding);
2018 else
2019 outside_sizer->Add(m_top_padding, 1);
2020 }
2021
2022 // add the sizer that contains all of the toolbar elements
2023 outside_sizer->Add(sizer, 1, wxEXPAND);
2024
2025 // add "bottom" padding
2026 if (m_bottom_padding > 0)
2027 {
2028 if (horizontal)
2029 outside_sizer->Add(1, m_bottom_padding);
2030 else
2031 outside_sizer->Add(m_bottom_padding, 1);
2032 }
2033
2034 delete m_sizer; // remove old sizer
2035 m_sizer = outside_sizer;
2036
2037 // calculate the rock-bottom minimum size
2038 for (i = 0, count = m_items.GetCount(); i < count; ++i)
2039 {
2040 wxAuiToolBarItem& item = m_items.Item(i);
2041 if (item.sizer_item && item.proportion > 0 && item.min_size.IsFullySpecified())
2042 item.sizer_item->SetMinSize(0,0);
2043 }
2044
2045 m_absolute_min_size = m_sizer->GetMinSize();
2046
2047 // reset the min sizes to what they were
2048 for (i = 0, count = m_items.GetCount(); i < count; ++i)
2049 {
2050 wxAuiToolBarItem& item = m_items.Item(i);
2051 if (item.sizer_item && item.proportion > 0 && item.min_size.IsFullySpecified())
2052 item.sizer_item->SetMinSize(item.min_size);
2053 }
2054
2055 // set control size
2056 wxSize size = m_sizer->GetMinSize();
2057 m_minWidth = size.x;
2058 m_minHeight = size.y;
2059
2060 if ((m_style & wxAUI_TB_NO_AUTORESIZE) == 0)
2061 {
2062 wxSize cur_size = GetClientSize();
2063 wxSize new_size = GetMinSize();
2064 if (new_size != cur_size)
2065 {
2066 SetClientSize(new_size);
2067 }
2068 else
2069 {
2070 m_sizer->SetDimension(0, 0, cur_size.x, cur_size.y);
2071 }
2072 }
2073 else
2074 {
2075 wxSize cur_size = GetClientSize();
2076 m_sizer->SetDimension(0, 0, cur_size.x, cur_size.y);
2077 }
2078
2079 return true;
2080}
2081
2082int wxAuiToolBar::GetOverflowState() const
2083{
2084 return m_overflow_state;
2085}
2086
2087wxRect wxAuiToolBar::GetOverflowRect() const
2088{
2089 wxRect cli_rect(wxPoint(0,0), GetClientSize());
2090 wxRect overflow_rect = m_overflow_sizer_item->GetRect();
2091 int overflow_size = m_art->GetElementSize(wxAUI_TBART_OVERFLOW_SIZE);
2092
2093 if (m_orientation == wxVERTICAL)
2094 {
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;
2099 }
2100 else
2101 {
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;
2106 }
2107
2108 return overflow_rect;
2109}
2110
2111wxSize wxAuiToolBar::GetLabelSize(const wxString& label)
2112{
2113 wxClientDC dc(this);
2114
2115 int tx, ty;
2116 int text_width = 0, text_height = 0;
2117
2118 dc.SetFont(m_font);
2119
2120 // get the text height
2121 dc.GetTextExtent(wxT("ABCDHgj"), &tx, &text_height);
2122
2123 // get the text width
2124 dc.GetTextExtent(label, &text_width, &ty);
2125
2126 return wxSize(text_width, text_height);
2127}
2128
2129
2130void wxAuiToolBar::DoIdleUpdate()
2131{
2132 wxEvtHandler* handler = GetEventHandler();
2133
2134 bool need_refresh = false;
2135
2136 size_t i, count;
2137 for (i = 0, count = m_items.GetCount(); i < count; ++i)
2138 {
2139 wxAuiToolBarItem& item = m_items.Item(i);
2140
2141 if (item.toolid == -1)
2142 continue;
2143
2144 wxUpdateUIEvent evt(item.toolid);
2145 evt.SetEventObject(this);
2146
2147 if (handler->ProcessEvent(evt))
2148 {
2149 if (evt.GetSetEnabled())
2150 {
2151 bool is_enabled;
2152 if (item.window)
2153 is_enabled = item.window->IsEnabled();
2154 else
2155 is_enabled = (item.state & wxAUI_BUTTON_STATE_DISABLED) ? false : true;
2156
2157 bool new_enabled = evt.GetEnabled();
2158 if (new_enabled != is_enabled)
2159 {
2160 if (item.window)
2161 {
2162 item.window->Enable(new_enabled);
2163 }
2164 else
2165 {
2166 if (new_enabled)
2167 item.state &= ~wxAUI_BUTTON_STATE_DISABLED;
2168 else
2169 item.state |= wxAUI_BUTTON_STATE_DISABLED;
2170 }
2171 need_refresh = true;
2172 }
2173 }
2174
2175 if (evt.GetSetChecked())
2176 {
2177 // make sure we aren't checking an item that can't be
2178 if (item.kind != wxITEM_CHECK && item.kind != wxITEM_RADIO)
2179 continue;
2180
2181 bool is_checked = (item.state & wxAUI_BUTTON_STATE_CHECKED) ? true : false;
2182 bool new_checked = evt.GetChecked();
2183
2184 if (new_checked != is_checked)
2185 {
2186 if (new_checked)
2187 item.state |= wxAUI_BUTTON_STATE_CHECKED;
2188 else
2189 item.state &= ~wxAUI_BUTTON_STATE_CHECKED;
2190
2191 need_refresh = true;
2192 }
2193 }
2194
2195 }
2196 }
2197
2198
2199 if (need_refresh)
2200 {
2201 Refresh(false);
2202 }
2203}
2204
2205
2206void wxAuiToolBar::OnSize(wxSizeEvent& WXUNUSED(evt))
2207{
2208 int x, y;
2209 GetClientSize(&x, &y);
2210
2211 if (((x >= y) && m_absolute_min_size.x > x) ||
2212 ((y > x) && m_absolute_min_size.y > y))
2213 {
2214 // hide all flexible items
2215 size_t i, count;
2216 for (i = 0, count = m_items.GetCount(); i < count; ++i)
2217 {
2218 wxAuiToolBarItem& item = m_items.Item(i);
2219 if (item.sizer_item && item.proportion > 0 && item.sizer_item->IsShown())
2220 {
2221 item.sizer_item->Show(false);
2222 item.sizer_item->SetProportion(0);
2223 }
2224 }
2225 }
2226 else
2227 {
2228 // show all flexible items
2229 size_t i, count;
2230 for (i = 0, count = m_items.GetCount(); i < count; ++i)
2231 {
2232 wxAuiToolBarItem& item = m_items.Item(i);
2233 if (item.sizer_item && item.proportion > 0 && !item.sizer_item->IsShown())
2234 {
2235 item.sizer_item->Show(true);
2236 item.sizer_item->SetProportion(item.proportion);
2237 }
2238 }
2239 }
2240
2241 m_sizer->SetDimension(0, 0, x, y);
2242
2243 Refresh(false);
2244 Update();
2245
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);
2250}
2251
2252
2253
2254void wxAuiToolBar::DoSetSize(int x,
2255 int y,
2256 int width,
2257 int height,
2258 int sizeFlags)
2259{
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);
2265
2266 wxWindow::DoSetSize(x, y, width, height, sizeFlags);
2267}
2268
2269
2270void wxAuiToolBar::OnIdle(wxIdleEvent& evt)
2271{
2272 // if orientation doesn't match dock, fix it
2273 wxAuiManager* manager = wxAuiManager::GetManager(this);
2274 if (manager)
2275 {
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");
2282 if (ok)
2283 {
2284 wxOrientation newOrientation = m_orientation;
2285 if (pane.IsDocked())
2286 {
2287 switch (pane.dock_direction)
2288 {
2289 case wxAUI_DOCK_TOP:
2290 case wxAUI_DOCK_BOTTOM:
2291 newOrientation = wxHORIZONTAL;
2292 break;
2293 case wxAUI_DOCK_LEFT:
2294 case wxAUI_DOCK_RIGHT:
2295 newOrientation = wxVERTICAL;
2296 break;
2297 default:
2298 wxFAIL_MSG("invalid dock location value");
2299 }
2300 }
2301 else if (pane.IsResizable() &&
2302 GetOrientation(m_style) == wxBOTH)
2303 {
2304 // changing orientation in OnSize causes havoc
2305 int x, y;
2306 GetClientSize(&x, &y);
2307
2308 if (x > y)
2309 {
2310 newOrientation = wxHORIZONTAL;
2311 }
2312 else
2313 {
2314 newOrientation = wxVERTICAL;
2315 }
2316 }
2317 if (newOrientation != m_orientation)
2318 {
2319 SetOrientation(newOrientation);
2320 Realize();
2321 if (newOrientation == wxHORIZONTAL)
2322 {
2323 pane.best_size = GetHintSize(wxAUI_DOCK_TOP);
2324 }
2325 else
2326 {
2327 pane.best_size = GetHintSize(wxAUI_DOCK_LEFT);
2328 }
2329 if (pane.IsDocked())
2330 {
2331 pane.floating_size = wxDefaultSize;
2332 }
2333 else
2334 {
2335 SetSize(GetParent()->GetClientSize());
2336 }
2337 manager->Update();
2338 }
2339 }
2340 }
2341
2342 DoIdleUpdate();
2343 evt.Skip();
2344}
2345
2346void wxAuiToolBar::OnPaint(wxPaintEvent& WXUNUSED(evt))
2347{
2348 wxAutoBufferedPaintDC dc(this);
2349 wxRect cli_rect(wxPoint(0,0), GetClientSize());
2350
2351
2352 bool horizontal = m_orientation == wxHORIZONTAL;
2353
2354
2355 m_art->DrawBackground(dc, this, cli_rect);
2356
2357 int gripper_size = m_art->GetElementSize(wxAUI_TBART_GRIPPER_SIZE);
2358 int dropdown_size = m_art->GetElementSize(wxAUI_TBART_OVERFLOW_SIZE);
2359
2360 // paint the gripper
2361 if (gripper_size > 0 && m_gripper_sizer_item)
2362 {
2363 wxRect gripper_rect = m_gripper_sizer_item->GetRect();
2364 if (horizontal)
2365 gripper_rect.width = gripper_size;
2366 else
2367 gripper_rect.height = gripper_size;
2368 m_art->DrawGripper(dc, this, gripper_rect);
2369 }
2370
2371 // calculated how far we can draw items
2372 int last_extent;
2373 if (horizontal)
2374 last_extent = cli_rect.width;
2375 else
2376 last_extent = cli_rect.height;
2377 if (m_overflow_visible)
2378 last_extent -= dropdown_size;
2379
2380 // paint each individual tool
2381 size_t i, count = m_items.GetCount();
2382 for (i = 0; i < count; ++i)
2383 {
2384 wxAuiToolBarItem& item = m_items.Item(i);
2385
2386 if (!item.sizer_item)
2387 continue;
2388
2389 wxRect item_rect = item.sizer_item->GetRect();
2390
2391
2392 if ((horizontal && item_rect.x + item_rect.width >= last_extent) ||
2393 (!horizontal && item_rect.y + item_rect.height >= last_extent))
2394 {
2395 break;
2396 }
2397
2398 if (item.kind == wxITEM_SEPARATOR)
2399 {
2400 // draw a separator
2401 m_art->DrawSeparator(dc, this, item_rect);
2402 }
2403 else if (item.kind == wxITEM_LABEL)
2404 {
2405 // draw a text label only
2406 m_art->DrawLabel(dc, this, item, item_rect);
2407 }
2408 else if (item.kind == wxITEM_NORMAL)
2409 {
2410 // draw a regular button or dropdown button
2411 if (!item.dropdown)
2412 m_art->DrawButton(dc, this, item, item_rect);
2413 else
2414 m_art->DrawDropDownButton(dc, this, item, item_rect);
2415 }
2416 else if (item.kind == wxITEM_CHECK)
2417 {
2418 // draw either a regular or dropdown toggle button
2419 if (!item.dropdown)
2420 m_art->DrawButton(dc, this, item, item_rect);
2421 else
2422 m_art->DrawDropDownButton(dc, this, item, item_rect);
2423 }
2424 else if (item.kind == wxITEM_RADIO)
2425 {
2426 // draw a toggle button
2427 m_art->DrawButton(dc, this, item, item_rect);
2428 }
2429 else if (item.kind == wxITEM_CONTROL)
2430 {
2431 // draw the control's label
2432 m_art->DrawControlLabel(dc, this, item, item_rect);
2433 }
2434
2435 // fire a signal to see if the item wants to be custom-rendered
2436 OnCustomRender(dc, item, item_rect);
2437 }
2438
2439 // paint the overflow button
2440 if (dropdown_size > 0 && m_overflow_sizer_item)
2441 {
2442 wxRect dropdown_rect = GetOverflowRect();
2443 m_art->DrawOverflowButton(dc, this, dropdown_rect, m_overflow_state);
2444 }
2445}
2446
2447void wxAuiToolBar::OnEraseBackground(wxEraseEvent& WXUNUSED(evt))
2448{
2449 // empty
2450}
2451
2452void wxAuiToolBar::OnLeftDown(wxMouseEvent& evt)
2453{
2454 wxRect cli_rect(wxPoint(0,0), GetClientSize());
2455
2456 if (m_gripper_sizer_item)
2457 {
2458 wxRect gripper_rect = m_gripper_sizer_item->GetRect();
2459 if (gripper_rect.Contains(evt.GetX(), evt.GetY()))
2460 {
2461 // find aui manager
2462 wxAuiManager* manager = wxAuiManager::GetManager(this);
2463 if (!manager)
2464 return;
2465
2466 int x_drag_offset = evt.GetX() - gripper_rect.GetX();
2467 int y_drag_offset = evt.GetY() - gripper_rect.GetY();
2468
2469 // gripper was clicked
2470 manager->StartPaneDrag(this, wxPoint(x_drag_offset, y_drag_offset));
2471 return;
2472 }
2473 }
2474
2475 if (m_overflow_sizer_item)
2476 {
2477 wxRect overflow_rect = GetOverflowRect();
2478
2479 if (m_art &&
2480 m_overflow_visible &&
2481 overflow_rect.Contains(evt.m_x, evt.m_y))
2482 {
2483 wxAuiToolBarEvent e(wxEVT_COMMAND_AUITOOLBAR_OVERFLOW_CLICK, -1);
2484 e.SetEventObject(this);
2485 e.SetToolId(-1);
2486 e.SetClickPoint(wxPoint(evt.GetX(), evt.GetY()));
2487 bool processed = GetEventHandler()->ProcessEvent(e);
2488
2489 if (processed)
2490 {
2491 DoIdleUpdate();
2492 }
2493 else
2494 {
2495 size_t i, count;
2496 wxAuiToolBarItemArray overflow_items;
2497
2498
2499 // add custom overflow prepend items, if any
2500 count = m_custom_overflow_prepend.GetCount();
2501 for (i = 0; i < count; ++i)
2502 overflow_items.Add(m_custom_overflow_prepend[i]);
2503
2504 // only show items that don't fit in the dropdown
2505 count = m_items.GetCount();
2506 for (i = 0; i < count; ++i)
2507 {
2508 if (!GetToolFitsByIndex(i))
2509 overflow_items.Add(m_items[i]);
2510 }
2511
2512 // add custom overflow append items, if any
2513 count = m_custom_overflow_append.GetCount();
2514 for (i = 0; i < count; ++i)
2515 overflow_items.Add(m_custom_overflow_append[i]);
2516
2517 int res = m_art->ShowDropDown(this, overflow_items);
2518 m_overflow_state = 0;
2519 Refresh(false);
2520 if (res != -1)
2521 {
2522 wxCommandEvent e(wxEVT_COMMAND_MENU_SELECTED, res);
2523 e.SetEventObject(this);
2524 GetParent()->GetEventHandler()->ProcessEvent(e);
2525 }
2526 }
2527
2528 return;
2529 }
2530 }
2531
2532 m_dragging = false;
2533 m_action_pos = wxPoint(evt.GetX(), evt.GetY());
2534 m_action_item = FindToolByPosition(evt.GetX(), evt.GetY());
2535
2536 if (m_action_item)
2537 {
2538 if (m_action_item->state & wxAUI_BUTTON_STATE_DISABLED)
2539 {
2540 m_action_pos = wxPoint(-1,-1);
2541 m_action_item = NULL;
2542 return;
2543 }
2544
2545 UnsetToolTip();
2546
2547 // fire the tool dropdown event
2548 wxAuiToolBarEvent e(wxEVT_COMMAND_AUITOOLBAR_TOOL_DROPDOWN, m_action_item->toolid);
2549 e.SetEventObject(this);
2550 e.SetToolId(m_action_item->toolid);
2551
2552 int mouse_x = evt.GetX();
2553 wxRect rect = m_action_item->sizer_item->GetRect();
2554 const bool dropDownHit = m_action_item->dropdown &&
2555 mouse_x >= (rect.x+rect.width-BUTTON_DROPDOWN_WIDTH-1) &&
2556 mouse_x < (rect.x+rect.width);
2557 e.SetDropDownClicked(dropDownHit);
2558
2559 e.SetClickPoint(evt.GetPosition());
2560 e.SetItemRect(rect);
2561
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_action_item);
2565
2566 if(dropDownHit)
2567 {
2568 m_action_pos = wxPoint(-1,-1);
2569 m_action_item = NULL;
2570 }
2571
2572 if(!GetEventHandler()->ProcessEvent(e) || e.GetSkipped())
2573 CaptureMouse();
2574
2575 DoIdleUpdate();
2576 }
2577}
2578
2579void wxAuiToolBar::OnLeftUp(wxMouseEvent& evt)
2580{
2581 if (!HasCapture())
2582 return;
2583
2584 SetPressedItem(NULL);
2585
2586 wxAuiToolBarItem* hit_item = FindToolByPosition(evt.GetX(), evt.GetY());
2587 if (hit_item && !(hit_item->state & wxAUI_BUTTON_STATE_DISABLED))
2588 {
2589 SetHoverItem(hit_item);
2590 }
2591
2592 if (m_dragging)
2593 {
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'
2596 // event
2597
2598 // OnCaptureLost() will be called now and this will reset all our state
2599 // tracking variables
2600 ReleaseMouse();
2601 }
2602 else
2603 {
2604 wxAuiToolBarItem* hit_item;
2605 hit_item = FindToolByPosition(evt.GetX(), evt.GetY());
2606
2607 if (m_action_item && hit_item == m_action_item)
2608 {
2609 UnsetToolTip();
2610
2611 wxCommandEvent e(wxEVT_COMMAND_MENU_SELECTED, m_action_item->toolid);
2612 e.SetEventObject(this);
2613
2614 if (hit_item->kind == wxITEM_CHECK || hit_item->kind == wxITEM_RADIO)
2615 {
2616 const bool toggle = !(m_action_item->state & wxAUI_BUTTON_STATE_CHECKED);
2617
2618 ToggleTool(m_action_item->toolid, toggle);
2619
2620 // repaint immediately
2621 Refresh(false);
2622 Update();
2623
2624 e.SetInt(toggle);
2625 }
2626
2627 // we have to release the mouse *before* sending the event, because
2628 // we don't know what a handler might do. It could open up a popup
2629 // menu for example and that would make us lose our capture anyway.
2630
2631 ReleaseMouse();
2632
2633 GetEventHandler()->ProcessEvent(e);
2634 DoIdleUpdate();
2635 }
2636 else
2637 ReleaseMouse();
2638 }
2639}
2640
2641void wxAuiToolBar::OnRightDown(wxMouseEvent& evt)
2642{
2643 wxRect cli_rect(wxPoint(0,0), GetClientSize());
2644
2645 if (m_gripper_sizer_item)
2646 {
2647 wxRect gripper_rect = m_gripper_sizer_item->GetRect();
2648 if (gripper_rect.Contains(evt.GetX(), evt.GetY()))
2649 return;
2650 }
2651
2652 if (m_overflow_sizer_item)
2653 {
2654 int dropdown_size = m_art->GetElementSize(wxAUI_TBART_OVERFLOW_SIZE);
2655 if (dropdown_size > 0 &&
2656 evt.m_x > cli_rect.width - dropdown_size &&
2657 evt.m_y >= 0 &&
2658 evt.m_y < cli_rect.height &&
2659 m_art)
2660 {
2661 return;
2662 }
2663 }
2664
2665 m_action_pos = wxPoint(evt.GetX(), evt.GetY());
2666 m_action_item = FindToolByPosition(evt.GetX(), evt.GetY());
2667
2668 if (m_action_item && m_action_item->state & wxAUI_BUTTON_STATE_DISABLED)
2669 {
2670 m_action_pos = wxPoint(-1,-1);
2671 m_action_item = NULL;
2672 return;
2673 }
2674
2675 UnsetToolTip();
2676}
2677
2678void wxAuiToolBar::OnRightUp(wxMouseEvent& evt)
2679{
2680 wxAuiToolBarItem* hit_item;
2681 hit_item = FindToolByPosition(evt.GetX(), evt.GetY());
2682
2683 if (m_action_item && hit_item == m_action_item)
2684 {
2685 if (hit_item->kind == wxITEM_NORMAL)
2686 {
2687 wxAuiToolBarEvent e(wxEVT_COMMAND_AUITOOLBAR_RIGHT_CLICK, m_action_item->toolid);
2688 e.SetEventObject(this);
2689 e.SetToolId(m_action_item->toolid);
2690 e.SetClickPoint(m_action_pos);
2691 GetEventHandler()->ProcessEvent(e);
2692 DoIdleUpdate();
2693 }
2694 }
2695 else
2696 {
2697 // right-clicked on the invalid area of the toolbar
2698 wxAuiToolBarEvent e(wxEVT_COMMAND_AUITOOLBAR_RIGHT_CLICK, -1);
2699 e.SetEventObject(this);
2700 e.SetToolId(-1);
2701 e.SetClickPoint(m_action_pos);
2702 GetEventHandler()->ProcessEvent(e);
2703 DoIdleUpdate();
2704 }
2705
2706 // reset member variables
2707 m_action_pos = wxPoint(-1,-1);
2708 m_action_item = NULL;
2709}
2710
2711void wxAuiToolBar::OnMiddleDown(wxMouseEvent& evt)
2712{
2713 wxRect cli_rect(wxPoint(0,0), GetClientSize());
2714
2715 if (m_gripper_sizer_item)
2716 {
2717 wxRect gripper_rect = m_gripper_sizer_item->GetRect();
2718 if (gripper_rect.Contains(evt.GetX(), evt.GetY()))
2719 return;
2720 }
2721
2722 if (m_overflow_sizer_item)
2723 {
2724 int dropdown_size = m_art->GetElementSize(wxAUI_TBART_OVERFLOW_SIZE);
2725 if (dropdown_size > 0 &&
2726 evt.m_x > cli_rect.width - dropdown_size &&
2727 evt.m_y >= 0 &&
2728 evt.m_y < cli_rect.height &&
2729 m_art)
2730 {
2731 return;
2732 }
2733 }
2734
2735 m_action_pos = wxPoint(evt.GetX(), evt.GetY());
2736 m_action_item = FindToolByPosition(evt.GetX(), evt.GetY());
2737
2738 if (m_action_item)
2739 {
2740 if (m_action_item->state & wxAUI_BUTTON_STATE_DISABLED)
2741 {
2742 m_action_pos = wxPoint(-1,-1);
2743 m_action_item = NULL;
2744 return;
2745 }
2746 }
2747
2748 UnsetToolTip();
2749}
2750
2751void wxAuiToolBar::OnMiddleUp(wxMouseEvent& evt)
2752{
2753 wxAuiToolBarItem* hit_item;
2754 hit_item = FindToolByPosition(evt.GetX(), evt.GetY());
2755
2756 if (m_action_item && hit_item == m_action_item)
2757 {
2758 if (hit_item->kind == wxITEM_NORMAL)
2759 {
2760 wxAuiToolBarEvent e(wxEVT_COMMAND_AUITOOLBAR_MIDDLE_CLICK, m_action_item->toolid);
2761 e.SetEventObject(this);
2762 e.SetToolId(m_action_item->toolid);
2763 e.SetClickPoint(m_action_pos);
2764 GetEventHandler()->ProcessEvent(e);
2765 DoIdleUpdate();
2766 }
2767 }
2768
2769 // reset member variables
2770 m_action_pos = wxPoint(-1,-1);
2771 m_action_item = NULL;
2772}
2773
2774void wxAuiToolBar::OnMotion(wxMouseEvent& evt)
2775{
2776 const bool button_pressed = HasCapture();
2777
2778 // start a drag event
2779 if (!m_dragging && button_pressed &&
2780 abs(evt.GetX() - m_action_pos.x) + abs(evt.GetY() - m_action_pos.y) > 5)
2781 {
2782 // TODO: sending this event only makes sense if there is an 'END_DRAG'
2783 // event sent sometime in the future (see OnLeftUp())
2784 wxAuiToolBarEvent e(wxEVT_COMMAND_AUITOOLBAR_BEGIN_DRAG, GetId());
2785 e.SetEventObject(this);
2786 e.SetToolId(m_action_item->toolid);
2787 m_dragging = GetEventHandler()->ProcessEvent(e) && !e.GetSkipped();
2788
2789 DoIdleUpdate();
2790 }
2791
2792 if(m_dragging)
2793 return;
2794
2795 wxAuiToolBarItem* hit_item = FindToolByPosition(evt.GetX(), evt.GetY());
2796 if(button_pressed)
2797 {
2798 // if we have a button pressed we want it to be shown in 'depressed'
2799 // state unless we move the mouse outside the button, then we want it
2800 // to show as just 'highlighted'
2801 if (hit_item == m_action_item)
2802 SetPressedItem(m_action_item);
2803 else
2804 {
2805 SetPressedItem(NULL);
2806 SetHoverItem(m_action_item);
2807 }
2808 }
2809 else
2810 {
2811 if (hit_item && (hit_item->state & wxAUI_BUTTON_STATE_DISABLED))
2812 SetHoverItem(NULL);
2813 else
2814 SetHoverItem(hit_item);
2815
2816 // tooltips handling
2817 wxAuiToolBarItem* packing_hit_item;
2818 packing_hit_item = FindToolByPositionWithPacking(evt.GetX(), evt.GetY());
2819 if (packing_hit_item)
2820 {
2821 if (packing_hit_item != m_tip_item)
2822 {
2823 m_tip_item = packing_hit_item;
2824
2825 if ( !packing_hit_item->short_help.empty() )
2826 SetToolTip(packing_hit_item->short_help);
2827 else
2828 UnsetToolTip();
2829 }
2830 }
2831 else
2832 {
2833 UnsetToolTip();
2834 m_tip_item = NULL;
2835 }
2836
2837 // figure out the dropdown button state (are we hovering or pressing it?)
2838 RefreshOverflowState();
2839 }
2840}
2841
2842void wxAuiToolBar::DoResetMouseState()
2843{
2844 RefreshOverflowState();
2845 SetHoverItem(NULL);
2846 SetPressedItem(NULL);
2847
2848 m_tip_item = NULL;
2849
2850 // we have to reset those here, because the mouse-up handlers which do
2851 // it usually won't be called if we let go of a mouse button while we
2852 // are outside of the window
2853 m_action_pos = wxPoint(-1,-1);
2854 m_action_item = NULL;
2855}
2856
2857void wxAuiToolBar::OnLeaveWindow(wxMouseEvent& evt)
2858{
2859 if(HasCapture())
2860 {
2861 evt.Skip();
2862 return;
2863 }
2864
2865 DoResetMouseState();
2866}
2867
2868void wxAuiToolBar::OnCaptureLost(wxMouseCaptureLostEvent& WXUNUSED(evt))
2869{
2870 m_dragging = false;
2871
2872 DoResetMouseState();
2873}
2874
2875void wxAuiToolBar::OnSetCursor(wxSetCursorEvent& evt)
2876{
2877 wxCursor cursor = wxNullCursor;
2878
2879 if (m_gripper_sizer_item)
2880 {
2881 wxRect gripper_rect = m_gripper_sizer_item->GetRect();
2882 if (gripper_rect.Contains(evt.GetX(), evt.GetY()))
2883 {
2884 cursor = wxCursor(wxCURSOR_SIZING);
2885 }
2886 }
2887
2888 evt.SetCursor(cursor);
2889}
2890
2891
2892#endif // wxUSE_AUI
2893
wxWidgets (Impactor)