src/aui/auibar.cpp

   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"
  46 WX_DEFINE_OBJARRAY(wxAuiToolBarItemArray)
  47
  48
  49 wxDEFINE_EVENT( wxEVT_COMMAND_AUITOOLBAR_TOOL_DROPDOWN, wxAuiToolBarEvent );
  50 wxDEFINE_EVENT( wxEVT_COMMAND_AUITOOLBAR_OVERFLOW_CLICK, wxAuiToolBarEvent );
  51 wxDEFINE_EVENT( wxEVT_COMMAND_AUITOOLBAR_RIGHT_CLICK, wxAuiToolBarEvent );
  52 wxDEFINE_EVENT( wxEVT_COMMAND_AUITOOLBAR_MIDDLE_CLICK, wxAuiToolBarEvent );
  53 wxDEFINE_EVENT( wxEVT_COMMAND_AUITOOLBAR_BEGIN_DRAG, wxAuiToolBarEvent );
  54
  55
  56 IMPLEMENT_CLASS(wxAuiToolBar, wxControl)
  57 IMPLEMENT_DYNAMIC_CLASS(wxAuiToolBarEvent, wxEvent)
  58
  59
  60 // missing wxITEM_* items
  61 enum
  62 {
  63     wxITEM_CONTROL = wxITEM_MAX,
  64     wxITEM_LABEL,
  65     wxITEM_SPACER
  66 };
  67
  68 const int BUTTON_DROPDOWN_WIDTH = 10;
  69
  70
  71 wxBitmap wxAuiBitmapFromBits(const unsigned char bits[], int w, int h,
  72                              const wxColour& color);
  73
  74 unsigned char wxAuiBlendColour(unsigned char fg, unsigned char bg, double alpha);
  75 wxColor wxAuiStepColour(const wxColor& c, int percent);
  76
  77 static 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
 112 static 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
 135 class ToolbarCommandCapture : public wxEvtHandler
 136 {
 137 public:
 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
 156 private:
 157     int m_last_id;
 158 };
 159
 160
 161
 162 static const unsigned char
 163     DISABLED_TEXT_GREY_HUE = wxAuiBlendColour(0, 255, 0.4);
 164 const wxColour DISABLED_TEXT_COLOR(DISABLED_TEXT_GREY_HUE,
 165                                    DISABLED_TEXT_GREY_HUE,
 166                                    DISABLED_TEXT_GREY_HUE);
 167
 168 wxAuiDefaultToolBarArt::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
 204 wxAuiDefaultToolBarArt::~wxAuiDefaultToolBarArt()
 205 {
 206     m_font = *wxNORMAL_FONT;
 207 }
 208
 209
 210 wxAuiToolBarArt* wxAuiDefaultToolBarArt::Clone()
 211 {
 212     return static_cast<wxAuiToolBarArt*>(new wxAuiDefaultToolBarArt);
 213 }
 214
 215 void wxAuiDefaultToolBarArt::SetFlags(unsigned int flags)
 216 {
 217     m_flags = flags;
 218 }
 219
 220 void wxAuiDefaultToolBarArt::SetFont(const wxFont& font)
 221 {
 222     m_font = font;
 223 }
 224
 225 void wxAuiDefaultToolBarArt::SetTextOrientation(int orientation)
 226 {
 227     m_text_orientation = orientation;
 228 }
 229
 230 void 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
 242 void 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
 269 void 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
 372 void 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
 487 void 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
 529 wxSize 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
 546 wxSize 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
 595 void 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
 628 void 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
 667 void 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
 701 int 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
 712 void 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
 722 int 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
 776 BEGIN_EVENT_TABLE(wxAuiToolBar, wxControl)
 777     EVT_SIZE(wxAuiToolBar::OnSize)
 778     EVT_IDLE(wxAuiToolBar::OnIdle)
 779     EVT_ERASE_BACKGROUND(wxAuiToolBar::OnEraseBackground)
 780     EVT_PAINT(wxAuiToolBar::OnPaint)
 781     EVT_LEFT_DOWN(wxAuiToolBar::OnLeftDown)
 782     EVT_LEFT_DCLICK(wxAuiToolBar::OnLeftDown)
 783     EVT_LEFT_UP(wxAuiToolBar::OnLeftUp)
 784     EVT_RIGHT_DOWN(wxAuiToolBar::OnRightDown)
 785     EVT_RIGHT_DCLICK(wxAuiToolBar::OnRightDown)
 786     EVT_RIGHT_UP(wxAuiToolBar::OnRightUp)
 787     EVT_MIDDLE_DOWN(wxAuiToolBar::OnMiddleDown)
 788     EVT_MIDDLE_DCLICK(wxAuiToolBar::OnMiddleDown)
 789     EVT_MIDDLE_UP(wxAuiToolBar::OnMiddleUp)
 790     EVT_MOTION(wxAuiToolBar::OnMotion)
 791     EVT_LEAVE_WINDOW(wxAuiToolBar::OnLeaveWindow)
 792     EVT_SET_CURSOR(wxAuiToolBar::OnSetCursor)
 793 END_EVENT_TABLE()
 794
 795
 796 wxAuiToolBar::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
 834 wxAuiToolBar::~wxAuiToolBar()
 835 {
 836     delete m_art;
 837     delete m_sizer;
 838 }
 839
 840 void 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
 869 void 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
 882 wxAuiToolBarArt* wxAuiToolBar::GetArtProvider() const
 883 {
 884     return m_art;
 885 }
 886
 887
 888
 889
 890 wxAuiToolBarItem* 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
 907 wxAuiToolBarItem* 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
 950 wxAuiToolBarItem* 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
 974 wxAuiToolBarItem* 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
