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