src/aui/auibar.cpp

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