1003 wxAuiToolBarItem* 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
1025 wxAuiToolBarItem* 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
1048 wxAuiToolBarItem* 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
1071 void wxAuiToolBar::Clear()
1072 {
1073     m_items.Clear();
1074     m_sizer_element_count = 0;
1075 }
1076
1077 bool 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
1090 bool 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
1103 wxControl* wxAuiToolBar::FindControl(int id)
1104 {
1105     wxWindow* wnd = FindWindow(id);
1106     return (wxControl*)wnd;
1107 }
1108
1109 wxAuiToolBarItem* 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
1122 wxAuiToolBarItem* 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
1146 wxAuiToolBarItem* 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
1175 wxAuiToolBarItem* 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
1186 void wxAuiToolBar::SetToolBitmapSize(const wxSize& WXUNUSED(size))
1187 {
1188     // TODO: wxToolBar compatibility
1189 }
1190
1191 wxSize wxAuiToolBar::GetToolBitmapSize() const
1192 {
1193     // TODO: wxToolBar compatibility
1194     return wxSize(16,15);
1195 }
1196
1197 void 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
1206 int 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
1215 void wxAuiToolBar::SetToolSeparation(int separation)
1216 {
1217     if (m_art)
1218         m_art->SetElementSize(wxAUI_TBART_SEPARATOR_SIZE, separation);
1219 }
1220
1221 int 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
1230 void 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
1239 bool 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
1248 void 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
1267 bool 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
1279 void wxAuiToolBar::SetToolBorderPadding(int padding)
1280 {
1281     m_tool_border_padding = padding;
1282 }
1283
1284 int wxAuiToolBar::GetToolBorderPadding() const
1285 {
1286     return m_tool_border_padding;
1287 }
1288
1289 void 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
1299 int wxAuiToolBar::GetToolTextOrientation() const
1300 {
1301     return m_tool_text_orientation;
1302 }
1303
1304 void wxAuiToolBar::SetToolPacking(int packing)
1305 {
1306     m_tool_packing = packing;
1307 }
1308
1309 int wxAuiToolBar::GetToolPacking() const
1310 {
1311     return m_tool_packing;
1312 }
1313
1314
1315 void wxAuiToolBar::SetOrientation(int WXUNUSED(orientation))
1316 {
1317 }
1318
1319 void 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
1331 bool wxAuiToolBar::GetGripperVisible() const
1332 {
1333     return m_gripper_visible;
1334 }
1335
1336 void 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
1346 bool wxAuiToolBar::GetOverflowVisible() const
1347 {
1348     return m_overflow_visible;
1349 }
1350
1351 void wxAuiToolBar::SetOverflowVisible(bool visible)
1352 {
1353     m_overflow_visible = visible;
1354     if (visible)
1355         m_style |= wxAUI_TB_OVERFLOW;
1356     Refresh(false);
1357 }
1358
1359 bool 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
1372 void 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
1397 void 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
1423 void 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
1459 void 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
1499 bool 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
1514 void 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
1527 bool 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
1537 wxString 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
1547 void 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
1556 wxBitmap 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
1566 void 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
1575 wxString 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
1585 void 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
1594 wxString 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
1604 void 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
1613 void 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
1621 size_t wxAuiToolBar::GetToolCount() const
1622 {
1623     return m_items.size();
1624 }
1625
1626 int 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
1644 bool 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
1680 bool wxAuiToolBar::GetToolFits(int tool_id) const
1681 {
1682     return GetToolFitsByIndex(GetToolIndex(tool_id));
1683 }
1684
1685 wxRect 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
1696 bool 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
1708 bool 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
1959 int wxAuiToolBar::GetOverflowState() const
1960 {
1961     return m_overflow_state;
1962 }
1963
1964 wxRect 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
1988 wxSize 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
2007 void 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
2083 void 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
2131 void 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
2147 void wxAuiToolBar::OnIdle(wxIdleEvent& evt)
2148 {
2149     DoIdleUpdate();
2150     evt.Skip();
2151 }
2152
2153 void 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
2253 void wxAuiToolBar::OnEraseBackground(wxEraseEvent& WXUNUSED(evt))
2254 {
2255     // empty
2256 }
2257
2258 void 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
2376 void 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
2440 void 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
2478 void 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
2511 void 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
2549 void 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
2572 void 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
2641 void wxAuiToolBar::OnLeaveWindow(wxMouseEvent& WXUNUSED(evt))
2642 {
2643     RefreshOverflowState();
2644     SetHoverItem(NULL);
2645     SetPressedItem(NULL);
2646
2647     m_tip_item = NULL;
2648 }
2649
2650
2651 void 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