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