]> 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
fixing modal dialog quit after nested message box problem
[wxWidgets.git] / src / aui / auibar.cpp
... / ...
CommitLineData
1///////////////////////////////////////////////////////////////////////////////
2
3// Name: src/aui/dockart.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// for themeing support
42#include <Carbon/Carbon.h>
43#endif
44
45#include "wx/arrimpl.cpp"
46WX_DEFINE_OBJARRAY(wxAuiToolBarItemArray)
47
48
49wxDEFINE_EVENT( wxEVT_COMMAND_AUITOOLBAR_TOOL_DROPDOWN, wxAuiToolBarEvent );
50wxDEFINE_EVENT( wxEVT_COMMAND_AUITOOLBAR_OVERFLOW_CLICK, wxAuiToolBarEvent );
51wxDEFINE_EVENT( wxEVT_COMMAND_AUITOOLBAR_RIGHT_CLICK, wxAuiToolBarEvent );
52wxDEFINE_EVENT( wxEVT_COMMAND_AUITOOLBAR_MIDDLE_CLICK, wxAuiToolBarEvent );
53wxDEFINE_EVENT( wxEVT_COMMAND_AUITOOLBAR_BEGIN_DRAG, wxAuiToolBarEvent );
54
55
56IMPLEMENT_CLASS(wxAuiToolBar, wxControl)
57IMPLEMENT_DYNAMIC_CLASS(wxAuiToolBarEvent, wxEvent)
58
59
60// missing wxITEM_* items
61enum
62{
63 wxITEM_CONTROL = wxITEM_MAX,
64 wxITEM_LABEL,
65 wxITEM_SPACER
66};
67
68const int BUTTON_DROPDOWN_WIDTH = 10;
69
70
71wxBitmap wxAuiBitmapFromBits(const unsigned char bits[], int w, int h,
72 const wxColour& color);
73
74unsigned char wxAuiBlendColour(unsigned char fg, unsigned char bg, double alpha);
75wxColor wxAuiStepColour(const wxColor& c, int percent);
76
77static wxBitmap MakeDisabledBitmap(wxBitmap& bmp)
78{
79 wxImage image = bmp.ConvertToImage();
80
81 int mr, mg, mb;
82 mr = image.GetMaskRed();
83 mg = image.GetMaskGreen();
84 mb = image.GetMaskBlue();
85
86 unsigned char* data = image.GetData();
87 int width = image.GetWidth();
88 int height = image.GetHeight();
89 bool has_mask = image.HasMask();
90
91 for (int y = height-1; y >= 0; --y)
92 {
93 for (int x = width-1; x >= 0; --x)
94 {
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;
99
100 if (has_mask && *r == mr && *g == mg && *b == mb)
101 continue;
102
103 *r = wxAuiBlendColour(*r, 255, 0.4);
104 *g = wxAuiBlendColour(*g, 255, 0.4);
105 *b = wxAuiBlendColour(*b, 255, 0.4);
106 }
107 }
108
109 return wxBitmap(image);
110}
111
112static wxColor GetBaseColor()
113{
114
115#if defined( __WXMAC__ ) && wxOSX_USE_COCOA_OR_CARBON
116 wxColor base_colour = wxColour( wxMacCreateCGColorFromHITheme(kThemeBrushToolbarBackground));
117#else
118 wxColor base_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
119#endif
120
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)
126 {
127 base_colour = wxAuiStepColour(base_colour, 92);
128 }
129
130 return base_colour;
131}
132
133
134
135class ToolbarCommandCapture : public wxEvtHandler
136{
137public:
138
139 ToolbarCommandCapture() { m_last_id = 0; }
140 int GetCommandId() const { return m_last_id; }
141
142 bool ProcessEvent(wxEvent& evt)
143 {
144 if (evt.GetEventType() == wxEVT_COMMAND_MENU_SELECTED)
145 {
146 m_last_id = evt.GetId();
147 return true;
148 }
149
150 if (GetNextHandler())
151 return GetNextHandler()->ProcessEvent(evt);
152
153 return false;
154 }
155
156private:
157 int m_last_id;
158};
159
160
161
162static const unsigned char
163 DISABLED_TEXT_GREY_HUE = wxAuiBlendColour(0, 255, 0.4);
164const wxColour DISABLED_TEXT_COLOR(DISABLED_TEXT_GREY_HUE,
165 DISABLED_TEXT_GREY_HUE,
166 DISABLED_TEXT_GREY_HUE);
167
168wxAuiDefaultToolBarArt::wxAuiDefaultToolBarArt()
169{
170 m_base_colour = GetBaseColor();
171
172 m_flags = 0;
173 m_text_orientation = wxAUI_TBTOOL_TEXT_BOTTOM;
174 m_highlight_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
175
176 m_separator_size = 7;
177 m_gripper_size = 7;
178 m_overflow_size = 16;
179
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);
185
186 m_gripper_pen1 = wxPen(darker5_colour);
187 m_gripper_pen2 = wxPen(darker3_colour);
188 m_gripper_pen3 = *wxWHITE_PEN;
189
190 static unsigned char button_dropdown_bits[] = { 0xe0, 0xf1, 0xfb };
191 static unsigned char overflow_bits[] = { 0x80, 0xff, 0x80, 0xc1, 0xe3, 0xf7 };
192
193 m_button_dropdown_bmp = wxAuiBitmapFromBits(button_dropdown_bits, 5, 3,
194 *wxBLACK);
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));
200
201 m_font = *wxNORMAL_FONT;
202}
203
204wxAuiDefaultToolBarArt::~wxAuiDefaultToolBarArt()
205{
206 m_font = *wxNORMAL_FONT;
207}
208
209
210wxAuiToolBarArt* wxAuiDefaultToolBarArt::Clone()
211{
212 return static_cast<wxAuiToolBarArt*>(new wxAuiDefaultToolBarArt);
213}
214
215void wxAuiDefaultToolBarArt::SetFlags(unsigned int flags)
216{
217 m_flags = flags;
218}
219
220void wxAuiDefaultToolBarArt::SetFont(const wxFont& font)
221{
222 m_font = font;
223}
224
225void wxAuiDefaultToolBarArt::SetTextOrientation(int orientation)
226{
227 m_text_orientation = orientation;
228}
229
230unsigned int wxAuiDefaultToolBarArt::GetFlags()
231{
232 return m_flags;
233}
234
235wxFont wxAuiDefaultToolBarArt::GetFont()
236{
237 return m_font;
238}
239
240int wxAuiDefaultToolBarArt::GetTextOrientation()
241{
242 return m_text_orientation;
243}
244
245void wxAuiDefaultToolBarArt::DrawBackground(
246 wxDC& dc,
247 wxWindow* WXUNUSED(wnd),
248 const wxRect& _rect)
249{
250 wxRect rect = _rect;
251 rect.height++;
252 wxColour start_colour = wxAuiStepColour(m_base_colour, 150);
253 wxColour end_colour = wxAuiStepColour(m_base_colour, 90);
254 dc.GradientFillLinear(rect, start_colour, end_colour, wxSOUTH);
255}
256
257void wxAuiDefaultToolBarArt::DrawLabel(
258 wxDC& dc,
259 wxWindow* WXUNUSED(wnd),
260 const wxAuiToolBarItem& item,
261 const wxRect& rect)
262{
263 dc.SetFont(m_font);
264 dc.SetTextForeground(*wxBLACK);
265
266 // we only care about the text height here since the text
267 // will get cropped based on the width of the item
268 int text_width = 0, text_height = 0;
269 dc.GetTextExtent(wxT("ABCDHgj"), &text_width, &text_height);
270
271 // set the clipping region
272 wxRect clip_rect = rect;
273 clip_rect.width -= 1;
274 dc.SetClippingRegion(clip_rect);
275
276 int text_x, text_y;
277 text_x = rect.x + 1;
278 text_y = rect.y + (rect.height-text_height)/2;
279 dc.DrawText(item.GetLabel(), text_x, text_y);
280 dc.DestroyClippingRegion();
281}
282
283
284void wxAuiDefaultToolBarArt::DrawButton(
285 wxDC& dc,
286 wxWindow* WXUNUSED(wnd),
287 const wxAuiToolBarItem& item,
288 const wxRect& rect)
289{
290 int text_width = 0, text_height = 0;
291
292 if (m_flags & wxAUI_TB_TEXT)
293 {
294 dc.SetFont(m_font);
295
296 int tx, ty;
297
298 dc.GetTextExtent(wxT("ABCDHgj"), &tx, &text_height);
299 text_width = 0;
300 dc.GetTextExtent(item.GetLabel(), &text_width, &ty);
301 }
302
303 int bmp_x = 0, bmp_y = 0;
304 int text_x = 0, text_y = 0;
305
306 if (m_text_orientation == wxAUI_TBTOOL_TEXT_BOTTOM)
307 {
308 bmp_x = rect.x +
309 (rect.width/2) -
310 (item.GetBitmap().GetWidth()/2);
311
312 bmp_y = rect.y +
313 ((rect.height-text_height)/2) -
314 (item.GetBitmap().GetHeight()/2);
315
316 text_x = rect.x + (rect.width/2) - (text_width/2) + 1;
317 text_y = rect.y + rect.height - text_height - 1;
318 }
319 else if (m_text_orientation == wxAUI_TBTOOL_TEXT_RIGHT)
320 {
321 bmp_x = rect.x + 3;
322
323 bmp_y = rect.y +
324 (rect.height/2) -
325 (item.GetBitmap().GetHeight()/2);
326
327 text_x = bmp_x + 3 + item.GetBitmap().GetWidth();
328 text_y = rect.y +
329 (rect.height/2) -
330 (text_height/2);
331 }
332
333
334 if (!(item.GetState() & wxAUI_BUTTON_STATE_DISABLED))
335 {
336 if (item.GetState() & wxAUI_BUTTON_STATE_PRESSED)
337 {
338 dc.SetPen(wxPen(m_highlight_colour));
339 dc.SetBrush(wxBrush(wxAuiStepColour(m_highlight_colour, 150)));
340 dc.DrawRectangle(rect);
341 }
342 else if ((item.GetState() & wxAUI_BUTTON_STATE_HOVER) || item.IsSticky())
343 {
344 dc.SetPen(wxPen(m_highlight_colour));
345 dc.SetBrush(wxBrush(wxAuiStepColour(m_highlight_colour, 170)));
346
347 // draw an even lighter background for checked item hovers (since
348 // the hover background is the same color as the check background)
349 if (item.GetState() & wxAUI_BUTTON_STATE_CHECKED)
350 dc.SetBrush(wxBrush(wxAuiStepColour(m_highlight_colour, 180)));
351
352 dc.DrawRectangle(rect);
353 }
354 else if (item.GetState() & wxAUI_BUTTON_STATE_CHECKED)
355 {
356 // it's important to put this code in an else statment after the
357 // hover, otherwise hovers won't draw properly for checked items
358 dc.SetPen(wxPen(m_highlight_colour));
359 dc.SetBrush(wxBrush(wxAuiStepColour(m_highlight_colour, 170)));
360 dc.DrawRectangle(rect);
361 }
362 }
363
364 wxBitmap bmp;
365 if (item.GetState() & wxAUI_BUTTON_STATE_DISABLED)
366 bmp = item.GetDisabledBitmap();
367 else
368 bmp = item.GetBitmap();
369
370 if (!bmp.IsOk())
371 return;
372
373 dc.DrawBitmap(bmp, bmp_x, bmp_y, true);
374
375 // set the item's text color based on if it is disabled
376 dc.SetTextForeground(*wxBLACK);
377 if (item.GetState() & wxAUI_BUTTON_STATE_DISABLED)
378 dc.SetTextForeground(DISABLED_TEXT_COLOR);
379
380 if ( (m_flags & wxAUI_TB_TEXT) && !item.GetLabel().empty() )
381 {
382 dc.DrawText(item.GetLabel(), text_x, text_y);
383 }
384}
385
386
387void wxAuiDefaultToolBarArt::DrawDropDownButton(
388 wxDC& dc,
389 wxWindow* WXUNUSED(wnd),
390 const wxAuiToolBarItem& item,
391 const wxRect& rect)
392{
393 int text_width = 0, text_height = 0, text_x = 0, text_y = 0;
394 int bmp_x = 0, bmp_y = 0, dropbmp_x = 0, dropbmp_y = 0;
395
396 wxRect button_rect = wxRect(rect.x,
397 rect.y,
398 rect.width-BUTTON_DROPDOWN_WIDTH,
399 rect.height);
400 wxRect dropdown_rect = wxRect(rect.x+rect.width-BUTTON_DROPDOWN_WIDTH-1,
401 rect.y,
402 BUTTON_DROPDOWN_WIDTH+1,
403 rect.height);
404
405 if (m_flags & wxAUI_TB_TEXT)
406 {
407 dc.SetFont(m_font);
408
409 int tx, ty;
410 if (m_flags & wxAUI_TB_TEXT)
411 {
412 dc.GetTextExtent(wxT("ABCDHgj"), &tx, &text_height);
413 text_width = 0;
414 }
415
416 dc.GetTextExtent(item.GetLabel(), &text_width, &ty);
417 }
418
419
420
421 dropbmp_x = dropdown_rect.x +
422 (dropdown_rect.width/2) -
423 (m_button_dropdown_bmp.GetWidth()/2);
424 dropbmp_y = dropdown_rect.y +
425 (dropdown_rect.height/2) -
426 (m_button_dropdown_bmp.GetHeight()/2);
427
428
429 if (m_text_orientation == wxAUI_TBTOOL_TEXT_BOTTOM)
430 {
431 bmp_x = button_rect.x +
432 (button_rect.width/2) -
433 (item.GetBitmap().GetWidth()/2);
434 bmp_y = button_rect.y +
435 ((button_rect.height-text_height)/2) -
436 (item.GetBitmap().GetHeight()/2);
437
438 text_x = rect.x + (rect.width/2) - (text_width/2) + 1;
439 text_y = rect.y + rect.height - text_height - 1;
440 }
441 else if (m_text_orientation == wxAUI_TBTOOL_TEXT_RIGHT)
442 {
443 bmp_x = rect.x + 3;
444
445 bmp_y = rect.y +
446 (rect.height/2) -
447 (item.GetBitmap().GetHeight()/2);
448
449 text_x = bmp_x + 3 + item.GetBitmap().GetWidth();
450 text_y = rect.y +
451 (rect.height/2) -
452 (text_height/2);
453 }
454
455
456 if (item.GetState() & wxAUI_BUTTON_STATE_PRESSED)
457 {
458 dc.SetPen(wxPen(m_highlight_colour));
459 dc.SetBrush(wxBrush(wxAuiStepColour(m_highlight_colour, 140)));
460 dc.DrawRectangle(button_rect);
461 dc.DrawRectangle(dropdown_rect);
462 }
463 else if (item.GetState() & wxAUI_BUTTON_STATE_HOVER ||
464 item.IsSticky())
465 {
466 dc.SetPen(wxPen(m_highlight_colour));
467 dc.SetBrush(wxBrush(wxAuiStepColour(m_highlight_colour, 170)));
468 dc.DrawRectangle(button_rect);
469 dc.DrawRectangle(dropdown_rect);
470 }
471
472 wxBitmap bmp;
473 wxBitmap dropbmp;
474 if (item.GetState() & wxAUI_BUTTON_STATE_DISABLED)
475 {
476 bmp = item.GetDisabledBitmap();
477 dropbmp = m_disabled_button_dropdown_bmp;
478 }
479 else
480 {
481 bmp = item.GetBitmap();
482 dropbmp = m_button_dropdown_bmp;
483 }
484
485 if (!bmp.IsOk())
486 return;
487
488 dc.DrawBitmap(bmp, bmp_x, bmp_y, true);
489 dc.DrawBitmap(dropbmp, dropbmp_x, dropbmp_y, true);
490
491 // set the item's text color based on if it is disabled
492 dc.SetTextForeground(*wxBLACK);
493 if (item.GetState() & wxAUI_BUTTON_STATE_DISABLED)
494 dc.SetTextForeground(DISABLED_TEXT_COLOR);
495
496 if ( (m_flags & wxAUI_TB_TEXT) && !item.GetLabel().empty() )
497 {
498 dc.DrawText(item.GetLabel(), text_x, text_y);
499 }
500}
501
502void wxAuiDefaultToolBarArt::DrawControlLabel(
503 wxDC& dc,
504 wxWindow* WXUNUSED(wnd),
505 const wxAuiToolBarItem& item,
506 const wxRect& rect)
507{
508 if (!(m_flags & wxAUI_TB_TEXT))
509 return;
510
511 if (m_text_orientation != wxAUI_TBTOOL_TEXT_BOTTOM)
512 return;
513
514 int text_x = 0, text_y = 0;
515 int text_width = 0, text_height = 0;
516
517 dc.SetFont(m_font);
518
519 int tx, ty;
520 if (m_flags & wxAUI_TB_TEXT)
521 {
522 dc.GetTextExtent(wxT("ABCDHgj"), &tx, &text_height);
523 text_width = 0;
524 }
525
526 dc.GetTextExtent(item.GetLabel(), &text_width, &ty);
527
528 // don't draw the label if it is wider than the item width
529 if (text_width > rect.width)
530 return;
531
532 // set the label's text color
533 dc.SetTextForeground(*wxBLACK);
534
535 text_x = rect.x + (rect.width/2) - (text_width/2) + 1;
536 text_y = rect.y + rect.height - text_height - 1;
537
538 if ( (m_flags & wxAUI_TB_TEXT) && !item.GetLabel().empty() )
539 {
540 dc.DrawText(item.GetLabel(), text_x, text_y);
541 }
542}
543
544wxSize wxAuiDefaultToolBarArt::GetLabelSize(
545 wxDC& dc,
546 wxWindow* WXUNUSED(wnd),
547 const wxAuiToolBarItem& item)
548{
549 dc.SetFont(m_font);
550
551 // get label's height
552 int width = 0, height = 0;
553 dc.GetTextExtent(wxT("ABCDHgj"), &width, &height);
554
555 // get item's width
556 width = item.GetMinSize().GetWidth();
557
558 if (width == -1)
559 {
560 // no width specified, measure the text ourselves
561 width = dc.GetTextExtent(item.GetLabel()).GetX();
562 }
563
564 return wxSize(width, height);
565}
566
567wxSize wxAuiDefaultToolBarArt::GetToolSize(
568 wxDC& dc,
569 wxWindow* WXUNUSED(wnd),
570 const wxAuiToolBarItem& item)
571{
572 if (!item.GetBitmap().IsOk() && !(m_flags & wxAUI_TB_TEXT))
573 return wxSize(16,16);
574
575 int width = item.GetBitmap().GetWidth();
576 int height = item.GetBitmap().GetHeight();
577
578 if (m_flags & wxAUI_TB_TEXT)
579 {
580 dc.SetFont(m_font);
581 int tx, ty;
582
583 if (m_text_orientation == wxAUI_TBTOOL_TEXT_BOTTOM)
584 {
585 dc.GetTextExtent(wxT("ABCDHgj"), &tx, &ty);
586 height += ty;
587
588 if ( !item.GetLabel().empty() )
589 {
590 dc.GetTextExtent(item.GetLabel(), &tx, &ty);
591 width = wxMax(width, tx+6);
592 }
593 }
594 else if ( m_text_orientation == wxAUI_TBTOOL_TEXT_RIGHT &&
595 !item.GetLabel().empty() )
596 {
597 width += 3; // space between left border and bitmap
598 width += 3; // space between bitmap and text
599
600 if ( !item.GetLabel().empty() )
601 {
602 dc.GetTextExtent(item.GetLabel(), &tx, &ty);
603 width += tx;
604 height = wxMax(height, ty);
605 }
606 }
607 }
608
609 // if the tool has a dropdown button, add it to the width
610 if (item.HasDropDown())
611 width += (BUTTON_DROPDOWN_WIDTH+4);
612
613 return wxSize(width, height);
614}
615
616void wxAuiDefaultToolBarArt::DrawSeparator(
617 wxDC& dc,
618 wxWindow* WXUNUSED(wnd),
619 const wxRect& _rect)
620{
621 bool horizontal = true;
622 if (m_flags & wxAUI_TB_VERTICAL)
623 horizontal = false;
624
625 wxRect rect = _rect;
626
627 if (horizontal)
628 {
629 rect.x += (rect.width/2);
630 rect.width = 1;
631 int new_height = (rect.height*3)/4;
632 rect.y += (rect.height/2) - (new_height/2);
633 rect.height = new_height;
634 }
635 else
636 {
637 rect.y += (rect.height/2);
638 rect.height = 1;
639 int new_width = (rect.width*3)/4;
640 rect.x += (rect.width/2) - (new_width/2);
641 rect.width = new_width;
642 }
643
644 wxColour start_colour = wxAuiStepColour(m_base_colour, 80);
645 wxColour end_colour = wxAuiStepColour(m_base_colour, 80);
646 dc.GradientFillLinear(rect, start_colour, end_colour, horizontal ? wxSOUTH : wxEAST);
647}
648
649void wxAuiDefaultToolBarArt::DrawGripper(wxDC& dc,
650 wxWindow* WXUNUSED(wnd),
651 const wxRect& rect)
652{
653 int i = 0;
654 while (1)
655 {
656 int x, y;
657
658 if (m_flags & wxAUI_TB_VERTICAL)
659 {
660 x = rect.x + (i*4) + 5;
661 y = rect.y + 3;
662 if (x > rect.GetWidth()-5)
663 break;
664 }
665 else
666 {
667 x = rect.x + 3;
668 y = rect.y + (i*4) + 5;
669 if (y > rect.GetHeight()-5)
670 break;
671 }
672
673 dc.SetPen(m_gripper_pen1);
674 dc.DrawPoint(x, y);
675 dc.SetPen(m_gripper_pen2);
676 dc.DrawPoint(x, y+1);
677 dc.DrawPoint(x+1, y);
678 dc.SetPen(m_gripper_pen3);
679 dc.DrawPoint(x+2, y+1);
680 dc.DrawPoint(x+2, y+2);
681 dc.DrawPoint(x+1, y+2);
682
683 i++;
684 }
685
686}
687
688void wxAuiDefaultToolBarArt::DrawOverflowButton(wxDC& dc,
689 wxWindow* wnd,
690 const wxRect& rect,
691 int state)
692{
693 if (state & wxAUI_BUTTON_STATE_HOVER ||
694 state & wxAUI_BUTTON_STATE_PRESSED)
695 {
696 wxRect cli_rect = wnd->GetClientRect();
697 wxColor light_gray_bg = wxAuiStepColour(m_highlight_colour, 170);
698
699 if (m_flags & wxAUI_TB_VERTICAL)
700 {
701 dc.SetPen(wxPen(m_highlight_colour));
702 dc.DrawLine(rect.x, rect.y, rect.x+rect.width, rect.y);
703 dc.SetPen(wxPen(light_gray_bg));
704 dc.SetBrush(wxBrush(light_gray_bg));
705 dc.DrawRectangle(rect.x, rect.y+1, rect.width, rect.height);
706 }
707 else
708 {
709 dc.SetPen(wxPen(m_highlight_colour));
710 dc.DrawLine(rect.x, rect.y, rect.x, rect.y+rect.height);
711 dc.SetPen(wxPen(light_gray_bg));
712 dc.SetBrush(wxBrush(light_gray_bg));
713 dc.DrawRectangle(rect.x+1, rect.y, rect.width, rect.height);
714 }
715 }
716
717 int x = rect.x+1+(rect.width-m_overflow_bmp.GetWidth())/2;
718 int y = rect.y+1+(rect.height-m_overflow_bmp.GetHeight())/2;
719 dc.DrawBitmap(m_overflow_bmp, x, y, true);
720}
721
722int wxAuiDefaultToolBarArt::GetElementSize(int element_id)
723{
724 switch (element_id)
725 {
726 case wxAUI_TBART_SEPARATOR_SIZE: return m_separator_size;
727 case wxAUI_TBART_GRIPPER_SIZE: return m_gripper_size;
728 case wxAUI_TBART_OVERFLOW_SIZE: return m_overflow_size;
729 default: return 0;
730 }
731}
732
733void wxAuiDefaultToolBarArt::SetElementSize(int element_id, int size)
734{
735 switch (element_id)
736 {
737 case wxAUI_TBART_SEPARATOR_SIZE: m_separator_size = size; break;
738 case wxAUI_TBART_GRIPPER_SIZE: m_gripper_size = size; break;
739 case wxAUI_TBART_OVERFLOW_SIZE: m_overflow_size = size; break;
740 }
741}
742
743int wxAuiDefaultToolBarArt::ShowDropDown(wxWindow* wnd,
744 const wxAuiToolBarItemArray& items)
745{
746 wxMenu menuPopup;
747
748 size_t items_added = 0;
749
750 size_t i, count = items.GetCount();
751 for (i = 0; i < count; ++i)
752 {
753 wxAuiToolBarItem& item = items.Item(i);
754
755 if (item.GetKind() == wxITEM_NORMAL)
756 {
757 wxString text = item.GetShortHelp();
758 if (text.empty())
759 text = item.GetLabel();
760
761 if (text.empty())
762 text = wxT(" ");
763
764 wxMenuItem* m = new wxMenuItem(&menuPopup, item.GetId(), text, item.GetShortHelp());
765
766 m->SetBitmap(item.GetBitmap());
767 menuPopup.Append(m);
768 items_added++;
769 }
770 else if (item.GetKind() == wxITEM_SEPARATOR)
771 {
772 if (items_added > 0)
773 menuPopup.AppendSeparator();
774 }
775 }
776
777 // find out where to put the popup menu of window items
778 wxPoint pt = ::wxGetMousePosition();
779 pt = wnd->ScreenToClient(pt);
780
781 // find out the screen coordinate at the bottom of the tab ctrl
782 wxRect cli_rect = wnd->GetClientRect();
783 pt.y = cli_rect.y + cli_rect.height;
784
785 ToolbarCommandCapture* cc = new ToolbarCommandCapture;
786 wnd->PushEventHandler(cc);
787 wnd->PopupMenu(&menuPopup, pt);
788 int command = cc->GetCommandId();
789 wnd->PopEventHandler(true);
790
791 return command;
792}
793
794
795
796
797BEGIN_EVENT_TABLE(wxAuiToolBar, wxControl)
798 EVT_SIZE(wxAuiToolBar::OnSize)
799 EVT_IDLE(wxAuiToolBar::OnIdle)
800 EVT_ERASE_BACKGROUND(wxAuiToolBar::OnEraseBackground)
801 EVT_PAINT(wxAuiToolBar::OnPaint)
802 EVT_LEFT_DOWN(wxAuiToolBar::OnLeftDown)
803 EVT_LEFT_DCLICK(wxAuiToolBar::OnLeftDown)
804 EVT_LEFT_UP(wxAuiToolBar::OnLeftUp)
805 EVT_RIGHT_DOWN(wxAuiToolBar::OnRightDown)
806 EVT_RIGHT_DCLICK(wxAuiToolBar::OnRightDown)
807 EVT_RIGHT_UP(wxAuiToolBar::OnRightUp)
808 EVT_MIDDLE_DOWN(wxAuiToolBar::OnMiddleDown)
809 EVT_MIDDLE_DCLICK(wxAuiToolBar::OnMiddleDown)
810 EVT_MIDDLE_UP(wxAuiToolBar::OnMiddleUp)
811 EVT_MOTION(wxAuiToolBar::OnMotion)
812 EVT_LEAVE_WINDOW(wxAuiToolBar::OnLeaveWindow)
813 EVT_SET_CURSOR(wxAuiToolBar::OnSetCursor)
814END_EVENT_TABLE()
815
816
817wxAuiToolBar::wxAuiToolBar(wxWindow* parent,
818 wxWindowID id,
819 const wxPoint& position,
820 const wxSize& size,
821 long style)
822 : wxControl(parent,
823 id,
824 position,
825 size,
826 style | wxBORDER_NONE)
827{
828 m_sizer = new wxBoxSizer(wxHORIZONTAL);
829 m_button_width = -1;
830 m_button_height = -1;
831 m_sizer_element_count = 0;
832 m_action_pos = wxPoint(-1,-1);
833 m_action_item = NULL;
834 m_tip_item = NULL;
835 m_art = new wxAuiDefaultToolBarArt;
836 m_tool_packing = 2;
837 m_tool_border_padding = 3;
838 m_tool_text_orientation = wxAUI_TBTOOL_TEXT_BOTTOM;
839 m_gripper_sizer_item = NULL;
840 m_overflow_sizer_item = NULL;
841 m_dragging = false;
842 m_style = style | wxBORDER_NONE;
843 m_gripper_visible = (m_style & wxAUI_TB_GRIPPER) ? true : false;
844 m_overflow_visible = (m_style & wxAUI_TB_OVERFLOW) ? true : false;
845 m_overflow_state = 0;
846 SetMargins(5, 5, 2, 2);
847 SetFont(*wxNORMAL_FONT);
848 m_art->SetFlags((unsigned int)m_style);
849 SetExtraStyle(wxWS_EX_PROCESS_IDLE);
850 if (style & wxAUI_TB_HORZ_LAYOUT)
851 SetToolTextOrientation(wxAUI_TBTOOL_TEXT_RIGHT);
852 SetBackgroundStyle(wxBG_STYLE_CUSTOM);
853}
854
855
856wxAuiToolBar::~wxAuiToolBar()
857{
858 delete m_art;
859 delete m_sizer;
860}
861
862void wxAuiToolBar::SetWindowStyleFlag(long style)
863{
864 wxControl::SetWindowStyleFlag(style);
865
866 m_style = style;
867
868 if (m_art)
869 {
870 m_art->SetFlags((unsigned int)m_style);
871 }
872
873 if (m_style & wxAUI_TB_GRIPPER)
874 m_gripper_visible = true;
875 else
876 m_gripper_visible = false;
877
878
879 if (m_style & wxAUI_TB_OVERFLOW)
880 m_overflow_visible = true;
881 else
882 m_overflow_visible = false;
883
884 if (style & wxAUI_TB_HORZ_LAYOUT)
885 SetToolTextOrientation(wxAUI_TBTOOL_TEXT_RIGHT);
886 else
887 SetToolTextOrientation(wxAUI_TBTOOL_TEXT_BOTTOM);
888}
889
890long wxAuiToolBar::GetWindowStyleFlag() const
891{
892 return m_style;
893}
894
895void wxAuiToolBar::SetArtProvider(wxAuiToolBarArt* art)
896{
897 delete m_art;
898
899 m_art = art;
900
901 if (m_art)
902 {
903 m_art->SetFlags((unsigned int)m_style);
904 m_art->SetTextOrientation(m_tool_text_orientation);
905 }
906}
907
908wxAuiToolBarArt* wxAuiToolBar::GetArtProvider() const
909{
910 return m_art;
911}
912
913
914
915
916wxAuiToolBarItem* wxAuiToolBar::AddTool(int tool_id,
917 const wxString& label,
918 const wxBitmap& bitmap,
919 const wxString& short_help_string,
920 wxItemKind kind)
921{
922 return AddTool(tool_id,
923 label,
924 bitmap,
925 wxNullBitmap,
926 kind,
927 short_help_string,
928 wxEmptyString,
929 NULL);
930}
931
932
933wxAuiToolBarItem* wxAuiToolBar::AddTool(int tool_id,
934 const wxString& label,
935 const wxBitmap& bitmap,
936 const wxBitmap& disabled_bitmap,
937 wxItemKind kind,
938 const wxString& short_help_string,
939 const wxString& long_help_string,
940 wxObject* WXUNUSED(client_data))
941{
942 wxAuiToolBarItem item;
943 item.window = NULL;
944 item.label = label;
945 item.bitmap = bitmap;
946 item.disabled_bitmap = disabled_bitmap;
947 item.short_help = short_help_string;
948 item.long_help = long_help_string;
949 item.active = true;
950 item.dropdown = false;
951 item.spacer_pixels = 0;
952 item.id = tool_id;
953 item.state = 0;
954 item.proportion = 0;
955 item.kind = kind;
956 item.sizer_item = NULL;
957 item.min_size = wxDefaultSize;
958 item.user_data = 0;
959 item.sticky = false;
960
961 if (item.id == wxID_ANY)
962 item.id = wxNewId();
963
964 if (!item.disabled_bitmap.IsOk())
965 {
966 // no disabled bitmap specified, we need to make one
967 if (item.bitmap.IsOk())
968 {
969 //wxImage img = item.bitmap.ConvertToImage();
970 //wxImage grey_version = img.ConvertToGreyscale();
971 //item.disabled_bitmap = wxBitmap(grey_version);
972 item.disabled_bitmap = MakeDisabledBitmap(item.bitmap);
973 }
974 }
975 m_items.Add(item);
976 return &m_items.Last();
977}
978
979wxAuiToolBarItem* wxAuiToolBar::AddControl(wxControl* control,
980 const wxString& label)
981{
982 wxAuiToolBarItem item;
983 item.window = (wxWindow*)control;
984 item.label = label;
985 item.bitmap = wxNullBitmap;
986 item.disabled_bitmap = wxNullBitmap;
987 item.active = true;
988 item.dropdown = false;
989 item.spacer_pixels = 0;
990 item.id = control->GetId();
991 item.state = 0;
992 item.proportion = 0;
993 item.kind = wxITEM_CONTROL;
994 item.sizer_item = NULL;
995 item.min_size = control->GetEffectiveMinSize();
996 item.user_data = 0;
997 item.sticky = false;
998
999 m_items.Add(item);
1000 return &m_items.Last();
1001}
1002
1003wxAuiToolBarItem* wxAuiToolBar::AddLabel(int tool_id,
1004 const wxString& label,
1005 const int width)
1006{
1007 wxSize min_size = wxDefaultSize;
1008 if (width != -1)
1009 min_size.x = width;
1010
1011 wxAuiToolBarItem item;
1012 item.window = NULL;
1013 item.label = label;
1014 item.bitmap = wxNullBitmap;
1015 item.disabled_bitmap = wxNullBitmap;
1016 item.active = true;
1017 item.dropdown = false;
1018 item.spacer_pixels = 0;
1019 item.id = tool_id;
1020 item.state = 0;
1021 item.proportion = 0;
1022 item.kind = wxITEM_LABEL;
1023 item.sizer_item = NULL;
1024 item.min_size = min_size;
1025 item.user_data = 0;
1026 item.sticky = false;
1027
1028 if (item.id == wxID_ANY)
1029 item.id = wxNewId();
1030
1031 m_items.Add(item);
1032 return &m_items.Last();
1033}
1034
1035wxAuiToolBarItem* wxAuiToolBar::AddSeparator()
1036{
1037 wxAuiToolBarItem item;
1038 item.window = NULL;
1039 item.label = wxEmptyString;
1040 item.bitmap = wxNullBitmap;
1041 item.disabled_bitmap = wxNullBitmap;
1042 item.active = true;
1043 item.dropdown = false;
1044 item.id = -1;
1045 item.state = 0;
1046 item.proportion = 0;
1047 item.kind = wxITEM_SEPARATOR;
1048 item.sizer_item = NULL;
1049 item.min_size = wxDefaultSize;
1050 item.user_data = 0;
1051 item.sticky = false;
1052
1053 m_items.Add(item);
1054 return &m_items.Last();
1055}
1056
1057wxAuiToolBarItem* wxAuiToolBar::AddSpacer(int pixels)
1058{
1059 wxAuiToolBarItem item;
1060 item.window = NULL;
1061 item.label = wxEmptyString;
1062 item.bitmap = wxNullBitmap;
1063 item.disabled_bitmap = wxNullBitmap;
1064 item.active = true;
1065 item.dropdown = false;
1066 item.spacer_pixels = pixels;
1067 item.id = -1;
1068 item.state = 0;
1069 item.proportion = 0;
1070 item.kind = wxITEM_SPACER;
1071 item.sizer_item = NULL;
1072 item.min_size = wxDefaultSize;
1073 item.user_data = 0;
1074 item.sticky = false;
1075
1076 m_items.Add(item);
1077 return &m_items.Last();
1078}
1079
1080wxAuiToolBarItem* wxAuiToolBar::AddStretchSpacer(int proportion)
1081{
1082 wxAuiToolBarItem item;
1083 item.window = NULL;
1084 item.label = wxEmptyString;
1085 item.bitmap = wxNullBitmap;
1086 item.disabled_bitmap = wxNullBitmap;
1087 item.active = true;
1088 item.dropdown = false;
1089 item.spacer_pixels = 0;
1090 item.id = -1;
1091 item.state = 0;
1092 item.proportion = proportion;
1093 item.kind = wxITEM_SPACER;
1094 item.sizer_item = NULL;
1095 item.min_size = wxDefaultSize;
1096 item.user_data = 0;
1097 item.sticky = false;
1098
1099 m_items.Add(item);
1100 return &m_items.Last();
1101}
1102
1103void wxAuiToolBar::Clear()
1104{
1105 m_items.Clear();
1106 m_sizer_element_count = 0;
1107}
1108
1109bool wxAuiToolBar::DeleteTool(int tool_id)
1110{
1111 int idx = GetToolIndex(tool_id);
1112 if (idx >= 0 && idx < (int)m_items.GetCount())
1113 {
1114 m_items.RemoveAt(idx);
1115 Realize();
1116 return true;
1117 }
1118
1119 return false;
1120}
1121
1122bool wxAuiToolBar::DeleteByIndex(int idx)
1123{
1124 if (idx >= 0 && idx < (int)m_items.GetCount())
1125 {
1126 m_items.RemoveAt(idx);
1127 Realize();
1128 return true;
1129 }
1130
1131 return false;
1132}
1133
1134
1135wxControl* wxAuiToolBar::FindControl(int id)
1136{
1137 wxWindow* wnd = FindWindow(id);
1138 return (wxControl*)wnd;
1139}
1140
1141wxAuiToolBarItem* wxAuiToolBar::FindTool(int tool_id) const
1142{
1143 size_t i, count;
1144 for (i = 0, count = m_items.GetCount(); i < count; ++i)
1145 {
1146 wxAuiToolBarItem& item = m_items.Item(i);
1147 if (item.id == tool_id)
1148 return &item;
1149 }
1150
1151 return NULL;
1152}
1153
1154wxAuiToolBarItem* wxAuiToolBar::FindToolByPosition(wxCoord x, wxCoord y) const
1155{
1156 size_t i, count;
1157 for (i = 0, count = m_items.GetCount(); i < count; ++i)
1158 {
1159 wxAuiToolBarItem& item = m_items.Item(i);
1160
1161 if (!item.sizer_item)
1162 continue;
1163
1164 wxRect rect = item.sizer_item->GetRect();
1165 if (rect.Contains(x,y))
1166 {
1167 // if the item doesn't fit on the toolbar, return NULL
1168 if (!GetToolFitsByIndex(i))
1169 return NULL;
1170
1171 return &item;
1172 }
1173 }
1174
1175 return NULL;
1176}
1177
1178wxAuiToolBarItem* wxAuiToolBar::FindToolByPositionWithPacking(wxCoord x, wxCoord y) const
1179{
1180 size_t i, count;
1181 for (i = 0, count = m_items.GetCount(); i < count; ++i)
1182 {
1183 wxAuiToolBarItem& item = m_items.Item(i);
1184
1185 if (!item.sizer_item)
1186 continue;
1187
1188 wxRect rect = item.sizer_item->GetRect();
1189
1190 // apply tool packing
1191 if (i+1 < count)
1192 rect.width += m_tool_packing;
1193
1194 if (rect.Contains(x,y))
1195 {
1196 // if the item doesn't fit on the toolbar, return NULL
1197 if (!GetToolFitsByIndex(i))
1198 return NULL;
1199
1200 return &item;
1201 }
1202 }
1203
1204 return NULL;
1205}
1206
1207wxAuiToolBarItem* wxAuiToolBar::FindToolByIndex(int idx) const
1208{
1209 if (idx < 0)
1210 return NULL;
1211
1212 if (idx >= (int)m_items.size())
1213 return NULL;
1214
1215 return &(m_items[idx]);
1216}
1217
1218void wxAuiToolBar::SetToolBitmapSize(const wxSize& WXUNUSED(size))
1219{
1220 // TODO: wxToolBar compatibility
1221}
1222
1223wxSize wxAuiToolBar::GetToolBitmapSize() const
1224{
1225 // TODO: wxToolBar compatibility
1226 return wxSize(16,15);
1227}
1228
1229void wxAuiToolBar::SetToolProportion(int tool_id, int proportion)
1230{
1231 wxAuiToolBarItem* item = FindTool(tool_id);
1232 if (!item)
1233 return;
1234
1235 item->proportion = proportion;
1236}
1237
1238int wxAuiToolBar::GetToolProportion(int tool_id) const
1239{
1240 wxAuiToolBarItem* item = FindTool(tool_id);
1241 if (!item)
1242 return 0;
1243
1244 return item->proportion;
1245}
1246
1247void wxAuiToolBar::SetToolSeparation(int separation)
1248{
1249 if (m_art)
1250 m_art->SetElementSize(wxAUI_TBART_SEPARATOR_SIZE, separation);
1251}
1252
1253int wxAuiToolBar::GetToolSeparation() const
1254{
1255 if (m_art)
1256 return m_art->GetElementSize(wxAUI_TBART_SEPARATOR_SIZE);
1257 else
1258 return 5;
1259}
1260
1261
1262void wxAuiToolBar::SetToolDropDown(int tool_id, bool dropdown)
1263{
1264 wxAuiToolBarItem* item = FindTool(tool_id);
1265 if (!item)
1266 return;
1267
1268 item->dropdown = dropdown;
1269}
1270
1271bool wxAuiToolBar::GetToolDropDown(int tool_id) const
1272{
1273 wxAuiToolBarItem* item = FindTool(tool_id);
1274 if (!item)
1275 return 0;
1276
1277 return item->dropdown;
1278}
1279
1280void wxAuiToolBar::SetToolSticky(int tool_id, bool sticky)
1281{
1282 // ignore separators
1283 if (tool_id == -1)
1284 return;
1285
1286 wxAuiToolBarItem* item = FindTool(tool_id);
1287 if (!item)
1288 return;
1289
1290 if (item->sticky == sticky)
1291 return;
1292
1293 item->sticky = sticky;
1294
1295 Refresh(false);
1296 Update();
1297}
1298
1299bool wxAuiToolBar::GetToolSticky(int tool_id) const
1300{
1301 wxAuiToolBarItem* item = FindTool(tool_id);
1302 if (!item)
1303 return 0;
1304
1305 return item->sticky;
1306}
1307
1308
1309
1310
1311void wxAuiToolBar::SetToolBorderPadding(int padding)
1312{
1313 m_tool_border_padding = padding;
1314}
1315
1316int wxAuiToolBar::GetToolBorderPadding() const
1317{
1318 return m_tool_border_padding;
1319}
1320
1321void wxAuiToolBar::SetToolTextOrientation(int orientation)
1322{
1323 m_tool_text_orientation = orientation;
1324
1325 if (m_art)
1326 {
1327 m_art->SetTextOrientation(orientation);
1328 }
1329}
1330
1331int wxAuiToolBar::GetToolTextOrientation() const
1332{
1333 return m_tool_text_orientation;
1334}
1335
1336void wxAuiToolBar::SetToolPacking(int packing)
1337{
1338 m_tool_packing = packing;
1339}
1340
1341int wxAuiToolBar::GetToolPacking() const
1342{
1343 return m_tool_packing;
1344}
1345
1346
1347void wxAuiToolBar::SetOrientation(int WXUNUSED(orientation))
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; 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; 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
1657size_t wxAuiToolBar::GetToolCount() const
1658{
1659 return m_items.size();
1660}
1661
1662int wxAuiToolBar::GetToolIndex(int tool_id) const
1663{
1664 // this will prevent us from returning the index of the
1665 // first separator in the toolbar since its id is equal to -1
1666 if (tool_id == -1)
1667 return wxNOT_FOUND;
1668
1669 size_t i, count = m_items.GetCount();
1670 for (i = 0; i < count; ++i)
1671 {
1672 wxAuiToolBarItem& item = m_items.Item(i);
1673 if (item.id == tool_id)
1674 return i;
1675 }
1676
1677 return wxNOT_FOUND;
1678}
1679
1680bool wxAuiToolBar::GetToolFitsByIndex(int tool_idx) const
1681{
1682 if (tool_idx < 0 || tool_idx >= (int)m_items.GetCount())
1683 return false;
1684
1685 if (!m_items[tool_idx].sizer_item)
1686 return false;
1687
1688 int cli_w, cli_h;
1689 GetClientSize(&cli_w, &cli_h);
1690
1691 wxRect rect = m_items[tool_idx].sizer_item->GetRect();
1692
1693 if (m_style & wxAUI_TB_VERTICAL)
1694 {
1695 // take the dropdown size into account
1696 if (m_overflow_visible)
1697 cli_h -= m_overflow_sizer_item->GetSize().y;
1698
1699 if (rect.y+rect.height < cli_h)
1700 return true;
1701 }
1702 else
1703 {
1704 // take the dropdown size into account
1705 if (m_overflow_visible)
1706 cli_w -= m_overflow_sizer_item->GetSize().x;
1707
1708 if (rect.x+rect.width < cli_w)
1709 return true;
1710 }
1711
1712 return false;
1713}
1714
1715
1716bool wxAuiToolBar::GetToolFits(int tool_id) const
1717{
1718 return GetToolFitsByIndex(GetToolIndex(tool_id));
1719}
1720
1721wxRect wxAuiToolBar::GetToolRect(int tool_id) const
1722{
1723 wxAuiToolBarItem* tool = FindTool(tool_id);
1724 if (tool && tool->sizer_item)
1725 {
1726 return tool->sizer_item->GetRect();
1727 }
1728
1729 return wxRect();
1730}
1731
1732bool wxAuiToolBar::GetToolBarFits() const
1733{
1734 if (m_items.GetCount() == 0)
1735 {
1736 // empty toolbar always 'fits'
1737 return true;
1738 }
1739
1740 // entire toolbar content fits if the last tool fits
1741 return GetToolFitsByIndex(m_items.GetCount() - 1);
1742}
1743
1744bool wxAuiToolBar::Realize()
1745{
1746 wxClientDC dc(this);
1747 if (!dc.IsOk())
1748 return false;
1749
1750 bool horizontal = true;
1751 if (m_style & wxAUI_TB_VERTICAL)
1752 horizontal = false;
1753
1754
1755 // create the new sizer to add toolbar elements to
1756 wxBoxSizer* sizer = new wxBoxSizer(horizontal ? wxHORIZONTAL : wxVERTICAL);
1757
1758 // add gripper area
1759 int separator_size = m_art->GetElementSize(wxAUI_TBART_SEPARATOR_SIZE);
1760 int gripper_size = m_art->GetElementSize(wxAUI_TBART_GRIPPER_SIZE);
1761 if (gripper_size > 0 && m_gripper_visible)
1762 {
1763 if (horizontal)
1764 m_gripper_sizer_item = sizer->Add(gripper_size, 1, 0, wxEXPAND);
1765 else
1766 m_gripper_sizer_item = sizer->Add(1, gripper_size, 0, wxEXPAND);
1767 }
1768 else
1769 {
1770 m_gripper_sizer_item = NULL;
1771 }
1772
1773 // add "left" padding
1774 if (m_left_padding > 0)
1775 {
1776 if (horizontal)
1777 sizer->Add(m_left_padding, 1);
1778 else
1779 sizer->Add(1, m_left_padding);
1780 }
1781
1782 size_t i, count;
1783 for (i = 0, count = m_items.GetCount(); i < count; ++i)
1784 {
1785 wxAuiToolBarItem& item = m_items.Item(i);
1786 wxSizerItem* sizer_item = NULL;
1787
1788 switch (item.kind)
1789 {
1790 case wxITEM_LABEL:
1791 {
1792 wxSize size = m_art->GetLabelSize(dc, this, item);
1793 sizer_item = sizer->Add(size.x + (m_tool_border_padding*2),
1794 size.y + (m_tool_border_padding*2),
1795 item.proportion,
1796 item.alignment);
1797 if (i+1 < count)
1798 {
1799 sizer->AddSpacer(m_tool_packing);
1800 }
1801
1802 break;
1803 }
1804
1805 case wxITEM_CHECK:
1806 case wxITEM_NORMAL:
1807 case wxITEM_RADIO:
1808 {
1809 wxSize size = m_art->GetToolSize(dc, this, item);
1810 sizer_item = sizer->Add(size.x + (m_tool_border_padding*2),
1811 size.y + (m_tool_border_padding*2),
1812 0,
1813 item.alignment);
1814 // add tool packing
1815 if (i+1 < count)
1816 {
1817 sizer->AddSpacer(m_tool_packing);
1818 }
1819
1820 break;
1821 }
1822
1823 case wxITEM_SEPARATOR:
1824 {
1825 if (horizontal)
1826 sizer_item = sizer->Add(separator_size, 1, 0, wxEXPAND);
1827 else
1828 sizer_item = sizer->Add(1, separator_size, 0, wxEXPAND);
1829
1830 // add tool packing
1831 if (i+1 < count)
1832 {
1833 sizer->AddSpacer(m_tool_packing);
1834 }
1835
1836 break;
1837 }
1838
1839 case wxITEM_SPACER:
1840 if (item.proportion > 0)
1841 sizer_item = sizer->AddStretchSpacer(item.proportion);
1842 else
1843 sizer_item = sizer->Add(item.spacer_pixels, 1);
1844 break;
1845
1846 case wxITEM_CONTROL:
1847 {
1848 //sizer_item = sizer->Add(item.window, item.proportion, wxEXPAND);
1849 wxSizerItem* ctrl_sizer_item;
1850
1851 wxBoxSizer* vert_sizer = new wxBoxSizer(wxVERTICAL);
1852 vert_sizer->AddStretchSpacer(1);
1853 ctrl_sizer_item = vert_sizer->Add(item.window, 0, wxEXPAND);
1854 vert_sizer->AddStretchSpacer(1);
1855 if ( (m_style & wxAUI_TB_TEXT) &&
1856 m_tool_text_orientation == wxAUI_TBTOOL_TEXT_BOTTOM &&
1857 !item.GetLabel().empty() )
1858 {
1859 wxSize s = GetLabelSize(item.GetLabel());
1860 vert_sizer->Add(1, s.y);
1861 }
1862
1863
1864 sizer_item = sizer->Add(vert_sizer, item.proportion, wxEXPAND);
1865
1866 wxSize min_size = item.min_size;
1867
1868
1869 // proportional items will disappear from the toolbar if
1870 // their min width is not set to something really small
1871 if (item.proportion != 0)
1872 {
1873 min_size.x = 1;
1874 }
1875
1876 if (min_size.IsFullySpecified())
1877 {
1878 sizer_item->SetMinSize(min_size);
1879 ctrl_sizer_item->SetMinSize(min_size);
1880 }
1881
1882 // add tool packing
1883 if (i+1 < count)
1884 {
1885 sizer->AddSpacer(m_tool_packing);
1886 }
1887 }
1888 }
1889
1890 item.sizer_item = sizer_item;
1891 }
1892
1893 // add "right" padding
1894 if (m_right_padding > 0)
1895 {
1896 if (horizontal)
1897 sizer->Add(m_right_padding, 1);
1898 else
1899 sizer->Add(1, m_right_padding);
1900 }
1901
1902 // add drop down area
1903 m_overflow_sizer_item = NULL;
1904
1905 if (m_style & wxAUI_TB_OVERFLOW)
1906 {
1907 int overflow_size = m_art->GetElementSize(wxAUI_TBART_OVERFLOW_SIZE);
1908 if (overflow_size > 0 && m_overflow_visible)
1909 {
1910 if (horizontal)
1911 m_overflow_sizer_item = sizer->Add(overflow_size, 1, 0, wxEXPAND);
1912 else
1913 m_overflow_sizer_item = sizer->Add(1, overflow_size, 0, wxEXPAND);
1914 }
1915 else
1916 {
1917 m_overflow_sizer_item = NULL;
1918 }
1919 }
1920
1921
1922 // the outside sizer helps us apply the "top" and "bottom" padding
1923 wxBoxSizer* outside_sizer = new wxBoxSizer(horizontal ? wxVERTICAL : wxHORIZONTAL);
1924
1925 // add "top" padding
1926 if (m_top_padding > 0)
1927 {
1928 if (horizontal)
1929 outside_sizer->Add(1, m_top_padding);
1930 else
1931 outside_sizer->Add(m_top_padding, 1);
1932 }
1933
1934 // add the sizer that contains all of the toolbar elements
1935 outside_sizer->Add(sizer, 1, wxEXPAND);
1936
1937 // add "bottom" padding
1938 if (m_bottom_padding > 0)
1939 {
1940 if (horizontal)
1941 outside_sizer->Add(1, m_bottom_padding);
1942 else
1943 outside_sizer->Add(m_bottom_padding, 1);
1944 }
1945
1946 delete m_sizer; // remove old sizer
1947 m_sizer = outside_sizer;
1948
1949 // calculate the rock-bottom minimum size
1950 for (i = 0, count = m_items.GetCount(); i < count; ++i)
1951 {
1952 wxAuiToolBarItem& item = m_items.Item(i);
1953 if (item.sizer_item && item.proportion > 0 && item.min_size.IsFullySpecified())
1954 item.sizer_item->SetMinSize(0,0);
1955 }
1956
1957 m_absolute_min_size = m_sizer->GetMinSize();
1958
1959 // reset the min sizes to what they were
1960 for (i = 0, count = m_items.GetCount(); i < count; ++i)
1961 {
1962 wxAuiToolBarItem& item = m_items.Item(i);
1963 if (item.sizer_item && item.proportion > 0 && item.min_size.IsFullySpecified())
1964 item.sizer_item->SetMinSize(item.min_size);
1965 }
1966
1967 // set control size
1968 wxSize size = m_sizer->GetMinSize();
1969 m_minWidth = size.x;
1970 m_minHeight = size.y;
1971
1972 if ((m_style & wxAUI_TB_NO_AUTORESIZE) == 0)
1973 {
1974 wxSize cur_size = GetClientSize();
1975 wxSize new_size = GetMinSize();
1976 if (new_size != cur_size)
1977 {
1978 SetClientSize(new_size);
1979 }
1980 else
1981 {
1982 m_sizer->SetDimension(0, 0, cur_size.x, cur_size.y);
1983 }
1984 }
1985 else
1986 {
1987 wxSize cur_size = GetClientSize();
1988 m_sizer->SetDimension(0, 0, cur_size.x, cur_size.y);
1989 }
1990
1991 Refresh(false);
1992 return true;
1993}
1994
1995int wxAuiToolBar::GetOverflowState() const
1996{
1997 return m_overflow_state;
1998}
1999
2000wxRect wxAuiToolBar::GetOverflowRect() const
2001{
2002 wxRect cli_rect(wxPoint(0,0), GetClientSize());
2003 wxRect overflow_rect = m_overflow_sizer_item->GetRect();
2004 int overflow_size = m_art->GetElementSize(wxAUI_TBART_OVERFLOW_SIZE);
2005
2006 if (m_style & wxAUI_TB_VERTICAL)
2007 {
2008 overflow_rect.y = cli_rect.height - overflow_size;
2009 overflow_rect.x = 0;
2010 overflow_rect.width = cli_rect.width;
2011 overflow_rect.height = overflow_size;
2012 }
2013 else
2014 {
2015 overflow_rect.x = cli_rect.width - overflow_size;
2016 overflow_rect.y = 0;
2017 overflow_rect.width = overflow_size;
2018 overflow_rect.height = cli_rect.height;
2019 }
2020
2021 return overflow_rect;
2022}
2023
2024wxSize wxAuiToolBar::GetLabelSize(const wxString& label)
2025{
2026 wxClientDC dc(this);
2027
2028 int tx, ty;
2029 int text_width = 0, text_height = 0;
2030
2031 dc.SetFont(m_font);
2032
2033 // get the text height
2034 dc.GetTextExtent(wxT("ABCDHgj"), &tx, &text_height);
2035
2036 // get the text width
2037 dc.GetTextExtent(label, &text_width, &ty);
2038
2039 return wxSize(text_width, text_height);
2040}
2041
2042
2043void wxAuiToolBar::DoIdleUpdate()
2044{
2045 wxEvtHandler* handler = GetEventHandler();
2046
2047 bool need_refresh = false;
2048
2049 size_t i, count;
2050 for (i = 0, count = m_items.GetCount(); i < count; ++i)
2051 {
2052 wxAuiToolBarItem& item = m_items.Item(i);
2053
2054 if (item.id == -1)
2055 continue;
2056
2057 wxUpdateUIEvent evt(item.id);
2058 evt.SetEventObject(this);
2059
2060 if (handler->ProcessEvent(evt))
2061 {
2062 if (evt.GetSetEnabled())
2063 {
2064 bool is_enabled;
2065 if (item.window)
2066 is_enabled = item.window->IsEnabled();
2067 else
2068 is_enabled = (item.state & wxAUI_BUTTON_STATE_DISABLED) ? false : true;
2069
2070 bool new_enabled = evt.GetEnabled();
2071 if (new_enabled != is_enabled)
2072 {
2073 if (item.window)
2074 {
2075 item.window->Enable(new_enabled);
2076 }
2077 else
2078 {
2079 if (new_enabled)
2080 item.state &= ~wxAUI_BUTTON_STATE_DISABLED;
2081 else
2082 item.state |= wxAUI_BUTTON_STATE_DISABLED;
2083 }
2084 need_refresh = true;
2085 }
2086 }
2087
2088 if (evt.GetSetChecked())
2089 {
2090 // make sure we aren't checking an item that can't be
2091 if (item.kind != wxITEM_CHECK && item.kind != wxITEM_RADIO)
2092 continue;
2093
2094 bool is_checked = (item.state & wxAUI_BUTTON_STATE_CHECKED) ? true : false;
2095 bool new_checked = evt.GetChecked();
2096
2097 if (new_checked != is_checked)
2098 {
2099 if (new_checked)
2100 item.state |= wxAUI_BUTTON_STATE_CHECKED;
2101 else
2102 item.state &= ~wxAUI_BUTTON_STATE_CHECKED;
2103
2104 need_refresh = true;
2105 }
2106 }
2107
2108 }
2109 }
2110
2111
2112 if (need_refresh)
2113 {
2114 Refresh(false);
2115 }
2116}
2117
2118
2119void wxAuiToolBar::OnSize(wxSizeEvent& WXUNUSED(evt))
2120{
2121 int x, y;
2122 GetClientSize(&x, &y);
2123
2124 if (x > y)
2125 SetOrientation(wxHORIZONTAL);
2126 else
2127 SetOrientation(wxVERTICAL);
2128
2129 if (((x >= y) && m_absolute_min_size.x > x) ||
2130 ((y > x) && m_absolute_min_size.y > y))
2131 {
2132 // hide all flexible items
2133 size_t i, count;
2134 for (i = 0, count = m_items.GetCount(); i < count; ++i)
2135 {
2136 wxAuiToolBarItem& item = m_items.Item(i);
2137 if (item.sizer_item && item.proportion > 0 && item.sizer_item->IsShown())
2138 {
2139 item.sizer_item->Show(false);
2140 item.sizer_item->SetProportion(0);
2141 }
2142 }
2143 }
2144 else
2145 {
2146 // show all flexible items
2147 size_t i, count;
2148 for (i = 0, count = m_items.GetCount(); i < count; ++i)
2149 {
2150 wxAuiToolBarItem& item = m_items.Item(i);
2151 if (item.sizer_item && item.proportion > 0 && !item.sizer_item->IsShown())
2152 {
2153 item.sizer_item->Show(true);
2154 item.sizer_item->SetProportion(item.proportion);
2155 }
2156 }
2157 }
2158
2159 m_sizer->SetDimension(0, 0, x, y);
2160
2161 Refresh(false);
2162 Update();
2163}
2164
2165
2166
2167void wxAuiToolBar::DoSetSize(int x,
2168 int y,
2169 int width,
2170 int height,
2171 int sizeFlags)
2172{
2173 wxSize parent_size = GetParent()->GetClientSize();
2174 if (x + width > parent_size.x)
2175 width = wxMax(0, parent_size.x - x);
2176 if (y + height > parent_size.y)
2177 height = wxMax(0, parent_size.y - y);
2178
2179 wxWindow::DoSetSize(x, y, width, height, sizeFlags);
2180}
2181
2182
2183void wxAuiToolBar::OnIdle(wxIdleEvent& evt)
2184{
2185 DoIdleUpdate();
2186 evt.Skip();
2187}
2188
2189void wxAuiToolBar::OnPaint(wxPaintEvent& WXUNUSED(evt))
2190{
2191 wxAutoBufferedPaintDC dc(this);
2192 wxRect cli_rect(wxPoint(0,0), GetClientSize());
2193
2194
2195 bool horizontal = true;
2196 if (m_style & wxAUI_TB_VERTICAL)
2197 horizontal = false;
2198
2199
2200 m_art->DrawBackground(dc, this, cli_rect);
2201
2202 int gripper_size = m_art->GetElementSize(wxAUI_TBART_GRIPPER_SIZE);
2203 int dropdown_size = m_art->GetElementSize(wxAUI_TBART_OVERFLOW_SIZE);
2204
2205 // paint the gripper
2206 if (gripper_size > 0 && m_gripper_sizer_item)
2207 {
2208 wxRect gripper_rect = m_gripper_sizer_item->GetRect();
2209 if (horizontal)
2210 gripper_rect.width = gripper_size;
2211 else
2212 gripper_rect.height = gripper_size;
2213 m_art->DrawGripper(dc, this, gripper_rect);
2214 }
2215
2216 // calculated how far we can draw items
2217 int last_extent;
2218 if (horizontal)
2219 last_extent = cli_rect.width;
2220 else
2221 last_extent = cli_rect.height;
2222 if (m_overflow_visible)
2223 last_extent -= dropdown_size;
2224
2225 // paint each individual tool
2226 size_t i, count = m_items.GetCount();
2227 for (i = 0; i < count; ++i)
2228 {
2229 wxAuiToolBarItem& item = m_items.Item(i);
2230
2231 if (!item.sizer_item)
2232 continue;
2233
2234 wxRect item_rect = item.sizer_item->GetRect();
2235
2236
2237 if ((horizontal && item_rect.x + item_rect.width >= last_extent) ||
2238 (!horizontal && item_rect.y + item_rect.height >= last_extent))
2239 {
2240 break;
2241 }
2242
2243 if (item.kind == wxITEM_SEPARATOR)
2244 {
2245 // draw a separator
2246 m_art->DrawSeparator(dc, this, item_rect);
2247 }
2248 else if (item.kind == wxITEM_LABEL)
2249 {
2250 // draw a text label only
2251 m_art->DrawLabel(dc, this, item, item_rect);
2252 }
2253 else if (item.kind == wxITEM_NORMAL)
2254 {
2255 // draw a regular button or dropdown button
2256 if (!item.dropdown)
2257 m_art->DrawButton(dc, this, item, item_rect);
2258 else
2259 m_art->DrawDropDownButton(dc, this, item, item_rect);
2260 }
2261 else if (item.kind == wxITEM_CHECK)
2262 {
2263 // draw a toggle button
2264 m_art->DrawButton(dc, this, item, item_rect);
2265 }
2266 else if (item.kind == wxITEM_RADIO)
2267 {
2268 // draw a toggle button
2269 m_art->DrawButton(dc, this, item, item_rect);
2270 }
2271 else if (item.kind == wxITEM_CONTROL)
2272 {
2273 // draw the control's label
2274 m_art->DrawControlLabel(dc, this, item, item_rect);
2275 }
2276
2277 // fire a signal to see if the item wants to be custom-rendered
2278 OnCustomRender(dc, item, item_rect);
2279 }
2280
2281 // paint the overflow button
2282 if (dropdown_size > 0 && m_overflow_sizer_item)
2283 {
2284 wxRect dropdown_rect = GetOverflowRect();
2285 m_art->DrawOverflowButton(dc, this, dropdown_rect, m_overflow_state);
2286 }
2287}
2288
2289void wxAuiToolBar::OnEraseBackground(wxEraseEvent& WXUNUSED(evt))
2290{
2291 // empty
2292}
2293
2294void wxAuiToolBar::OnLeftDown(wxMouseEvent& evt)
2295{
2296 wxRect cli_rect(wxPoint(0,0), GetClientSize());
2297
2298 if (m_gripper_sizer_item)
2299 {
2300 wxRect gripper_rect = m_gripper_sizer_item->GetRect();
2301 if (gripper_rect.Contains(evt.GetX(), evt.GetY()))
2302 {
2303 // find aui manager
2304 wxAuiManager* manager = wxAuiManager::GetManager(this);
2305 if (!manager)
2306 return;
2307
2308 int x_drag_offset = evt.GetX() - gripper_rect.GetX();
2309 int y_drag_offset = evt.GetY() - gripper_rect.GetY();
2310
2311 // gripper was clicked
2312 manager->StartPaneDrag(this, wxPoint(x_drag_offset, y_drag_offset));
2313 return;
2314 }
2315 }
2316
2317 if (m_overflow_sizer_item)
2318 {
2319 wxRect overflow_rect = GetOverflowRect();
2320
2321 if (m_art &&
2322 m_overflow_visible &&
2323 overflow_rect.Contains(evt.m_x, evt.m_y))
2324 {
2325 wxAuiToolBarEvent e(wxEVT_COMMAND_AUITOOLBAR_OVERFLOW_CLICK, -1);
2326 e.SetEventObject(this);
2327 e.SetToolId(-1);
2328 e.SetClickPoint(wxPoint(evt.GetX(), evt.GetY()));
2329 bool processed = GetEventHandler()->ProcessEvent(e);
2330
2331 if (processed)
2332 {
2333 DoIdleUpdate();
2334 }
2335 else
2336 {
2337 size_t i, count;
2338 wxAuiToolBarItemArray overflow_items;
2339
2340
2341 // add custom overflow prepend items, if any
2342 count = m_custom_overflow_prepend.GetCount();
2343 for (i = 0; i < count; ++i)
2344 overflow_items.Add(m_custom_overflow_prepend[i]);
2345
2346 // only show items that don't fit in the dropdown
2347 count = m_items.GetCount();
2348 for (i = 0; i < count; ++i)
2349 {
2350 if (!GetToolFitsByIndex(i))
2351 overflow_items.Add(m_items[i]);
2352 }
2353
2354 // add custom overflow append items, if any
2355 count = m_custom_overflow_append.GetCount();
2356 for (i = 0; i < count; ++i)
2357 overflow_items.Add(m_custom_overflow_append[i]);
2358
2359 int res = m_art->ShowDropDown(this, overflow_items);
2360 m_overflow_state = 0;
2361 Refresh(false);
2362 if (res != -1)
2363 {
2364 wxCommandEvent e(wxEVT_COMMAND_MENU_SELECTED, res);
2365 e.SetEventObject(this);
2366 GetParent()->GetEventHandler()->ProcessEvent(e);
2367 }
2368 }
2369
2370 return;
2371 }
2372 }
2373
2374 m_dragging = false;
2375 m_action_pos = wxPoint(evt.GetX(), evt.GetY());
2376 m_action_item = FindToolByPosition(evt.GetX(), evt.GetY());
2377
2378 if (m_action_item)
2379 {
2380 if (m_action_item->state & wxAUI_BUTTON_STATE_DISABLED)
2381 {
2382 m_action_pos = wxPoint(-1,-1);
2383 m_action_item = NULL;
2384 return;
2385 }
2386
2387 SetPressedItem(m_action_item);
2388
2389 // fire the tool dropdown event
2390 wxAuiToolBarEvent e(wxEVT_COMMAND_AUITOOLBAR_TOOL_DROPDOWN, m_action_item->id);
2391 e.SetEventObject(this);
2392 e.SetToolId(m_action_item->id);
2393 e.SetDropDownClicked(false);
2394
2395 int mouse_x = evt.GetX();
2396 wxRect rect = m_action_item->sizer_item->GetRect();
2397
2398 if (m_action_item->dropdown &&
2399 mouse_x >= (rect.x+rect.width-BUTTON_DROPDOWN_WIDTH-1) &&
2400 mouse_x < (rect.x+rect.width))
2401 {
2402 e.SetDropDownClicked(true);
2403 }
2404
2405 e.SetClickPoint(evt.GetPosition());
2406 e.SetItemRect(rect);
2407 GetEventHandler()->ProcessEvent(e);
2408 DoIdleUpdate();
2409 }
2410}
2411
2412void wxAuiToolBar::OnLeftUp(wxMouseEvent& evt)
2413{
2414 SetPressedItem(NULL);
2415
2416 wxAuiToolBarItem* hit_item = FindToolByPosition(evt.GetX(), evt.GetY());
2417 if (hit_item && !(hit_item->state & wxAUI_BUTTON_STATE_DISABLED))
2418 {
2419 SetHoverItem(hit_item);
2420 }
2421
2422
2423 if (m_dragging)
2424 {
2425 // reset drag and drop member variables
2426 m_dragging = false;
2427 m_action_pos = wxPoint(-1,-1);
2428 m_action_item = NULL;
2429 return;
2430 }
2431 else
2432 {
2433 wxAuiToolBarItem* hit_item;
2434 hit_item = FindToolByPosition(evt.GetX(), evt.GetY());
2435
2436 if (m_action_item && hit_item == m_action_item)
2437 {
2438 UnsetToolTip();
2439
2440 if (hit_item->kind == wxITEM_CHECK || hit_item->kind == wxITEM_RADIO)
2441 {
2442 bool toggle = false;
2443
2444 if (m_action_item->state & wxAUI_BUTTON_STATE_CHECKED)
2445 toggle = false;
2446 else
2447 toggle = true;
2448
2449 ToggleTool(m_action_item->id, toggle);
2450
2451 // repaint immediately
2452 Refresh(false);
2453 Update();
2454
2455 wxCommandEvent e(wxEVT_COMMAND_MENU_SELECTED, m_action_item->id);
2456 e.SetEventObject(this);
2457 e.SetInt (toggle);
2458 GetEventHandler()->ProcessEvent(e);
2459 DoIdleUpdate();
2460 }
2461 else
2462 {
2463 wxCommandEvent e(wxEVT_COMMAND_MENU_SELECTED, m_action_item->id);
2464 e.SetEventObject(this);
2465 GetEventHandler()->ProcessEvent(e);
2466 DoIdleUpdate();
2467 }
2468 }
2469 }
2470
2471 // reset drag and drop member variables
2472 m_dragging = false;
2473 m_action_pos = wxPoint(-1,-1);
2474 m_action_item = NULL;
2475}
2476
2477void wxAuiToolBar::OnRightDown(wxMouseEvent& evt)
2478{
2479 wxRect cli_rect(wxPoint(0,0), GetClientSize());
2480
2481 if (m_gripper_sizer_item)
2482 {
2483 wxRect gripper_rect = m_gripper_sizer_item->GetRect();
2484 if (gripper_rect.Contains(evt.GetX(), evt.GetY()))
2485 return;
2486 }
2487
2488 if (m_overflow_sizer_item)
2489 {
2490 int dropdown_size = m_art->GetElementSize(wxAUI_TBART_OVERFLOW_SIZE);
2491 if (dropdown_size > 0 &&
2492 evt.m_x > cli_rect.width - dropdown_size &&
2493 evt.m_y >= 0 &&
2494 evt.m_y < cli_rect.height &&
2495 m_art)
2496 {
2497 return;
2498 }
2499 }
2500
2501 m_action_pos = wxPoint(evt.GetX(), evt.GetY());
2502 m_action_item = FindToolByPosition(evt.GetX(), evt.GetY());
2503
2504 if (m_action_item)
2505 {
2506 if (m_action_item->state & wxAUI_BUTTON_STATE_DISABLED)
2507 {
2508 m_action_pos = wxPoint(-1,-1);
2509 m_action_item = NULL;
2510 return;
2511 }
2512 }
2513}
2514
2515void wxAuiToolBar::OnRightUp(wxMouseEvent& evt)
2516{
2517 wxAuiToolBarItem* hit_item;
2518 hit_item = FindToolByPosition(evt.GetX(), evt.GetY());
2519
2520 if (m_action_item && hit_item == m_action_item)
2521 {
2522 if (hit_item->kind == wxITEM_NORMAL)
2523 {
2524 wxAuiToolBarEvent e(wxEVT_COMMAND_AUITOOLBAR_RIGHT_CLICK, m_action_item->id);
2525 e.SetEventObject(this);
2526 e.SetToolId(m_action_item->id);
2527 e.SetClickPoint(m_action_pos);
2528 GetEventHandler()->ProcessEvent(e);
2529 DoIdleUpdate();
2530 }
2531 }
2532 else
2533 {
2534 // right-clicked on the invalid area of the toolbar
2535 wxAuiToolBarEvent e(wxEVT_COMMAND_AUITOOLBAR_RIGHT_CLICK, -1);
2536 e.SetEventObject(this);
2537 e.SetToolId(-1);
2538 e.SetClickPoint(m_action_pos);
2539 GetEventHandler()->ProcessEvent(e);
2540 DoIdleUpdate();
2541 }
2542
2543 // reset member variables
2544 m_action_pos = wxPoint(-1,-1);
2545 m_action_item = NULL;
2546}
2547
2548void wxAuiToolBar::OnMiddleDown(wxMouseEvent& evt)
2549{
2550 wxRect cli_rect(wxPoint(0,0), GetClientSize());
2551
2552 if (m_gripper_sizer_item)
2553 {
2554 wxRect gripper_rect = m_gripper_sizer_item->GetRect();
2555 if (gripper_rect.Contains(evt.GetX(), evt.GetY()))
2556 return;
2557 }
2558
2559 if (m_overflow_sizer_item)
2560 {
2561 int dropdown_size = m_art->GetElementSize(wxAUI_TBART_OVERFLOW_SIZE);
2562 if (dropdown_size > 0 &&
2563 evt.m_x > cli_rect.width - dropdown_size &&
2564 evt.m_y >= 0 &&
2565 evt.m_y < cli_rect.height &&
2566 m_art)
2567 {
2568 return;
2569 }
2570 }
2571
2572 m_action_pos = wxPoint(evt.GetX(), evt.GetY());
2573 m_action_item = FindToolByPosition(evt.GetX(), evt.GetY());
2574
2575 if (m_action_item)
2576 {
2577 if (m_action_item->state & wxAUI_BUTTON_STATE_DISABLED)
2578 {
2579 m_action_pos = wxPoint(-1,-1);
2580 m_action_item = NULL;
2581 return;
2582 }
2583 }
2584}
2585
2586void wxAuiToolBar::OnMiddleUp(wxMouseEvent& evt)
2587{
2588 wxAuiToolBarItem* hit_item;
2589 hit_item = FindToolByPosition(evt.GetX(), evt.GetY());
2590
2591 if (m_action_item && hit_item == m_action_item)
2592 {
2593 if (hit_item->kind == wxITEM_NORMAL)
2594 {
2595 wxAuiToolBarEvent e(wxEVT_COMMAND_AUITOOLBAR_MIDDLE_CLICK, m_action_item->id);
2596 e.SetEventObject(this);
2597 e.SetToolId(m_action_item->id);
2598 e.SetClickPoint(m_action_pos);
2599 GetEventHandler()->ProcessEvent(e);
2600 DoIdleUpdate();
2601 }
2602 }
2603
2604 // reset member variables
2605 m_action_pos = wxPoint(-1,-1);
2606 m_action_item = NULL;
2607}
2608
2609void wxAuiToolBar::OnMotion(wxMouseEvent& evt)
2610{
2611 // start a drag event
2612 if (!m_dragging &&
2613 m_action_item != NULL &&
2614 m_action_pos != wxPoint(-1,-1) &&
2615 abs(evt.m_x - m_action_pos.x) + abs(evt.m_y - m_action_pos.y) > 5)
2616 {
2617 UnsetToolTip();
2618
2619 m_dragging = true;
2620
2621 wxAuiToolBarEvent e(wxEVT_COMMAND_AUITOOLBAR_BEGIN_DRAG, GetId());
2622 e.SetEventObject(this);
2623 e.SetToolId(m_action_item->id);
2624 GetEventHandler()->ProcessEvent(e);
2625 DoIdleUpdate();
2626 return;
2627 }
2628
2629 wxAuiToolBarItem* hit_item = FindToolByPosition(evt.GetX(), evt.GetY());
2630 if (hit_item)
2631 {
2632 if (!(hit_item->state & wxAUI_BUTTON_STATE_DISABLED))
2633 SetHoverItem(hit_item);
2634 else
2635 SetHoverItem(NULL);
2636 }
2637 else
2638 {
2639 // no hit item, remove any hit item
2640 SetHoverItem(hit_item);
2641 }
2642
2643 // figure out tooltips
2644 wxAuiToolBarItem* packing_hit_item;
2645 packing_hit_item = FindToolByPositionWithPacking(evt.GetX(), evt.GetY());
2646 if (packing_hit_item)
2647 {
2648 if (packing_hit_item != m_tip_item)
2649 {
2650 m_tip_item = packing_hit_item;
2651
2652 if ( !packing_hit_item->short_help.empty() )
2653 SetToolTip(packing_hit_item->short_help);
2654 else
2655 UnsetToolTip();
2656 }
2657 }
2658 else
2659 {
2660 UnsetToolTip();
2661 m_tip_item = NULL;
2662 }
2663
2664 // if we've pressed down an item and we're hovering
2665 // over it, make sure it's state is set to pressed
2666 if (m_action_item)
2667 {
2668 if (m_action_item == hit_item)
2669 SetPressedItem(m_action_item);
2670 else
2671 SetPressedItem(NULL);
2672 }
2673
2674 // figure out the dropdown button state (are we hovering or pressing it?)
2675 RefreshOverflowState();
2676}
2677
2678void wxAuiToolBar::OnLeaveWindow(wxMouseEvent& WXUNUSED(evt))
2679{
2680 RefreshOverflowState();
2681 SetHoverItem(NULL);
2682 SetPressedItem(NULL);
2683
2684 m_tip_item = NULL;
2685}
2686
2687
2688void wxAuiToolBar::OnSetCursor(wxSetCursorEvent& evt)
2689{
2690 wxCursor cursor = wxNullCursor;
2691
2692 if (m_gripper_sizer_item)
2693 {
2694 wxRect gripper_rect = m_gripper_sizer_item->GetRect();
2695 if (gripper_rect.Contains(evt.GetX(), evt.GetY()))
2696 {
2697 cursor = wxCursor(wxCURSOR_SIZING);
2698 }
2699 }
2700
2701 evt.SetCursor(cursor);
2702}
2703
2704
2705#endif // wxUSE_AUI
2706
wxWidgets (Impactor)