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