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 unsigned char wxAuiBlendColour(unsigned char fg, unsigned char bg, double alpha);
  73 wxColor wxAuiStepColour(const wxColor& c, int percent);
  74
  75 static wxBitmap MakeDisabledBitmap(wxBitmap& bmp)
  76 {
  77     wxImage image = bmp.ConvertToImage();
  78
  79     int mr, mg, mb;
  80     mr = image.GetMaskRed();
  81     mg = image.GetMaskGreen();
  82     mb = image.GetMaskBlue();
  83
  84     unsigned char* data = image.GetData();
  85     int width = image.GetWidth();
  86     int height = image.GetHeight();
  87     bool has_mask = image.HasMask();
  88
  89     for (int y = height-1; y >= 0; --y)
  90     {
  91         for (int x = width-1; x >= 0; --x)
  92         {
  93             data = image.GetData() + (y*(width*3))+(x*3);
  94             unsigned char* r = data;
  95             unsigned char* g = data+1;
  96             unsigned char* b = data+2;
  97
  98             if (has_mask && *r == mr && *g == mg && *b == mb)
  99                 continue;
 100
 101             *r = wxAuiBlendColour(*r, 255, 0.4);
 102             *g = wxAuiBlendColour(*g, 255, 0.4);
 103             *b = wxAuiBlendColour(*b, 255, 0.4);
 104         }
 105     }
 106
 107     return wxBitmap(image);
 108 }
 109
 110 static wxColor GetBaseColor()
 111 {
 112
 113 #if defined( __WXMAC__ ) && wxOSX_USE_COCOA_OR_CARBON
 114     wxColor base_colour = wxColour( wxMacCreateCGColorFromHITheme(kThemeBrushToolbarBackground));
 115 #else
 116     wxColor base_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
 117 #endif
 118
 119     // the base_colour is too pale to use as our base colour,
 120     // so darken it a bit --
 121     if ((255-base_colour.Red()) +
 122         (255-base_colour.Green()) +
 123         (255-base_colour.Blue()) < 60)
 124     {
 125         base_colour = wxAuiStepColour(base_colour, 92);
 126     }
 127
 128     return base_colour;
 129 }
 130
 131
 132
 133 class ToolbarCommandCapture : public wxEvtHandler
 134 {
 135 public:
 136
 137     ToolbarCommandCapture() { m_last_id = 0; }
 138     int GetCommandId() const { return m_last_id; }
 139
 140     bool ProcessEvent(wxEvent& evt)
 141     {
 142         if (evt.GetEventType() == wxEVT_COMMAND_MENU_SELECTED)
 143         {
 144             m_last_id = evt.GetId();
 145             return true;
 146         }
 147
 148         if (GetNextHandler())
 149             return GetNextHandler()->ProcessEvent(evt);
 150
 151         return false;
 152     }
 153
 154 private:
 155     int m_last_id;
 156 };
 157
 158
 159
 160 static const unsigned char
 161     DISABLED_TEXT_GREY_HUE = wxAuiBlendColour(0, 255, 0.4);
 162 const wxColour DISABLED_TEXT_COLOR(DISABLED_TEXT_GREY_HUE,
 163                                    DISABLED_TEXT_GREY_HUE,
 164                                    DISABLED_TEXT_GREY_HUE);
 165
 166 wxAuiDefaultToolBarArt::wxAuiDefaultToolBarArt()
 167 {
 168     m_base_colour = GetBaseColor();
 169
 170     m_flags = 0;
 171     m_text_orientation = wxAUI_TBTOOL_TEXT_BOTTOM;
 172     m_highlight_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
 173
 174     m_separator_size = 7;
 175     m_gripper_size = 7;
 176     m_overflow_size = 16;
 177
 178     wxColor darker1_colour = wxAuiStepColour(m_base_colour, 85);
 179     wxColor darker2_colour = wxAuiStepColour(m_base_colour, 75);
 180     wxColor darker3_colour = wxAuiStepColour(m_base_colour, 60);
 181     wxColor darker4_colour = wxAuiStepColour(m_base_colour, 50);
 182     wxColor darker5_colour = wxAuiStepColour(m_base_colour, 40);
 183
 184     m_gripper_pen1 = wxPen(darker5_colour);
 185     m_gripper_pen2 = wxPen(darker3_colour);
 186     m_gripper_pen3 = *wxWHITE_PEN;
 187
 188     static const unsigned char button_dropdown_bits[] = { 0xe0, 0xf1, 0xfb };
 189     static const unsigned char overflow_bits[] = { 0x80, 0xff, 0x80, 0xc1, 0xe3, 0xf7 };
 190
 191     m_button_dropdown_bmp = wxAuiBitmapFromBits(button_dropdown_bits, 5, 3,
 192                                                 *wxBLACK);
 193     m_disabled_button_dropdown_bmp = wxAuiBitmapFromBits(
 194                                                 button_dropdown_bits, 5, 3,
 195                                                 wxColor(128,128,128));
 196     m_overflow_bmp = wxAuiBitmapFromBits(overflow_bits, 7, 6, *wxBLACK);
 197     m_disabled_overflow_bmp = wxAuiBitmapFromBits(overflow_bits, 7, 6, wxColor(128,128,128));
 198
 199     m_font = *wxNORMAL_FONT;
 200 }
 201
 202 wxAuiDefaultToolBarArt::~wxAuiDefaultToolBarArt()
 203 {
 204     m_font = *wxNORMAL_FONT;
 205 }
 206
 207
 208 wxAuiToolBarArt* wxAuiDefaultToolBarArt::Clone()
 209 {
 210     return static_cast<wxAuiToolBarArt*>(new wxAuiDefaultToolBarArt);
 211 }
 212
 213 void wxAuiDefaultToolBarArt::SetFlags(unsigned int flags)
 214 {
 215     m_flags = flags;
 216 }
 217
 218 void wxAuiDefaultToolBarArt::SetFont(const wxFont& font)
 219 {
 220     m_font = font;
 221 }
 222
 223 void wxAuiDefaultToolBarArt::SetTextOrientation(int orientation)
 224 {
 225     m_text_orientation = orientation;
 226 }
 227
 228 unsigned int wxAuiDefaultToolBarArt::GetFlags()
 229 {
 230     return m_flags;
 231 }
 232
 233 wxFont wxAuiDefaultToolBarArt::GetFont()
 234 {
 235     return m_font;
 236 }
 237
 238 int wxAuiDefaultToolBarArt::GetTextOrientation()
 239 {
 240     return m_text_orientation;
 241 }
 242
 243 void wxAuiDefaultToolBarArt::DrawBackground(
 244                                     wxDC& dc,
 245                                     wxWindow* WXUNUSED(wnd),
 246                                     const wxRect& _rect)
 247 {
 248     wxRect rect = _rect;
 249     rect.height++;
 250     wxColour start_colour = wxAuiStepColour(m_base_colour, 150);
 251     wxColour end_colour = wxAuiStepColour(m_base_colour, 90);
 252     dc.GradientFillLinear(rect, start_colour, end_colour, wxSOUTH);
 253 }
 254
 255 void wxAuiDefaultToolBarArt::DrawLabel(
 256                                     wxDC& dc,
 257                                     wxWindow* WXUNUSED(wnd),
 258                                     const wxAuiToolBarItem& item,
 259                                     const wxRect& rect)
 260 {
 261     dc.SetFont(m_font);
 262     dc.SetTextForeground(*wxBLACK);
 263
 264     // we only care about the text height here since the text
 265     // will get cropped based on the width of the item
 266     int text_width = 0, text_height = 0;
 267     dc.GetTextExtent(wxT("ABCDHgj"), &text_width, &text_height);
 268
 269     // set the clipping region
 270     wxRect clip_rect = rect;
 271     clip_rect.width -= 1;
 272     dc.SetClippingRegion(clip_rect);
 273
 274     int text_x, text_y;
 275     text_x = rect.x + 1;
 276     text_y = rect.y + (rect.height-text_height)/2;
 277     dc.DrawText(item.GetLabel(), text_x, text_y);
 278     dc.DestroyClippingRegion();
 279 }
 280
 281
 282 void wxAuiDefaultToolBarArt::DrawButton(
 283                                     wxDC& dc,
 284                                     wxWindow* WXUNUSED(wnd),
 285                                     const wxAuiToolBarItem& item,
 286                                     const wxRect& rect)
 287 {
 288     int text_width = 0, text_height = 0;
 289
 290     if (m_flags & wxAUI_TB_TEXT)
 291     {
 292         dc.SetFont(m_font);
 293
 294         int tx, ty;
 295
 296         dc.GetTextExtent(wxT("ABCDHgj"), &tx, &text_height);
 297         text_width = 0;
 298         dc.GetTextExtent(item.GetLabel(), &text_width, &ty);
 299     }
 300
 301     int bmp_x = 0, bmp_y = 0;
 302     int text_x = 0, text_y = 0;
 303
 304     if (m_text_orientation == wxAUI_TBTOOL_TEXT_BOTTOM)
 305     {
 306         bmp_x = rect.x +
 307                 (rect.width/2) -
 308                 (item.GetBitmap().GetWidth()/2);
 309
 310         bmp_y = rect.y +
 311                 ((rect.height-text_height)/2) -
 312                 (item.GetBitmap().GetHeight()/2);
 313
 314         text_x = rect.x + (rect.width/2) - (text_width/2) + 1;
 315         text_y = rect.y + rect.height - text_height - 1;
 316     }
 317     else if (m_text_orientation == wxAUI_TBTOOL_TEXT_RIGHT)
 318     {
 319         bmp_x = rect.x + 3;
 320
 321         bmp_y = rect.y +
 322                 (rect.height/2) -
 323                 (item.GetBitmap().GetHeight()/2);
 324
 325         text_x = bmp_x + 3 + item.GetBitmap().GetWidth();
 326         text_y = rect.y +
 327                  (rect.height/2) -
 328                  (text_height/2);
 329     }
 330
 331
 332     if (!(item.GetState() & wxAUI_BUTTON_STATE_DISABLED))
 333     {
 334         if (item.GetState() & wxAUI_BUTTON_STATE_PRESSED)
 335         {
 336             dc.SetPen(wxPen(m_highlight_colour));
 337             dc.SetBrush(wxBrush(wxAuiStepColour(m_highlight_colour, 150)));
 338             dc.DrawRectangle(rect);
 339         }
 340         else if ((item.GetState() & wxAUI_BUTTON_STATE_HOVER) || item.IsSticky())
 341         {
 342             dc.SetPen(wxPen(m_highlight_colour));
 343             dc.SetBrush(wxBrush(wxAuiStepColour(m_highlight_colour, 170)));
 344
 345             // draw an even lighter background for checked item hovers (since
 346             // the hover background is the same color as the check background)
 347             if (item.GetState() & wxAUI_BUTTON_STATE_CHECKED)
 348                 dc.SetBrush(wxBrush(wxAuiStepColour(m_highlight_colour, 180)));
 349
 350             dc.DrawRectangle(rect);
 351         }
 352         else if (item.GetState() & wxAUI_BUTTON_STATE_CHECKED)
 353         {
 354             // it's important to put this code in an else statment after the
 355             // hover, otherwise hovers won't draw properly for checked items
 356             dc.SetPen(wxPen(m_highlight_colour));
 357             dc.SetBrush(wxBrush(wxAuiStepColour(m_highlight_colour, 170)));
 358             dc.DrawRectangle(rect);
 359         }
 360     }
 361
 362     wxBitmap bmp;
 363     if (item.GetState() & wxAUI_BUTTON_STATE_DISABLED)
 364         bmp = item.GetDisabledBitmap();
 365     else
 366         bmp = item.GetBitmap();
 367
 368     if (!bmp.IsOk())
 369         return;
 370
 371     dc.DrawBitmap(bmp, bmp_x, bmp_y, true);
 372
 373     // set the item's text color based on if it is disabled
 374     dc.SetTextForeground(*wxBLACK);
 375     if (item.GetState() & wxAUI_BUTTON_STATE_DISABLED)
 376         dc.SetTextForeground(DISABLED_TEXT_COLOR);
 377
 378     if ( (m_flags & wxAUI_TB_TEXT) && !item.GetLabel().empty() )
 379     {
 380         dc.DrawText(item.GetLabel(), text_x, text_y);
 381     }
 382 }
 383
 384
 385 void wxAuiDefaultToolBarArt::DrawDropDownButton(
 386                                     wxDC& dc,
 387                                     wxWindow* WXUNUSED(wnd),
 388                                     const wxAuiToolBarItem& item,
 389                                     const wxRect& rect)
 390 {
 391     int text_width = 0, text_height = 0, text_x = 0, text_y = 0;
 392     int bmp_x = 0, bmp_y = 0, dropbmp_x = 0, dropbmp_y = 0;
 393
 394     wxRect button_rect = wxRect(rect.x,
 395                                 rect.y,
 396                                 rect.width-BUTTON_DROPDOWN_WIDTH,
 397                                 rect.height);
 398     wxRect dropdown_rect = wxRect(rect.x+rect.width-BUTTON_DROPDOWN_WIDTH-1,
 399                                   rect.y,
 400                                   BUTTON_DROPDOWN_WIDTH+1,
 401                                   rect.height);
 402
 403     if (m_flags & wxAUI_TB_TEXT)
 404     {
 405         dc.SetFont(m_font);
 406
 407         int tx, ty;
 408         if (m_flags & wxAUI_TB_TEXT)
 409         {
 410             dc.GetTextExtent(wxT("ABCDHgj"), &tx, &text_height);
 411             text_width = 0;
 412         }
 413
 414         dc.GetTextExtent(item.GetLabel(), &text_width, &ty);
 415     }
 416
 417
 418
 419     dropbmp_x = dropdown_rect.x +
 420                 (dropdown_rect.width/2) -
 421                 (m_button_dropdown_bmp.GetWidth()/2);
 422     dropbmp_y = dropdown_rect.y +
 423                 (dropdown_rect.height/2) -
 424                 (m_button_dropdown_bmp.GetHeight()/2);
 425
 426
 427     if (m_text_orientation == wxAUI_TBTOOL_TEXT_BOTTOM)
 428     {
 429         bmp_x = button_rect.x +
 430                 (button_rect.width/2) -
 431                 (item.GetBitmap().GetWidth()/2);
 432         bmp_y = button_rect.y +
 433                 ((button_rect.height-text_height)/2) -
 434                 (item.GetBitmap().GetHeight()/2);
 435
 436         text_x = rect.x + (rect.width/2) - (text_width/2) + 1;
 437         text_y = rect.y + rect.height - text_height - 1;
 438     }
 439     else if (m_text_orientation == wxAUI_TBTOOL_TEXT_RIGHT)
 440     {
 441         bmp_x = rect.x + 3;
 442
 443         bmp_y = rect.y +
 444                 (rect.height/2) -
 445                 (item.GetBitmap().GetHeight()/2);
 446
 447         text_x = bmp_x + 3 + item.GetBitmap().GetWidth();
 448         text_y = rect.y +
 449                  (rect.height/2) -
 450                  (text_height/2);
 451     }
 452
 453
 454     if (item.GetState() & wxAUI_BUTTON_STATE_PRESSED)
 455     {
 456         dc.SetPen(wxPen(m_highlight_colour));
 457         dc.SetBrush(wxBrush(wxAuiStepColour(m_highlight_colour, 140)));
 458         dc.DrawRectangle(button_rect);
 459         dc.DrawRectangle(dropdown_rect);
 460     }
 461     else if (item.GetState() & wxAUI_BUTTON_STATE_HOVER ||
 462              item.IsSticky())
 463     {
 464         dc.SetPen(wxPen(m_highlight_colour));
 465         dc.SetBrush(wxBrush(wxAuiStepColour(m_highlight_colour, 170)));
 466         dc.DrawRectangle(button_rect);
 467         dc.DrawRectangle(dropdown_rect);
 468     }
 469
 470     wxBitmap bmp;
 471     wxBitmap dropbmp;
 472     if (item.GetState() & wxAUI_BUTTON_STATE_DISABLED)
 473     {
 474         bmp = item.GetDisabledBitmap();
 475         dropbmp = m_disabled_button_dropdown_bmp;
 476     }
 477     else
 478     {
 479         bmp = item.GetBitmap();
 480         dropbmp = m_button_dropdown_bmp;
 481     }
 482
 483     if (!bmp.IsOk())
 484         return;
 485
 486     dc.DrawBitmap(bmp, bmp_x, bmp_y, true);
 487     dc.DrawBitmap(dropbmp, dropbmp_x, dropbmp_y, true);
 488
 489     // set the item's text color based on if it is disabled
 490     dc.SetTextForeground(*wxBLACK);
 491     if (item.GetState() & wxAUI_BUTTON_STATE_DISABLED)
 492         dc.SetTextForeground(DISABLED_TEXT_COLOR);
 493
 494     if ( (m_flags & wxAUI_TB_TEXT) && !item.GetLabel().empty() )
 495     {
 496         dc.DrawText(item.GetLabel(), text_x, text_y);
 497     }
 498 }
 499
 500 void wxAuiDefaultToolBarArt::DrawControlLabel(
 501                                     wxDC& dc,
 502                                     wxWindow* WXUNUSED(wnd),
 503                                     const wxAuiToolBarItem& item,
 504                                     const wxRect& rect)
 505 {
 506     if (!(m_flags & wxAUI_TB_TEXT))
 507         return;
 508
 509     if (m_text_orientation != wxAUI_TBTOOL_TEXT_BOTTOM)
 510         return;
 511
 512     int text_x = 0, text_y = 0;
 513     int text_width = 0, text_height = 0;
 514
 515     dc.SetFont(m_font);
 516
 517     int tx, ty;
 518     if (m_flags & wxAUI_TB_TEXT)
 519     {
 520         dc.GetTextExtent(wxT("ABCDHgj"), &tx, &text_height);
 521         text_width = 0;
 522     }
 523
 524     dc.GetTextExtent(item.GetLabel(), &text_width, &ty);
 525
 526     // don't draw the label if it is wider than the item width
 527     if (text_width > rect.width)
 528         return;
 529
 530     // set the label's text color
 531     dc.SetTextForeground(*wxBLACK);
 532
 533     text_x = rect.x + (rect.width/2) - (text_width/2) + 1;
 534     text_y = rect.y + rect.height - text_height - 1;
 535
 536     if ( (m_flags & wxAUI_TB_TEXT) && !item.GetLabel().empty() )
 537     {
 538         dc.DrawText(item.GetLabel(), text_x, text_y);
 539     }
 540 }
 541
 542 wxSize wxAuiDefaultToolBarArt::GetLabelSize(
 543                                         wxDC& dc,
 544                                         wxWindow* WXUNUSED(wnd),
 545                                         const wxAuiToolBarItem& item)
 546 {
 547     dc.SetFont(m_font);
 548
 549     // get label's height
 550     int width = 0, height = 0;
 551     dc.GetTextExtent(wxT("ABCDHgj"), &width, &height);
 552
 553     // get item's width
 554     width = item.GetMinSize().GetWidth();
 555
 556     if (width == -1)
 557     {
 558         // no width specified, measure the text ourselves
 559         width = dc.GetTextExtent(item.GetLabel()).GetX();
 560     }
 561
 562     return wxSize(width, height);
 563 }
 564
 565 wxSize wxAuiDefaultToolBarArt::GetToolSize(
 566                                         wxDC& dc,
 567                                         wxWindow* WXUNUSED(wnd),
 568                                         const wxAuiToolBarItem& item)
 569 {
 570     if (!item.GetBitmap().IsOk() && !(m_flags & wxAUI_TB_TEXT))
 571         return wxSize(16,16);
 572
 573     int width = item.GetBitmap().GetWidth();
 574     int height = item.GetBitmap().GetHeight();
 575
 576     if (m_flags & wxAUI_TB_TEXT)
 577     {
 578         dc.SetFont(m_font);
 579         int tx, ty;
 580
 581         if (m_text_orientation == wxAUI_TBTOOL_TEXT_BOTTOM)
 582         {
 583             dc.GetTextExtent(wxT("ABCDHgj"), &tx, &ty);
 584             height += ty;
 585
 586             if ( !item.GetLabel().empty() )
 587             {
 588                 dc.GetTextExtent(item.GetLabel(), &tx, &ty);
 589                 width = wxMax(width, tx+6);
 590             }
 591         }
 592         else if ( m_text_orientation == wxAUI_TBTOOL_TEXT_RIGHT &&
 593                   !item.GetLabel().empty() )
 594         {
 595             width += 3; // space between left border and bitmap
 596             width += 3; // space between bitmap and text
 597
 598             if ( !item.GetLabel().empty() )
 599             {
 600                 dc.GetTextExtent(item.GetLabel(), &tx, &ty);
 601                 width += tx;
 602                 height = wxMax(height, ty);
 603             }
 604         }
 605     }
 606
 607     // if the tool has a dropdown button, add it to the width
 608     if (item.HasDropDown())
 609         width += (BUTTON_DROPDOWN_WIDTH+4);
 610
 611     return wxSize(width, height);
 612 }
 613
 614 void wxAuiDefaultToolBarArt::DrawSeparator(
 615                                     wxDC& dc,
 616                                     wxWindow* WXUNUSED(wnd),
 617                                     const wxRect& _rect)
 618 {
 619     bool horizontal = true;
 620     if (m_flags & wxAUI_TB_VERTICAL)
 621         horizontal = false;
 622
 623     wxRect rect = _rect;
 624
 625     if (horizontal)
 626     {
 627         rect.x += (rect.width/2);
 628         rect.width = 1;
 629         int new_height = (rect.height*3)/4;
 630         rect.y += (rect.height/2) - (new_height/2);
 631         rect.height = new_height;
 632     }
 633     else
 634     {
 635         rect.y += (rect.height/2);
 636         rect.height = 1;
 637         int new_width = (rect.width*3)/4;
 638         rect.x += (rect.width/2) - (new_width/2);
 639         rect.width = new_width;
 640     }
 641
 642     wxColour start_colour = wxAuiStepColour(m_base_colour, 80);
 643     wxColour end_colour = wxAuiStepColour(m_base_colour, 80);
 644     dc.GradientFillLinear(rect, start_colour, end_colour, horizontal ? wxSOUTH : wxEAST);
 645 }
 646
 647 void wxAuiDefaultToolBarArt::DrawGripper(wxDC& dc,
 648                                     wxWindow* WXUNUSED(wnd),
 649                                     const wxRect& rect)
 650 {
 651     int i = 0;
 652     while (1)
 653     {
 654         int x, y;
 655
 656         if (m_flags & wxAUI_TB_VERTICAL)
 657         {
 658             x = rect.x + (i*4) + 5;
 659             y = rect.y + 3;
 660             if (x > rect.GetWidth()-5)
 661                 break;
 662         }
 663         else
 664         {
 665             x = rect.x + 3;
 666             y = rect.y + (i*4) + 5;
 667             if (y > rect.GetHeight()-5)
 668                 break;
 669         }
 670
 671         dc.SetPen(m_gripper_pen1);
 672         dc.DrawPoint(x, y);
 673         dc.SetPen(m_gripper_pen2);
 674         dc.DrawPoint(x, y+1);
 675         dc.DrawPoint(x+1, y);
 676         dc.SetPen(m_gripper_pen3);
 677         dc.DrawPoint(x+2, y+1);
 678         dc.DrawPoint(x+2, y+2);
 679         dc.DrawPoint(x+1, y+2);
 680
 681         i++;
 682     }
 683
 684 }
 685
 686 void wxAuiDefaultToolBarArt::DrawOverflowButton(wxDC& dc,
 687                                           wxWindow* wnd,
 688                                           const wxRect& rect,
 689                                           int state)
 690 {
 691     if (state & wxAUI_BUTTON_STATE_HOVER ||
 692         state & wxAUI_BUTTON_STATE_PRESSED)
 693     {
 694         wxRect cli_rect = wnd->GetClientRect();
 695         wxColor light_gray_bg = wxAuiStepColour(m_highlight_colour, 170);
 696
 697         if (m_flags & wxAUI_TB_VERTICAL)
 698         {
 699             dc.SetPen(wxPen(m_highlight_colour));
 700             dc.DrawLine(rect.x, rect.y, rect.x+rect.width, rect.y);
 701             dc.SetPen(wxPen(light_gray_bg));
 702             dc.SetBrush(wxBrush(light_gray_bg));
 703             dc.DrawRectangle(rect.x, rect.y+1, rect.width, rect.height);
 704         }
 705         else
 706         {
 707             dc.SetPen(wxPen(m_highlight_colour));
 708             dc.DrawLine(rect.x, rect.y, rect.x, rect.y+rect.height);
 709             dc.SetPen(wxPen(light_gray_bg));
 710             dc.SetBrush(wxBrush(light_gray_bg));
 711             dc.DrawRectangle(rect.x+1, rect.y, rect.width, rect.height);
 712         }
 713     }
 714
 715     int x = rect.x+1+(rect.width-m_overflow_bmp.GetWidth())/2;
 716     int y = rect.y+1+(rect.height-m_overflow_bmp.GetHeight())/2;
 717     dc.DrawBitmap(m_overflow_bmp, x, y, true);
 718 }
 719
 720 int wxAuiDefaultToolBarArt::GetElementSize(int element_id)
 721 {
 722     switch (element_id)
 723     {
 724         case wxAUI_TBART_SEPARATOR_SIZE: return m_separator_size;
 725         case wxAUI_TBART_GRIPPER_SIZE:   return m_gripper_size;
 726         case wxAUI_TBART_OVERFLOW_SIZE:  return m_overflow_size;
 727         default: return 0;
 728     }
 729 }
 730
 731 void wxAuiDefaultToolBarArt::SetElementSize(int element_id, int size)
 732 {
 733     switch (element_id)
 734     {
 735         case wxAUI_TBART_SEPARATOR_SIZE: m_separator_size = size; break;
 736         case wxAUI_TBART_GRIPPER_SIZE:   m_gripper_size = size; break;
 737         case wxAUI_TBART_OVERFLOW_SIZE:  m_overflow_size = size; break;
 738     }
 739 }
 740
 741 int wxAuiDefaultToolBarArt::ShowDropDown(wxWindow* wnd,
 742                                          const wxAuiToolBarItemArray& items)
 743 {
 744     wxMenu menuPopup;
 745
 746     size_t items_added = 0;
 747
 748     size_t i, count = items.GetCount();
 749     for (i = 0; i < count; ++i)
 750     {
 751         wxAuiToolBarItem& item = items.Item(i);
 752
 753         if (item.GetKind() == wxITEM_NORMAL)
 754         {
 755             wxString text = item.GetShortHelp();
 756             if (text.empty())
 757                 text = item.GetLabel();
 758
 759             if (text.empty())
 760                 text = wxT(" ");
 761
 762             wxMenuItem* m =  new wxMenuItem(&menuPopup, item.GetId(), text, item.GetShortHelp());
 763
 764             m->SetBitmap(item.GetBitmap());
 765             menuPopup.Append(m);
 766             items_added++;
 767         }
 768         else if (item.GetKind() == wxITEM_SEPARATOR)
 769         {
 770             if (items_added > 0)
 771                 menuPopup.AppendSeparator();
 772         }
 773     }
 774
 775     // find out where to put the popup menu of window items
 776     wxPoint pt = ::wxGetMousePosition();
 777     pt = wnd->ScreenToClient(pt);
 778
 779     // find out the screen coordinate at the bottom of the tab ctrl
 780     wxRect cli_rect = wnd->GetClientRect();
 781     pt.y = cli_rect.y + cli_rect.height;
 782
 783     ToolbarCommandCapture* cc = new ToolbarCommandCapture;
 784     wnd->PushEventHandler(cc);
 785     wnd->PopupMenu(&menuPopup, pt);
 786     int command = cc->GetCommandId();
 787     wnd->PopEventHandler(true);
 788
 789     return command;
 790 }
 791
 792
 793
 794
 795 static wxOrientation GetOrientation(long& style)
 796 {
 797     switch (style & wxAUI_ORIENTATION_MASK)
 798     {
 799         case wxAUI_TB_HORIZONTAL:
 800             return wxHORIZONTAL;
 801         case wxAUI_TB_VERTICAL:
 802             return wxVERTICAL;
 803         default:
 804             wxFAIL_MSG("toolbar cannot be locked in both horizontal and vertical orientations (maybe no lock was intended?)");
 805             // fall through
 806         case 0:
 807             return wxBOTH;
 808     }
 809 }
 810
 811 BEGIN_EVENT_TABLE(wxAuiToolBar, wxControl)
 812     EVT_SIZE(wxAuiToolBar::OnSize)
 813     EVT_IDLE(wxAuiToolBar::OnIdle)
 814     EVT_ERASE_BACKGROUND(wxAuiToolBar::OnEraseBackground)
 815     EVT_PAINT(wxAuiToolBar::OnPaint)
 816     EVT_LEFT_DOWN(wxAuiToolBar::OnLeftDown)
 817     EVT_LEFT_DCLICK(wxAuiToolBar::OnLeftDown)
 818     EVT_LEFT_UP(wxAuiToolBar::OnLeftUp)
 819     EVT_RIGHT_DOWN(wxAuiToolBar::OnRightDown)
 820     EVT_RIGHT_DCLICK(wxAuiToolBar::OnRightDown)
 821     EVT_RIGHT_UP(wxAuiToolBar::OnRightUp)
 822     EVT_MIDDLE_DOWN(wxAuiToolBar::OnMiddleDown)
 823     EVT_MIDDLE_DCLICK(wxAuiToolBar::OnMiddleDown)
 824     EVT_MIDDLE_UP(wxAuiToolBar::OnMiddleUp)
 825     EVT_MOTION(wxAuiToolBar::OnMotion)
 826     EVT_LEAVE_WINDOW(wxAuiToolBar::OnLeaveWindow)
 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         SetPressedItem(m_action_item);
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         e.SetDropDownClicked(false);
2580
2581         int mouse_x = evt.GetX();
2582         wxRect rect = m_action_item->sizer_item->GetRect();
2583
2584         if (m_action_item->dropdown &&
2585             mouse_x >= (rect.x+rect.width-BUTTON_DROPDOWN_WIDTH-1) &&
2586             mouse_x < (rect.x+rect.width))
2587         {
2588             e.SetDropDownClicked(true);
2589         }
2590
2591         e.SetClickPoint(evt.GetPosition());
2592         e.SetItemRect(rect);
2593         GetEventHandler()->ProcessEvent(e);
2594         DoIdleUpdate();
2595     }
2596 }
2597
2598 void wxAuiToolBar::OnLeftUp(wxMouseEvent& evt)
2599 {
2600     SetPressedItem(NULL);
2601
2602     wxAuiToolBarItem* hit_item = FindToolByPosition(evt.GetX(), evt.GetY());
2603     if (hit_item && !(hit_item->state & wxAUI_BUTTON_STATE_DISABLED))
2604     {
2605         SetHoverItem(hit_item);
2606     }
2607
2608
2609     if (m_dragging)
2610     {
2611         // reset drag and drop member variables
2612         m_dragging = false;
2613         m_action_pos = wxPoint(-1,-1);
2614         m_action_item = NULL;
2615         return;
2616     }
2617     else
2618     {
2619         wxAuiToolBarItem* hit_item;
2620         hit_item = FindToolByPosition(evt.GetX(), evt.GetY());
2621
2622         if (m_action_item && hit_item == m_action_item)
2623         {
2624             UnsetToolTip();
2625
2626             if (hit_item->kind == wxITEM_CHECK || hit_item->kind == wxITEM_RADIO)
2627             {
2628                 bool toggle = false;
2629
2630                 if (m_action_item->state & wxAUI_BUTTON_STATE_CHECKED)
2631                     toggle = false;
2632                 else
2633                     toggle = true;
2634
2635                 ToggleTool(m_action_item->id, toggle);
2636
2637                 // repaint immediately
2638                 Refresh(false);
2639                 Update();
2640
2641                 wxCommandEvent e(wxEVT_COMMAND_MENU_SELECTED, m_action_item->id);
2642                 e.SetEventObject(this);
2643                 e.SetInt (toggle);
2644                 GetEventHandler()->ProcessEvent(e);
2645                 DoIdleUpdate();
2646             }
2647             else
2648             {
2649                 wxCommandEvent e(wxEVT_COMMAND_MENU_SELECTED, m_action_item->id);
2650                 e.SetEventObject(this);
2651                 GetEventHandler()->ProcessEvent(e);
2652                 DoIdleUpdate();
2653             }
2654         }
2655     }
2656
2657     // reset drag and drop member variables
2658     m_dragging = false;
2659     m_action_pos = wxPoint(-1,-1);
2660     m_action_item = NULL;
2661 }
2662
2663 void wxAuiToolBar::OnRightDown(wxMouseEvent& evt)
2664 {
2665     wxRect cli_rect(wxPoint(0,0), GetClientSize());
2666
2667     if (m_gripper_sizer_item)
2668     {
2669         wxRect gripper_rect = m_gripper_sizer_item->GetRect();
2670         if (gripper_rect.Contains(evt.GetX(), evt.GetY()))
2671             return;
2672     }
2673
2674     if (m_overflow_sizer_item)
2675     {
2676         int dropdown_size = m_art->GetElementSize(wxAUI_TBART_OVERFLOW_SIZE);
2677         if (dropdown_size > 0 &&
2678             evt.m_x > cli_rect.width - dropdown_size &&
2679             evt.m_y >= 0 &&
2680             evt.m_y < cli_rect.height &&
2681             m_art)
2682         {
2683             return;
2684         }
2685     }
2686
2687     m_action_pos = wxPoint(evt.GetX(), evt.GetY());
2688     m_action_item = FindToolByPosition(evt.GetX(), evt.GetY());
2689
2690     if (m_action_item)
2691     {
2692         if (m_action_item->state & wxAUI_BUTTON_STATE_DISABLED)
2693         {
2694             m_action_pos = wxPoint(-1,-1);
2695             m_action_item = NULL;
2696             return;
2697         }
2698     }
2699 }
2700
2701 void wxAuiToolBar::OnRightUp(wxMouseEvent& evt)
2702 {
2703     wxAuiToolBarItem* hit_item;
2704     hit_item = FindToolByPosition(evt.GetX(), evt.GetY());
2705
2706     if (m_action_item && hit_item == m_action_item)
2707     {
2708         if (hit_item->kind == wxITEM_NORMAL)
2709         {
2710             wxAuiToolBarEvent e(wxEVT_COMMAND_AUITOOLBAR_RIGHT_CLICK, m_action_item->id);
2711             e.SetEventObject(this);
2712             e.SetToolId(m_action_item->id);
2713             e.SetClickPoint(m_action_pos);
2714             GetEventHandler()->ProcessEvent(e);
2715             DoIdleUpdate();
2716         }
2717     }
2718     else
2719     {
2720         // right-clicked on the invalid area of the toolbar
2721         wxAuiToolBarEvent e(wxEVT_COMMAND_AUITOOLBAR_RIGHT_CLICK, -1);
2722         e.SetEventObject(this);
2723         e.SetToolId(-1);
2724         e.SetClickPoint(m_action_pos);
2725         GetEventHandler()->ProcessEvent(e);
2726         DoIdleUpdate();
2727     }
2728
2729     // reset member variables
2730     m_action_pos = wxPoint(-1,-1);
2731     m_action_item = NULL;
2732 }
2733
2734 void wxAuiToolBar::OnMiddleDown(wxMouseEvent& evt)
2735 {
2736     wxRect cli_rect(wxPoint(0,0), GetClientSize());
2737
2738     if (m_gripper_sizer_item)
2739     {
2740         wxRect gripper_rect = m_gripper_sizer_item->GetRect();
2741         if (gripper_rect.Contains(evt.GetX(), evt.GetY()))
2742             return;
2743     }
2744
2745     if (m_overflow_sizer_item)
2746     {
2747         int dropdown_size = m_art->GetElementSize(wxAUI_TBART_OVERFLOW_SIZE);
2748         if (dropdown_size > 0 &&
2749             evt.m_x > cli_rect.width - dropdown_size &&
2750             evt.m_y >= 0 &&
2751             evt.m_y < cli_rect.height &&
2752             m_art)
2753         {
2754             return;
2755         }
2756     }
2757
2758     m_action_pos = wxPoint(evt.GetX(), evt.GetY());
2759     m_action_item = FindToolByPosition(evt.GetX(), evt.GetY());
2760
2761     if (m_action_item)
2762     {
2763         if (m_action_item->state & wxAUI_BUTTON_STATE_DISABLED)
2764         {
2765             m_action_pos = wxPoint(-1,-1);
2766             m_action_item = NULL;
2767             return;
2768         }
2769     }
2770 }
2771
2772 void wxAuiToolBar::OnMiddleUp(wxMouseEvent& evt)
2773 {
2774     wxAuiToolBarItem* hit_item;
2775     hit_item = FindToolByPosition(evt.GetX(), evt.GetY());
2776
2777     if (m_action_item && hit_item == m_action_item)
2778     {
2779         if (hit_item->kind == wxITEM_NORMAL)
2780         {
2781             wxAuiToolBarEvent e(wxEVT_COMMAND_AUITOOLBAR_MIDDLE_CLICK, m_action_item->id);
2782             e.SetEventObject(this);
2783             e.SetToolId(m_action_item->id);
2784             e.SetClickPoint(m_action_pos);
2785             GetEventHandler()->ProcessEvent(e);
2786             DoIdleUpdate();
2787         }
2788     }
2789
2790     // reset member variables
2791     m_action_pos = wxPoint(-1,-1);
2792     m_action_item = NULL;
2793 }
2794
2795 void wxAuiToolBar::OnMotion(wxMouseEvent& evt)
2796 {
2797     // start a drag event
2798     if (!m_dragging &&
2799         m_action_item != NULL &&
2800         m_action_pos != wxPoint(-1,-1) &&
2801         abs(evt.m_x - m_action_pos.x) + abs(evt.m_y - m_action_pos.y) > 5)
2802     {
2803         UnsetToolTip();
2804
2805         m_dragging = true;
2806
2807         wxAuiToolBarEvent e(wxEVT_COMMAND_AUITOOLBAR_BEGIN_DRAG, GetId());
2808         e.SetEventObject(this);
2809         e.SetToolId(m_action_item->id);
2810         GetEventHandler()->ProcessEvent(e);
2811         DoIdleUpdate();
2812         return;
2813     }
2814
2815     wxAuiToolBarItem* hit_item = FindToolByPosition(evt.GetX(), evt.GetY());
2816     if (hit_item)
2817     {
2818         if (!(hit_item->state & wxAUI_BUTTON_STATE_DISABLED))
2819             SetHoverItem(hit_item);
2820         else
2821             SetHoverItem(NULL);
2822     }
2823     else
2824     {
2825         // no hit item, remove any hit item
2826         SetHoverItem(hit_item);
2827     }
2828
2829     // figure out tooltips
2830     wxAuiToolBarItem* packing_hit_item;
2831     packing_hit_item = FindToolByPositionWithPacking(evt.GetX(), evt.GetY());
2832     if (packing_hit_item)
2833     {
2834         if (packing_hit_item != m_tip_item)
2835         {
2836             m_tip_item = packing_hit_item;
2837
2838             if ( !packing_hit_item->short_help.empty() )
2839                 SetToolTip(packing_hit_item->short_help);
2840             else
2841                 UnsetToolTip();
2842         }
2843     }
2844     else
2845     {
2846         UnsetToolTip();
2847         m_tip_item = NULL;
2848     }
2849
2850     // if we've pressed down an item and we're hovering
2851     // over it, make sure it's state is set to pressed
2852     if (m_action_item)
2853     {
2854         if (m_action_item == hit_item)
2855             SetPressedItem(m_action_item);
2856         else
2857             SetPressedItem(NULL);
2858     }
2859
2860     // figure out the dropdown button state (are we hovering or pressing it?)
2861     RefreshOverflowState();
2862 }
2863
2864 void wxAuiToolBar::OnLeaveWindow(wxMouseEvent& WXUNUSED(evt))
2865 {
2866     RefreshOverflowState();
2867     SetHoverItem(NULL);
2868     SetPressedItem(NULL);
2869
2870     m_tip_item = NULL;
2871 }
2872
2873
2874 void wxAuiToolBar::OnSetCursor(wxSetCursorEvent& evt)
2875 {
2876     wxCursor cursor = wxNullCursor;
2877
2878     if (m_gripper_sizer_item)
2879     {
2880         wxRect gripper_rect = m_gripper_sizer_item->GetRect();
2881         if (gripper_rect.Contains(evt.GetX(), evt.GetY()))
2882         {
2883             cursor = wxCursor(wxCURSOR_SIZING);
2884         }
2885     }
2886
2887     evt.SetCursor(cursor);
2888 }
2889
2890
2891 #endif // wxUSE_AUI
2892