src/msw/toolbar.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/toolbar.cpp
   3 // Purpose:     wxToolBar
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #if wxUSE_TOOLBAR && wxUSE_TOOLBAR_NATIVE && !defined(__SMARTPHONE__)
  28
  29 #include "wx/toolbar.h"
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/msw/wrapcctl.h" // include <commctrl.h> "properly"
  33     #include "wx/dynarray.h"
  34     #include "wx/frame.h"
  35     #include "wx/log.h"
  36     #include "wx/intl.h"
  37     #include "wx/settings.h"
  38     #include "wx/bitmap.h"
  39     #include "wx/dcmemory.h"
  40     #include "wx/control.h"
  41     #include "wx/app.h"         // for GetComCtl32Version
  42     #include "wx/image.h"
  43     #include "wx/stattext.h"
  44 #endif
  45
  46 #include "wx/artprov.h"
  47 #include "wx/sysopt.h"
  48 #include "wx/dcclient.h"
  49 #include "wx/scopedarray.h"
  50
  51 #include "wx/msw/private.h"
  52 #include "wx/msw/dc.h"
  53
  54 #if wxUSE_UXTHEME
  55 #include "wx/msw/uxtheme.h"
  56 #endif
  57
  58 // this define controls whether the code for button colours remapping (only
  59 // useful for 16 or 256 colour images) is active at all, it's always turned off
  60 // for CE where it doesn't compile (and is probably not needed anyhow) and may
  61 // also be turned off for other systems if you always use 24bpp images and so
  62 // never need it
  63 #ifndef __WXWINCE__
  64     #define wxREMAP_BUTTON_COLOURS
  65 #endif // !__WXWINCE__
  66
  67 // ----------------------------------------------------------------------------
  68 // constants
  69 // ----------------------------------------------------------------------------
  70
  71 // these standard constants are not always defined in compilers headers
  72
  73 // Styles
  74 #ifndef TBSTYLE_FLAT
  75     #define TBSTYLE_LIST            0x1000
  76     #define TBSTYLE_FLAT            0x0800
  77 #endif
  78
  79 #ifndef TBSTYLE_TRANSPARENT
  80     #define TBSTYLE_TRANSPARENT     0x8000
  81 #endif
  82
  83 #ifndef TBSTYLE_TOOLTIPS
  84     #define TBSTYLE_TOOLTIPS        0x0100
  85 #endif
  86
  87 // Messages
  88 #ifndef TB_GETSTYLE
  89     #define TB_SETSTYLE             (WM_USER + 56)
  90     #define TB_GETSTYLE             (WM_USER + 57)
  91 #endif
  92
  93 #ifndef TB_HITTEST
  94     #define TB_HITTEST              (WM_USER + 69)
  95 #endif
  96
  97 #ifndef TB_GETMAXSIZE
  98     #define TB_GETMAXSIZE           (WM_USER + 83)
  99 #endif
 100
 101 // ----------------------------------------------------------------------------
 102 // wxWin macros
 103 // ----------------------------------------------------------------------------
 104
 105 IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxControl)
 106
 107 /*
 108     TOOLBAR PROPERTIES
 109         tool
 110             bitmap
 111             bitmap2
 112             tooltip
 113             longhelp
 114             radio (bool)
 115             toggle (bool)
 116         separator
 117         style ( wxNO_BORDER | wxTB_HORIZONTAL)
 118         bitmapsize
 119         margins
 120         packing
 121         separation
 122
 123         dontattachtoframe
 124 */
 125
 126 BEGIN_EVENT_TABLE(wxToolBar, wxToolBarBase)
 127     EVT_MOUSE_EVENTS(wxToolBar::OnMouseEvent)
 128     EVT_SYS_COLOUR_CHANGED(wxToolBar::OnSysColourChanged)
 129     EVT_ERASE_BACKGROUND(wxToolBar::OnEraseBackground)
 130 END_EVENT_TABLE()
 131
 132 // ----------------------------------------------------------------------------
 133 // private classes
 134 // ----------------------------------------------------------------------------
 135
 136 class wxToolBarTool : public wxToolBarToolBase
 137 {
 138 public:
 139     wxToolBarTool(wxToolBar *tbar,
 140                   int id,
 141                   const wxString& label,
 142                   const wxBitmap& bmpNormal,
 143                   const wxBitmap& bmpDisabled,
 144                   wxItemKind kind,
 145                   wxObject *clientData,
 146                   const wxString& shortHelp,
 147                   const wxString& longHelp)
 148         : wxToolBarToolBase(tbar, id, label, bmpNormal, bmpDisabled, kind,
 149                             clientData, shortHelp, longHelp)
 150     {
 151         m_nSepCount = 0;
 152         m_staticText = 0;
 153     }
 154
 155     wxToolBarTool(wxToolBar *tbar, wxControl *control, const wxString& label)
 156         : wxToolBarToolBase(tbar, control, label)
 157     {
 158         if ( IsControl() && !m_label.empty() )
 159         {
 160             // create a control to render the control's label
 161             m_staticText = new wxStaticText
 162                                (
 163                                  m_tbar,
 164                                  wxID_ANY,
 165                                  m_label,
 166                                  wxDefaultPosition,
 167                                  wxDefaultSize,
 168                                  wxALIGN_CENTRE | wxST_NO_AUTORESIZE
 169                                );
 170         }
 171         else // no label
 172         {
 173             m_staticText = NULL;
 174         }
 175
 176         m_nSepCount = 1;
 177     }
 178
 179     virtual ~wxToolBarTool()
 180     {
 181         delete m_staticText;
 182     }
 183
 184     virtual void SetLabel(const wxString& label)
 185     {
 186         if ( label == m_label )
 187             return;
 188
 189         wxToolBarToolBase::SetLabel(label);
 190
 191         if ( m_staticText )
 192             m_staticText->SetLabel(label);
 193
 194         // we need to update the label shown in the toolbar because it has a
 195         // pointer to the internal buffer of the old label
 196         //
 197         // TODO: use TB_SETBUTTONINFO
 198     }
 199
 200     wxStaticText* GetStaticText()
 201     {
 202         wxASSERT_MSG( IsControl(),
 203                       _T("only makes sense for embedded control tools") );
 204
 205         return m_staticText;
 206     }
 207
 208     // set/get the number of separators which we use to cover the space used by
 209     // a control in the toolbar
 210     void SetSeparatorsCount(size_t count) { m_nSepCount = count; }
 211     size_t GetSeparatorsCount() const { return m_nSepCount; }
 212
 213 private:
 214     size_t m_nSepCount;
 215     wxStaticText *m_staticText;
 216
 217     DECLARE_NO_COPY_CLASS(wxToolBarTool)
 218 };
 219
 220 // ----------------------------------------------------------------------------
 221 // helper functions
 222 // ----------------------------------------------------------------------------
 223
 224 // return the rectangle of the item at the given index
 225 //
 226 // returns an empty (0, 0, 0, 0) rectangle if fails so the caller may compare
 227 // r.right or r.bottom with 0 to check for this
 228 static RECT wxGetTBItemRect(HWND hwnd, int index)
 229 {
 230     RECT r;
 231
 232     // note that we use TB_GETITEMRECT and not TB_GETRECT because the latter
 233     // only appeared in v4.70 of comctl32.dll
 234     if ( !::SendMessage(hwnd, TB_GETITEMRECT, index, (LPARAM)&r) )
 235     {
 236         wxLogLastError(wxT("TB_GETITEMRECT"));
 237
 238         r.top =
 239         r.left =
 240         r.right =
 241         r.bottom = 0;
 242     }
 243
 244     return r;
 245 }
 246
 247 // ============================================================================
 248 // implementation
 249 // ============================================================================
 250
 251 // ----------------------------------------------------------------------------
 252 // wxToolBarTool
 253 // ----------------------------------------------------------------------------
 254
 255 wxToolBarToolBase *wxToolBar::CreateTool(int id,
 256                                          const wxString& label,
 257                                          const wxBitmap& bmpNormal,
 258                                          const wxBitmap& bmpDisabled,
 259                                          wxItemKind kind,
 260                                          wxObject *clientData,
 261                                          const wxString& shortHelp,
 262                                          const wxString& longHelp)
 263 {
 264     return new wxToolBarTool(this, id, label, bmpNormal, bmpDisabled, kind,
 265                              clientData, shortHelp, longHelp);
 266 }
 267
 268 wxToolBarToolBase *
 269 wxToolBar::CreateTool(wxControl *control, const wxString& label)
 270 {
 271     return new wxToolBarTool(this, control, label);
 272 }
 273
 274 // ----------------------------------------------------------------------------
 275 // wxToolBar construction
 276 // ----------------------------------------------------------------------------
 277
 278 void wxToolBar::Init()
 279 {
 280     m_hBitmap = 0;
 281     m_disabledImgList = NULL;
 282
 283     m_nButtons = 0;
 284
 285     // even though modern Windows applications typically use 24*24 (or even
 286     // 32*32) size for their bitmaps, the native control itself still uses the
 287     // old 16*15 default size (see TB_SETBITMAPSIZE documentation in MSDN), so
 288     // default to it so that we don't call SetToolBitmapSize() unnecessarily in
 289     // AdjustToolBitmapSize()
 290     m_defaultWidth = 16;
 291     m_defaultHeight = 15;
 292
 293     m_pInTool = NULL;
 294 }
 295
 296 bool wxToolBar::Create(wxWindow *parent,
 297                        wxWindowID id,
 298                        const wxPoint& pos,
 299                        const wxSize& size,
 300                        long style,
 301                        const wxString& name)
 302 {
 303     // common initialisation
 304     if ( !CreateControl(parent, id, pos, size, style, wxDefaultValidator, name) )
 305         return false;
 306
 307     FixupStyle();
 308
 309     // MSW-specific initialisation
 310     if ( !MSWCreateToolbar(pos, size) )
 311         return false;
 312
 313     wxSetCCUnicodeFormat(GetHwnd());
 314
 315     // workaround for flat toolbar on Windows XP classic style: we have to set
 316     // the style after creating the control; doing it at creation time doesn't work
 317 #if wxUSE_UXTHEME
 318     if ( style & wxTB_FLAT )
 319     {
 320         LRESULT style = GetMSWToolbarStyle();
 321
 322         if ( !(style & TBSTYLE_FLAT) )
 323             ::SendMessage(GetHwnd(), TB_SETSTYLE, 0, style | TBSTYLE_FLAT);
 324     }
 325 #endif // wxUSE_UXTHEME
 326
 327     return true;
 328 }
 329
 330 bool wxToolBar::MSWCreateToolbar(const wxPoint& pos, const wxSize& size)
 331 {
 332     if ( !MSWCreateControl(TOOLBARCLASSNAME, wxEmptyString, pos, size) )
 333         return false;
 334
 335     // toolbar-specific post initialisation
 336     ::SendMessage(GetHwnd(), TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0);
 337
 338 #ifdef TB_SETEXTENDEDSTYLE
 339     if ( wxApp::GetComCtl32Version() >= 471 )
 340         ::SendMessage(GetHwnd(), TB_SETEXTENDEDSTYLE, 0, TBSTYLE_EX_DRAWDDARROWS);
 341 #endif
 342
 343     return true;
 344 }
 345
 346 void wxToolBar::Recreate()
 347 {
 348     const HWND hwndOld = GetHwnd();
 349     if ( !hwndOld )
 350     {
 351         // we haven't been created yet, no need to recreate
 352         return;
 353     }
 354
 355     // get the position and size before unsubclassing the old toolbar
 356     const wxPoint pos = GetPosition();
 357     const wxSize size = GetSize();
 358
 359     UnsubclassWin();
 360
 361     if ( !MSWCreateToolbar(pos, size) )
 362     {
 363         // what can we do?
 364         wxFAIL_MSG( _T("recreating the toolbar failed") );
 365
 366         return;
 367     }
 368
 369     // reparent all our children under the new toolbar
 370     for ( wxWindowList::compatibility_iterator node = m_children.GetFirst();
 371           node;
 372           node = node->GetNext() )
 373     {
 374         wxWindow *win = node->GetData();
 375         if ( !win->IsTopLevel() )
 376             ::SetParent(GetHwndOf(win), GetHwnd());
 377     }
 378
 379     // only destroy the old toolbar now --
 380     // after all the children had been reparented
 381     ::DestroyWindow(hwndOld);
 382
 383     // it is for the old bitmap control and can't be used with the new one
 384     if ( m_hBitmap )
 385     {
 386         ::DeleteObject((HBITMAP) m_hBitmap);
 387         m_hBitmap = 0;
 388     }
 389
 390     if ( m_disabledImgList )
 391     {
 392         delete m_disabledImgList;
 393         m_disabledImgList = NULL;
 394     }
 395
 396     Realize();
 397 }
 398
 399 wxToolBar::~wxToolBar()
 400 {
 401     // we must refresh the frame size when the toolbar is deleted but the frame
 402     // is not - otherwise toolbar leaves a hole in the place it used to occupy
 403     SendSizeEventToParent();
 404
 405     if ( m_hBitmap )
 406         ::DeleteObject((HBITMAP) m_hBitmap);
 407
 408     delete m_disabledImgList;
 409 }
 410
 411 wxSize wxToolBar::DoGetBestSize() const
 412 {
 413     wxSize sizeBest;
 414
 415     SIZE size;
 416     if ( !::SendMessage(GetHwnd(), TB_GETMAXSIZE, 0, (LPARAM)&size) )
 417     {
 418         // maybe an old (< 0x400) Windows version? try to approximate the
 419         // toolbar size ourselves
 420         sizeBest = GetToolSize();
 421         sizeBest.y += 2 * ::GetSystemMetrics(SM_CYBORDER); // Add borders
 422         sizeBest.x *= GetToolsCount();
 423
 424         // reverse horz and vertical components if necessary
 425         if ( IsVertical() )
 426         {
 427             int t = sizeBest.x;
 428             sizeBest.x = sizeBest.y;
 429             sizeBest.y = t;
 430         }
 431     }
 432     else // TB_GETMAXSIZE succeeded
 433     {
 434         // but it could still return an incorrect result due to what appears to
 435         // be a bug in old comctl32.dll versions which don't handle controls in
 436         // the toolbar correctly, so work around it (see SF patch 1902358)
 437         if ( !IsVertical() && wxApp::GetComCtl32Version() < 600 )
 438         {
 439             // calculate the toolbar width in alternative way
 440             const RECT rcFirst = wxGetTBItemRect(GetHwnd(), 0);
 441             const RECT rcLast = wxGetTBItemRect(GetHwnd(), GetToolsCount() - 1);
 442
 443             const int widthAlt = rcLast.right - rcFirst.left;
 444             if ( widthAlt > size.cx )
 445                 size.cx = widthAlt;
 446         }
 447
 448         sizeBest.x = size.cx;
 449         sizeBest.y = size.cy;
 450     }
 451
 452     if ( !IsVertical() )
 453     {
 454         // Without the extra height, DoGetBestSize can report a size that's
 455         // smaller than the actual window, causing windows to overlap slightly
 456         // in some circumstances, leading to missing borders (especially noticeable
 457         // in AUI layouts).
 458         if (!(GetWindowStyle() & wxTB_NODIVIDER))
 459             sizeBest.y += 2;
 460         sizeBest.y ++;
 461     }
 462
 463     CacheBestSize(sizeBest);
 464
 465     return sizeBest;
 466 }
 467
 468 WXDWORD wxToolBar::MSWGetStyle(long style, WXDWORD *exstyle) const
 469 {
 470     // toolbars never have border, giving one to them results in broken
 471     // appearance
 472     WXDWORD msStyle = wxControl::MSWGetStyle
 473                       (
 474                         (style & ~wxBORDER_MASK) | wxBORDER_NONE, exstyle
 475                       );
 476
 477     if ( !(style & wxTB_NO_TOOLTIPS) )
 478         msStyle |= TBSTYLE_TOOLTIPS;
 479
 480     if ( style & (wxTB_FLAT | wxTB_HORZ_LAYOUT) )
 481     {
 482         // static as it doesn't change during the program lifetime
 483         static const int s_verComCtl = wxApp::GetComCtl32Version();
 484
 485         // comctl32.dll 4.00 doesn't support the flat toolbars and using this
 486         // style with 6.00 (part of Windows XP) leads to the toolbar with
 487         // incorrect background colour - and not using it still results in the
 488         // correct (flat) toolbar, so don't use it there
 489         if ( s_verComCtl > 400 && s_verComCtl < 600 )
 490             msStyle |= TBSTYLE_FLAT | TBSTYLE_TRANSPARENT;
 491
 492         if ( s_verComCtl >= 470 && style & wxTB_HORZ_LAYOUT )
 493             msStyle |= TBSTYLE_LIST;
 494     }
 495
 496     if ( style & wxTB_NODIVIDER )
 497         msStyle |= CCS_NODIVIDER;
 498
 499     if ( style & wxTB_NOALIGN )
 500         msStyle |= CCS_NOPARENTALIGN;
 501
 502     if ( style & wxTB_VERTICAL )
 503         msStyle |= CCS_VERT;
 504
 505     if( style & wxTB_BOTTOM )
 506         msStyle |= CCS_BOTTOM;
 507
 508     if ( style & wxTB_RIGHT )
 509         msStyle |= CCS_RIGHT;
 510
 511     return msStyle;
 512 }
 513
 514 // ----------------------------------------------------------------------------
 515 // adding/removing tools
 516 // ----------------------------------------------------------------------------
 517
 518 bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos),
 519                              wxToolBarToolBase * WXUNUSED(tool))
 520 {
 521     // nothing special to do here - we really create the toolbar buttons in
 522     // Realize() later
 523     InvalidateBestSize();
 524     return true;
 525 }
 526
 527 bool wxToolBar::DoDeleteTool(size_t pos, wxToolBarToolBase *tool)
 528 {
 529     // the main difficulty we have here is with the controls in the toolbars:
 530     // as we (sometimes) use several separators to cover up the space used by
 531     // them, the indices are not the same for us and the toolbar
 532
 533     // first determine the position of the first button to delete: it may be
 534     // different from pos if we use several separators to cover the space used
 535     // by a control
 536     wxToolBarToolsList::compatibility_iterator node;
 537     for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
 538     {
 539         wxToolBarToolBase *tool2 = node->GetData();
 540         if ( tool2 == tool )
 541         {
 542             // let node point to the next node in the list
 543             node = node->GetNext();
 544
 545             break;
 546         }
 547
 548         if ( tool2->IsControl() )
 549             pos += ((wxToolBarTool *)tool2)->GetSeparatorsCount() - 1;
 550     }
 551
 552     // now determine the number of buttons to delete and the area taken by them
 553     size_t nButtonsToDelete = 1;
 554
 555     // get the size of the button we're going to delete
 556     const RECT r = wxGetTBItemRect(GetHwnd(), pos);
 557
 558     int width = r.right - r.left;
 559
 560     if ( tool->IsControl() )
 561     {
 562         nButtonsToDelete = ((wxToolBarTool *)tool)->GetSeparatorsCount();
 563         width *= nButtonsToDelete;
 564     }
 565
 566     // do delete all buttons
 567     m_nButtons -= nButtonsToDelete;
 568     while ( nButtonsToDelete-- > 0 )
 569     {
 570         if ( !::SendMessage(GetHwnd(), TB_DELETEBUTTON, pos, 0) )
 571         {
 572             wxLogLastError(wxT("TB_DELETEBUTTON"));
 573
 574             return false;
 575         }
 576     }
 577
 578     // and finally reposition all the controls after this button (the toolbar
 579     // takes care of all normal items)
 580     for ( /* node -> first after deleted */ ; node; node = node->GetNext() )
 581     {
 582         wxToolBarTool *tool2 = (wxToolBarTool*)node->GetData();
 583         if ( tool2->IsControl() )
 584         {
 585             wxControl * const control = tool2->GetControl();
 586
 587             int x;
 588             control->GetPosition(&x, NULL);
 589             control->Move(x - width, wxDefaultCoord);
 590
 591             wxStaticText * const staticText = tool2->GetStaticText();
 592             if ( staticText )
 593                 staticText->Move(x - width, wxDefaultCoord);
 594         }
 595     }
 596
 597     InvalidateBestSize();
 598
 599     return true;
 600 }
 601
 602 void wxToolBar::CreateDisabledImageList()
 603 {
 604     if (m_disabledImgList != NULL)
 605     {
 606         delete m_disabledImgList;
 607         m_disabledImgList = NULL;
 608     }
 609
 610     // as we can't use disabled image list with older versions of comctl32.dll,
 611     // don't even bother creating it
 612     if ( wxApp::GetComCtl32Version() >= 470 )
 613     {
 614         // search for the first disabled button img in the toolbar, if any
 615         for ( wxToolBarToolsList::compatibility_iterator
 616                 node = m_tools.GetFirst(); node; node = node->GetNext() )
 617         {
 618             wxToolBarToolBase *tool = node->GetData();
 619             wxBitmap bmpDisabled = tool->GetDisabledBitmap();
 620             if ( bmpDisabled.Ok() )
 621             {
 622                 m_disabledImgList = new wxImageList
 623                                         (
 624                                             m_defaultWidth,
 625                                             m_defaultHeight,
 626                                             bmpDisabled.GetMask() != NULL,
 627                                             GetToolsCount()
 628                                         );
 629                 break;
 630             }
 631         }
 632
 633         // we don't have any disabled bitmaps
 634     }
 635 }
 636
 637 void wxToolBar::AdjustToolBitmapSize()
 638 {
 639     const wxSize sizeOrig(m_defaultWidth, m_defaultHeight);
 640
 641     wxSize sizeActual(sizeOrig);
 642
 643     for ( wxToolBarToolsList::const_iterator i = m_tools.begin();
 644           i != m_tools.end();
 645           ++i )
 646     {
 647         const wxBitmap& bmp = (*i)->GetNormalBitmap();
 648         sizeActual.IncTo(bmp.GetSize());
 649     }
 650
 651     if ( sizeActual != sizeOrig )
 652         SetToolBitmapSize(sizeActual);
 653 }
 654
 655 bool wxToolBar::Realize()
 656 {
 657     const size_t nTools = GetToolsCount();
 658     if ( nTools == 0 )
 659         // nothing to do
 660         return true;
 661
 662     // make sure tool size is larger enough for all all bitmaps to fit in
 663     // (this is consistent with what other ports do):
 664     AdjustToolBitmapSize();
 665
 666 #ifdef wxREMAP_BUTTON_COLOURS
 667     // don't change the values of these constants, they can be set from the
 668     // user code via wxSystemOptions
 669     enum
 670     {
 671         Remap_None = -1,
 672         Remap_Bg,
 673         Remap_Buttons,
 674         Remap_TransparentBg
 675     };
 676
 677     // the user-specified option overrides anything, but if it wasn't set, only
 678     // remap the buttons on 8bpp displays as otherwise the bitmaps usually look
 679     // much worse after remapping
 680     static const wxChar *remapOption = wxT("msw.remap");
 681     const int remapValue = wxSystemOptions::HasOption(remapOption)
 682                                 ? wxSystemOptions::GetOptionInt(remapOption)
 683                                 : wxDisplayDepth() <= 8 ? Remap_Buttons
 684                                                         : Remap_None;
 685
 686 #endif // wxREMAP_BUTTON_COLOURS
 687
 688     // delete all old buttons, if any
 689     for ( size_t pos = 0; pos < m_nButtons; pos++ )
 690     {
 691         if ( !::SendMessage(GetHwnd(), TB_DELETEBUTTON, 0, 0) )
 692         {
 693             wxLogDebug(wxT("TB_DELETEBUTTON failed"));
 694         }
 695     }
 696
 697     // First, add the bitmap: we use one bitmap for all toolbar buttons
 698     // ----------------------------------------------------------------
 699
 700     wxToolBarToolsList::compatibility_iterator node;
 701     int bitmapId = 0;
 702
 703     if ( !HasFlag(wxTB_NOICONS) )
 704     {
 705         // if we already have a bitmap, we'll replace the existing one --
 706         // otherwise we'll install a new one
 707         HBITMAP oldToolBarBitmap = (HBITMAP)m_hBitmap;
 708
 709         const wxCoord totalBitmapWidth  = m_defaultWidth *
 710                                           wx_truncate_cast(wxCoord, nTools),
 711                       totalBitmapHeight = m_defaultHeight;
 712
 713         // Create a bitmap and copy all the tool bitmaps into it
 714         wxMemoryDC dcAllButtons;
 715         wxBitmap bitmap(totalBitmapWidth, totalBitmapHeight);
 716         dcAllButtons.SelectObject(bitmap);
 717
 718 #ifdef wxREMAP_BUTTON_COLOURS
 719         if ( remapValue != Remap_TransparentBg )
 720 #endif // wxREMAP_BUTTON_COLOURS
 721         {
 722             // VZ: why do we hardcode grey colour for CE?
 723             dcAllButtons.SetBackground(wxBrush(
 724 #ifdef __WXWINCE__
 725                                         wxColour(0xc0, 0xc0, 0xc0)
 726 #else // !__WXWINCE__
 727                                         GetBackgroundColour()
 728 #endif // __WXWINCE__/!__WXWINCE__
 729                                        ));
 730             dcAllButtons.Clear();
 731         }
 732
 733         m_hBitmap = bitmap.GetHBITMAP();
 734         HBITMAP hBitmap = (HBITMAP)m_hBitmap;
 735
 736 #ifdef wxREMAP_BUTTON_COLOURS
 737         if ( remapValue == Remap_Bg )
 738         {
 739             dcAllButtons.SelectObject(wxNullBitmap);
 740
 741             // Even if we're not remapping the bitmap
 742             // content, we still have to remap the background.
 743             hBitmap = (HBITMAP)MapBitmap((WXHBITMAP) hBitmap,
 744                 totalBitmapWidth, totalBitmapHeight);
 745
 746             dcAllButtons.SelectObject(bitmap);
 747         }
 748 #endif // wxREMAP_BUTTON_COLOURS
 749
 750         // the button position
 751         wxCoord x = 0;
 752
 753         // the number of buttons (not separators)
 754         int nButtons = 0;
 755
 756         CreateDisabledImageList();
 757         for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
 758         {
 759             wxToolBarToolBase *tool = node->GetData();
 760             if ( tool->IsButton() )
 761             {
 762                 const wxBitmap& bmp = tool->GetNormalBitmap();
 763
 764                 const int w = bmp.GetWidth();
 765                 const int h = bmp.GetHeight();
 766
 767                 if ( bmp.Ok() )
 768                 {
 769                     int xOffset = wxMax(0, (m_defaultWidth - w)/2);
 770                     int yOffset = wxMax(0, (m_defaultHeight - h)/2);
 771
 772                     // notice the last parameter: do use mask
 773                     dcAllButtons.DrawBitmap(bmp, x + xOffset, yOffset, true);
 774                 }
 775                 else
 776                 {
 777                     wxFAIL_MSG( _T("invalid tool button bitmap") );
 778                 }
 779
 780                 // also deal with disabled bitmap if we want to use them
 781                 if ( m_disabledImgList )
 782                 {
 783                     wxBitmap bmpDisabled = tool->GetDisabledBitmap();
 784 #if wxUSE_IMAGE && wxUSE_WXDIB
 785                     if ( !bmpDisabled.Ok() )
 786                     {
 787                         // no disabled bitmap specified but we still need to
 788                         // fill the space in the image list with something, so
 789                         // we grey out the normal bitmap
 790                         wxImage
 791                           imgGreyed = bmp.ConvertToImage().ConvertToGreyscale();
 792
 793 #ifdef wxREMAP_BUTTON_COLOURS
 794                         if ( remapValue == Remap_Buttons )
 795                         {
 796                             // we need to have light grey background colour for
 797                             // MapBitmap() to work correctly
 798                             for ( int y = 0; y < h; y++ )
 799                             {
 800                                 for ( int x = 0; x < w; x++ )
 801                                 {
 802                                     if ( imgGreyed.IsTransparent(x, y) )
 803                                         imgGreyed.SetRGB(x, y,
 804                                                          wxLIGHT_GREY->Red(),
 805                                                          wxLIGHT_GREY->Green(),
 806                                                          wxLIGHT_GREY->Blue());
 807                                 }
 808                             }
 809                         }
 810 #endif // wxREMAP_BUTTON_COLOURS
 811
 812                         bmpDisabled = wxBitmap(imgGreyed);
 813                     }
 814 #endif // wxUSE_IMAGE
 815
 816 #ifdef wxREMAP_BUTTON_COLOURS
 817                     if ( remapValue == Remap_Buttons )
 818                         MapBitmap(bmpDisabled.GetHBITMAP(), w, h);
 819 #endif // wxREMAP_BUTTON_COLOURS
 820
 821                     m_disabledImgList->Add(bmpDisabled);
 822                 }
 823
 824                 // still inc width and number of buttons because otherwise the
 825                 // subsequent buttons will all be shifted which is rather confusing
 826                 // (and like this you'd see immediately which bitmap was bad)
 827                 x += m_defaultWidth;
 828                 nButtons++;
 829             }
 830         }
 831
 832         dcAllButtons.SelectObject(wxNullBitmap);
 833
 834         // don't delete this HBITMAP!
 835         bitmap.SetHBITMAP(0);
 836
 837 #ifdef wxREMAP_BUTTON_COLOURS
 838         if ( remapValue == Remap_Buttons )
 839         {
 840             // Map to system colours
 841             hBitmap = (HBITMAP)MapBitmap((WXHBITMAP) hBitmap,
 842                                          totalBitmapWidth, totalBitmapHeight);
 843         }
 844 #endif // wxREMAP_BUTTON_COLOURS
 845
 846         bool addBitmap = true;
 847
 848         if ( oldToolBarBitmap )
 849         {
 850 #ifdef TB_REPLACEBITMAP
 851             if ( wxApp::GetComCtl32Version() >= 400 )
 852             {
 853                 TBREPLACEBITMAP replaceBitmap;
 854                 replaceBitmap.hInstOld = NULL;
 855                 replaceBitmap.hInstNew = NULL;
 856                 replaceBitmap.nIDOld = (UINT_PTR)oldToolBarBitmap;
 857                 replaceBitmap.nIDNew = (UINT_PTR)hBitmap;
 858                 replaceBitmap.nButtons = nButtons;
 859                 if ( !::SendMessage(GetHwnd(), TB_REPLACEBITMAP,
 860                                     0, (LPARAM) &replaceBitmap) )
 861                 {
 862                     wxFAIL_MSG(wxT("Could not replace the old bitmap"));
 863                 }
 864
 865                 ::DeleteObject(oldToolBarBitmap);
 866
 867                 // already done
 868                 addBitmap = false;
 869             }
 870             else
 871 #endif // TB_REPLACEBITMAP
 872             {
 873                 // we can't replace the old bitmap, so we will add another one
 874                 // (awfully inefficient, but what else to do?) and shift the bitmap
 875                 // indices accordingly
 876                 addBitmap = true;
 877
 878                 bitmapId = m_nButtons;
 879             }
 880         }
 881
 882         if ( addBitmap ) // no old bitmap or we can't replace it
 883         {
 884             TBADDBITMAP addBitmap;
 885             addBitmap.hInst = 0;
 886             addBitmap.nID = (UINT_PTR)hBitmap;
 887             if ( ::SendMessage(GetHwnd(), TB_ADDBITMAP,
 888                                (WPARAM) nButtons, (LPARAM)&addBitmap) == -1 )
 889             {
 890                 wxFAIL_MSG(wxT("Could not add bitmap to toolbar"));
 891             }
 892         }
 893
 894         // disable image lists are only supported in comctl32.dll 4.70+
 895         if ( wxApp::GetComCtl32Version() >= 470 )
 896         {
 897             HIMAGELIST hil = m_disabledImgList
 898                                 ? GetHimagelistOf(m_disabledImgList)
 899                                 : 0;
 900
 901             // notice that we set the image list even if don't have one right
 902             // now as we could have it before and need to reset it in this case
 903             HIMAGELIST oldImageList = (HIMAGELIST)
 904               ::SendMessage(GetHwnd(), TB_SETDISABLEDIMAGELIST, 0, (LPARAM)hil);
 905
 906             // delete previous image list if any
 907             if ( oldImageList )
 908                 ::DeleteObject(oldImageList);
 909         }
 910     }
 911
 912
 913     // Next add the buttons and separators
 914     // -----------------------------------
 915
 916     wxScopedArray<TBBUTTON> buttons(new TBBUTTON[nTools]);
 917
 918     // this array will hold the indices of all controls in the toolbar
 919     wxArrayInt controlIds;
 920
 921     bool lastWasRadio = false;
 922     int i = 0;
 923     for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
 924     {
 925         wxToolBarToolBase *tool = node->GetData();
 926
 927         // don't add separators to the vertical toolbar with old comctl32.dll
 928         // versions as they didn't handle this properly
 929         if ( IsVertical() && tool->IsSeparator() &&
 930                 wxApp::GetComCtl32Version() <= 472 )
 931         {
 932             continue;
 933         }
 934
 935         TBBUTTON& button = buttons[i];
 936
 937         wxZeroMemory(button);
 938
 939         bool isRadio = false;
 940         switch ( tool->GetStyle() )
 941         {
 942             case wxTOOL_STYLE_CONTROL:
 943                 button.idCommand = tool->GetId();
 944                 // fall through: create just a separator too
 945
 946             case wxTOOL_STYLE_SEPARATOR:
 947                 button.fsState = TBSTATE_ENABLED;
 948                 button.fsStyle = TBSTYLE_SEP;
 949                 break;
 950
 951             case wxTOOL_STYLE_BUTTON:
 952                 if ( !HasFlag(wxTB_NOICONS) )
 953                     button.iBitmap = bitmapId;
 954
 955                 if ( HasFlag(wxTB_TEXT) )
 956                 {
 957                     const wxString& label = tool->GetLabel();
 958                     if ( !label.empty() )
 959                         button.iString = (INT_PTR)label.wx_str();
 960                 }
 961
 962                 button.idCommand = tool->GetId();
 963
 964                 if ( tool->IsEnabled() )
 965                     button.fsState |= TBSTATE_ENABLED;
 966                 if ( tool->IsToggled() )
 967                     button.fsState |= TBSTATE_CHECKED;
 968
 969                 switch ( tool->GetKind() )
 970                 {
 971                     case wxITEM_RADIO:
 972                         button.fsStyle = TBSTYLE_CHECKGROUP;
 973
 974                         if ( !lastWasRadio )
 975                         {
 976                             // the first item in the radio group is checked by
 977                             // default to be consistent with wxGTK and the menu
 978                             // radio items
 979                             button.fsState |= TBSTATE_CHECKED;
 980
 981                             if (tool->Toggle(true))
 982                             {
 983                                 DoToggleTool(tool, true);
 984                             }
 985                         }
 986                         else if ( tool->IsToggled() )
 987                         {
 988                             wxToolBarToolsList::compatibility_iterator nodePrev = node->GetPrevious();
 989                             int prevIndex = i - 1;
 990                             while ( nodePrev )
 991                             {
 992                                 TBBUTTON& prevButton = buttons[prevIndex];
 993                                 wxToolBarToolBase *tool = nodePrev->GetData();
 994                                 if ( !tool->IsButton() || tool->GetKind() != wxITEM_RADIO )
 995                                     break;
 996
 997                                 if ( tool->Toggle(false) )
 998                                     DoToggleTool(tool, false);
 999
1000                                 prevButton.fsState &= ~TBSTATE_CHECKED;
1001                                 nodePrev = nodePrev->GetPrevious();
1002                                 prevIndex--;
1003                             }
1004                         }
1005
1006                         isRadio = true;
1007                         break;
1008
1009                     case wxITEM_CHECK:
1010                         button.fsStyle = TBSTYLE_CHECK;
1011                         break;
1012
1013                     case wxITEM_NORMAL:
1014                         button.fsStyle = TBSTYLE_BUTTON;
1015                         break;
1016
1017                    case wxITEM_DROPDOWN:
1018                         button.fsStyle = TBSTYLE_DROPDOWN;
1019                         break;
1020
1021                     default:
1022                         wxFAIL_MSG( _T("unexpected toolbar button kind") );
1023                         button.fsStyle = TBSTYLE_BUTTON;
1024                         break;
1025                 }
1026
1027                 bitmapId++;
1028                 break;
1029         }
1030
1031         lastWasRadio = isRadio;
1032
1033         i++;
1034     }
1035
1036     if ( !::SendMessage(GetHwnd(), TB_ADDBUTTONS, i, (LPARAM)buttons.get()) )
1037     {
1038         wxLogLastError(wxT("TB_ADDBUTTONS"));
1039     }
1040
1041
1042     // Deal with the controls finally
1043     // ------------------------------
1044
1045     // adjust the controls size to fit nicely in the toolbar
1046     int y = 0;
1047     size_t index = 0;
1048     for ( node = m_tools.GetFirst(); node; node = node->GetNext(), index++ )
1049     {
1050         wxToolBarTool *tool = (wxToolBarTool*)node->GetData();
1051
1052         // we calculate the running y coord for vertical toolbars so we need to
1053         // get the items size for all items but for the horizontal ones we
1054         // don't need to deal with the non controls
1055         bool isControl = tool->IsControl();
1056         if ( !isControl && !IsVertical() )
1057             continue;
1058
1059         const RECT r = wxGetTBItemRect(GetHwnd(), index);
1060         if ( !isControl )
1061         {
1062             // can only be control if isVertical
1063             y += r.bottom - r.top;
1064
1065             continue;
1066         }
1067
1068         wxControl *control = tool->GetControl();
1069         wxStaticText * const staticText = tool->GetStaticText();
1070
1071         wxSize size = control->GetSize();
1072         wxSize staticTextSize;
1073         if ( staticText )
1074         {
1075             staticTextSize = staticText->GetSize();
1076             staticTextSize.y += 3; // margin between control and its label
1077         }
1078
1079         // the position of the leftmost controls corner
1080         int left = wxDefaultCoord;
1081
1082         // TB_SETBUTTONINFO message is only supported by comctl32.dll 4.71+
1083 #ifdef TB_SETBUTTONINFO
1084         // available in headers, now check whether it is available now
1085         // (during run-time)
1086         if ( wxApp::GetComCtl32Version() >= 471 )
1087         {
1088             // set the (underlying) separators width to be that of the
1089             // control
1090             TBBUTTONINFO tbbi;
1091             tbbi.cbSize = sizeof(tbbi);
1092             tbbi.dwMask = TBIF_SIZE;
1093             tbbi.cx = (WORD)size.x;
1094             if ( !::SendMessage(GetHwnd(), TB_SETBUTTONINFO,
1095                                 tool->GetId(), (LPARAM)&tbbi) )
1096             {
1097                 // the id is probably invalid?
1098                 wxLogLastError(wxT("TB_SETBUTTONINFO"));
1099             }
1100         }
1101         else
1102 #endif // comctl32.dll 4.71
1103         // TB_SETBUTTONINFO unavailable
1104         {
1105             // try adding several separators to fit the controls width
1106             int widthSep = r.right - r.left;
1107             left = r.left;
1108
1109             TBBUTTON tbb;
1110             wxZeroMemory(tbb);
1111             tbb.idCommand = 0;
1112             tbb.fsState = TBSTATE_ENABLED;
1113             tbb.fsStyle = TBSTYLE_SEP;
1114
1115             size_t nSeparators = size.x / widthSep;
1116             for ( size_t nSep = 0; nSep < nSeparators; nSep++ )
1117             {
1118                 if ( !::SendMessage(GetHwnd(), TB_INSERTBUTTON,
1119                                     index, (LPARAM)&tbb) )
1120                 {
1121                     wxLogLastError(wxT("TB_INSERTBUTTON"));
1122                 }
1123
1124                 index++;
1125             }
1126
1127             // remember the number of separators we used - we'd have to
1128             // delete all of them later
1129             ((wxToolBarTool *)tool)->SetSeparatorsCount(nSeparators);
1130
1131             // adjust the controls width to exactly cover the separators
1132             size.x = (nSeparators + 1)*widthSep;
1133             control->SetSize(size.x, wxDefaultCoord);
1134         }
1135
1136         // position the control itself correctly vertically centering it on the
1137         // icon area of the toolbar
1138         int height = r.bottom - r.top - staticTextSize.y;
1139
1140         int diff = height - size.y;
1141         if ( diff < 0 || !HasFlag(wxTB_TEXT) )
1142         {
1143             // not enough room for the static text
1144             if ( staticText )
1145                 staticText->Hide();
1146
1147             // recalculate height & diff without the staticText control
1148             height = r.bottom - r.top;
1149             diff = height - size.y;
1150             if ( diff < 0 )
1151             {
1152                 // the control is too high, resize to fit
1153                 control->SetSize(wxDefaultCoord, height - 2);
1154
1155                 diff = 2;
1156             }
1157         }
1158         else // enough space for both the control and the label
1159         {
1160             if ( staticText )
1161                 staticText->Show();
1162         }
1163
1164         int top;
1165         if ( IsVertical() )
1166         {
1167             left = 0;
1168             top = y;
1169
1170             y += height + 2 * GetMargins().y;
1171         }
1172         else // horizontal toolbar
1173         {
1174             if ( left == wxDefaultCoord )
1175                 left = r.left;
1176
1177             top = r.top;
1178         }
1179
1180         control->Move(left, top + (diff + 1) / 2);
1181         if ( staticText )
1182         {
1183             staticText->Move(left + (size.x - staticTextSize.x)/2,
1184                              r.bottom - staticTextSize.y);
1185         }
1186     }
1187
1188     // the max index is the "real" number of buttons - i.e. counting even the
1189     // separators which we added just for aligning the controls
1190     m_nButtons = index;
1191
1192     if ( !IsVertical() )
1193     {
1194         if ( m_maxRows == 0 )
1195             // if not set yet, only one row
1196             SetRows(1);
1197     }
1198     else if ( m_nButtons > 0 ) // vertical non empty toolbar
1199     {
1200         // if not set yet, have one column
1201         m_maxRows = 1;
1202         SetRows(m_nButtons);
1203     }
1204
1205     InvalidateBestSize();
1206     UpdateSize();
1207
1208     return true;
1209 }
1210
1211 // ----------------------------------------------------------------------------
1212 // message handlers
1213 // ----------------------------------------------------------------------------
1214
1215 bool wxToolBar::MSWCommand(WXUINT WXUNUSED(cmd), WXWORD id_)
1216 {
1217     // cast to signed is important as we compare this id with (signed) ints in
1218     // FindById() and without the cast we'd get a positive int from a
1219     // "negative" (i.e. > 32767) WORD
1220     const int id = (signed short)id_;
1221
1222     wxToolBarToolBase *tool = FindById(id);
1223     if ( !tool )
1224         return false;
1225
1226     bool toggled = false; // just to suppress warnings
1227
1228     LRESULT state = ::SendMessage(GetHwnd(), TB_GETSTATE, id, 0);
1229
1230     if ( tool->CanBeToggled() )
1231     {
1232         toggled = (state & TBSTATE_CHECKED) != 0;
1233
1234         // ignore the event when a radio button is released, as this doesn't
1235         // seem to happen at all, and is handled otherwise
1236         if ( tool->GetKind() == wxITEM_RADIO && !toggled )
1237             return true;
1238
1239         tool->Toggle(toggled);
1240         UnToggleRadioGroup(tool);
1241     }
1242
1243     // Without the two lines of code below, if the toolbar was repainted during
1244     // OnLeftClick(), then it could end up without the tool bitmap temporarily
1245     // (see http://lists.nongnu.org/archive/html/lmi/2008-10/msg00014.html).
1246     // The Update() call bellow ensures that this won't happen, by repainting
1247     // invalidated areas of the toolbar immediately.
1248     //
1249     // To complicate matters, the tool would be drawn in depressed state (this
1250     // code is called when mouse button is released, not pressed). That's not
1251     // ideal, having the tool pressed for the duration of OnLeftClick()
1252     // provides the user with useful visual clue that the app is busy reacting
1253     // to the event. So we manually put the tool into pressed state, handle the
1254     // event and then finally restore tool's original state.
1255     ::SendMessage(GetHwnd(), TB_SETSTATE, id, MAKELONG(state | TBSTATE_PRESSED, 0));
1256     Update();
1257
1258     bool allowLeftClick = OnLeftClick(id, toggled);
1259
1260     // Restore the unpressed state. Enabled/toggled state might have been
1261     // changed since so take care of it.
1262     if (tool->IsEnabled())
1263         state |= TBSTATE_ENABLED;
1264     else
1265         state &= ~TBSTATE_ENABLED;
1266     if (tool->IsToggled())
1267         state |= TBSTATE_CHECKED;
1268     else
1269         state &= ~TBSTATE_CHECKED;
1270     ::SendMessage(GetHwnd(), TB_SETSTATE, id, MAKELONG(state, 0));
1271
1272     // OnLeftClick() can veto the button state change - for buttons which
1273     // may be toggled only, of couse
1274     if ( !allowLeftClick && tool->CanBeToggled() )
1275     {
1276         // revert back
1277         tool->Toggle(!toggled);
1278
1279         ::SendMessage(GetHwnd(), TB_CHECKBUTTON, id, MAKELONG(!toggled, 0));
1280     }
1281
1282     return true;
1283 }
1284
1285 bool wxToolBar::MSWOnNotify(int WXUNUSED(idCtrl),
1286                             WXLPARAM lParam,
1287                             WXLPARAM *WXUNUSED(result))
1288 {
1289     LPNMHDR hdr = (LPNMHDR)lParam;
1290     if ( hdr->code == TBN_DROPDOWN )
1291     {
1292         LPNMTOOLBAR tbhdr = (LPNMTOOLBAR)lParam;
1293
1294         wxCommandEvent evt(wxEVT_COMMAND_TOOL_DROPDOWN_CLICKED, tbhdr->iItem);
1295         if ( HandleWindowEvent(evt) )
1296         {
1297             // Event got handled, don't display default popup menu
1298             return false;
1299         }
1300
1301         const wxToolBarToolBase * const tool = FindById(tbhdr->iItem);
1302         wxCHECK_MSG( tool, false, _T("drop down message for unknown tool") );
1303
1304         wxMenu * const menu = tool->GetDropdownMenu();
1305         if ( !menu )
1306             return false;
1307
1308         // Display popup menu below button
1309         const RECT r = wxGetTBItemRect(GetHwnd(), GetToolPos(tbhdr->iItem));
1310         if ( r.right )
1311             PopupMenu(menu, r.left, r.bottom);
1312
1313         return true;
1314     }
1315
1316
1317     if( !HasFlag(wxTB_NO_TOOLTIPS) )
1318     {
1319 #if wxUSE_TOOLTIPS
1320         // First check if this applies to us
1321
1322         // the tooltips control created by the toolbar is sometimes Unicode, even
1323         // in an ANSI application - this seems to be a bug in comctl32.dll v5
1324         UINT code = hdr->code;
1325         if ( (code != (UINT) TTN_NEEDTEXTA) && (code != (UINT) TTN_NEEDTEXTW) )
1326             return false;
1327
1328         HWND toolTipWnd = (HWND)::SendMessage(GetHwnd(), TB_GETTOOLTIPS, 0, 0);
1329         if ( toolTipWnd != hdr->hwndFrom )
1330             return false;
1331
1332         LPTOOLTIPTEXT ttText = (LPTOOLTIPTEXT)lParam;
1333         int id = (int)ttText->hdr.idFrom;
1334
1335         wxToolBarToolBase *tool = FindById(id);
1336         if ( tool )
1337             return HandleTooltipNotify(code, lParam, tool->GetShortHelp());
1338 #else
1339         wxUnusedVar(lParam);
1340 #endif
1341     }
1342
1343     return false;
1344 }
1345
1346 // ----------------------------------------------------------------------------
1347 // toolbar geometry
1348 // ----------------------------------------------------------------------------
1349
1350 void wxToolBar::SetToolBitmapSize(const wxSize& size)
1351 {
1352     wxToolBarBase::SetToolBitmapSize(size);
1353
1354     ::SendMessage(GetHwnd(), TB_SETBITMAPSIZE, 0, MAKELONG(size.x, size.y));
1355 }
1356
1357 void wxToolBar::SetRows(int nRows)
1358 {
1359     if ( nRows == m_maxRows )
1360     {
1361         // avoid resizing the frame uselessly
1362         return;
1363     }
1364
1365     // TRUE in wParam means to create at least as many rows, FALSE -
1366     // at most as many
1367     RECT rect;
1368     ::SendMessage(GetHwnd(), TB_SETROWS,
1369                   MAKEWPARAM(nRows, !(GetWindowStyle() & wxTB_VERTICAL)),
1370                   (LPARAM) &rect);
1371
1372     m_maxRows = nRows;
1373
1374     UpdateSize();
1375 }
1376
1377 // The button size is bigger than the bitmap size
1378 wxSize wxToolBar::GetToolSize() const
1379 {
1380     // TB_GETBUTTONSIZE is supported from version 4.70
1381 #if defined(_WIN32_IE) && (_WIN32_IE >= 0x300 ) \
1382     && !( defined(__GNUWIN32__) && !wxCHECK_W32API_VERSION( 1, 0 ) ) \
1383     && !defined (__DIGITALMARS__)
1384     if ( wxApp::GetComCtl32Version() >= 470 )
1385     {
1386         DWORD dw = ::SendMessage(GetHwnd(), TB_GETBUTTONSIZE, 0, 0);
1387
1388         return wxSize(LOWORD(dw), HIWORD(dw));
1389     }
1390     else
1391 #endif // comctl32.dll 4.70+
1392     {
1393         // defaults
1394         return wxSize(m_defaultWidth + 8, m_defaultHeight + 7);
1395     }
1396 }
1397
1398 static
1399 wxToolBarToolBase *GetItemSkippingDummySpacers(const wxToolBarToolsList& tools,
1400                                                size_t index )
1401 {
1402     wxToolBarToolsList::compatibility_iterator current = tools.GetFirst();
1403
1404     for ( ; current ; current = current->GetNext() )
1405     {
1406         if ( index == 0 )
1407             return current->GetData();
1408
1409         wxToolBarTool *tool = (wxToolBarTool *)current->GetData();
1410         size_t separators = tool->GetSeparatorsCount();
1411
1412         // if it is a normal button, sepcount == 0, so skip 1 item (the button)
1413         // otherwise, skip as many items as the separator count, plus the
1414         // control itself
1415         index -= separators ? separators + 1 : 1;
1416     }
1417
1418     return 0;
1419 }
1420
1421 wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord x, wxCoord y) const
1422 {
1423     POINT pt;
1424     pt.x = x;
1425     pt.y = y;
1426     int index = (int)::SendMessage(GetHwnd(), TB_HITTEST, 0, (LPARAM)&pt);
1427
1428     // MBN: when the point ( x, y ) is close to the toolbar border
1429     //      TB_HITTEST returns m_nButtons ( not -1 )
1430     if ( index < 0 || (size_t)index >= m_nButtons )
1431         // it's a separator or there is no tool at all there
1432         return NULL;
1433
1434     // when TB_SETBUTTONINFO is available (both during compile- and run-time),
1435     // we don't use the dummy separators hack
1436 #ifdef TB_SETBUTTONINFO
1437     if ( wxApp::GetComCtl32Version() >= 471 )
1438     {
1439         return m_tools.Item((size_t)index)->GetData();
1440     }
1441     else
1442 #endif // TB_SETBUTTONINFO
1443     {
1444         return GetItemSkippingDummySpacers( m_tools, (size_t) index );
1445     }
1446 }
1447
1448 void wxToolBar::UpdateSize()
1449 {
1450     wxPoint pos = GetPosition();
1451     ::SendMessage(GetHwnd(), TB_AUTOSIZE, 0, 0);
1452     if (pos != GetPosition())
1453         Move(pos);
1454
1455     // In case Realize is called after the initial display (IOW the programmer
1456     // may have rebuilt the toolbar) give the frame the option of resizing the
1457     // toolbar to full width again, but only if the parent is a frame and the
1458     // toolbar is managed by the frame.  Otherwise assume that some other
1459     // layout mechanism is controlling the toolbar size and leave it alone.
1460     SendSizeEventToParent();
1461 }
1462
1463 // ----------------------------------------------------------------------------
1464 // toolbar styles
1465 // ---------------------------------------------------------------------------
1466
1467 // get the TBSTYLE of the given toolbar window
1468 long wxToolBar::GetMSWToolbarStyle() const
1469 {
1470     return ::SendMessage(GetHwnd(), TB_GETSTYLE, 0, 0L);
1471 }
1472
1473 void wxToolBar::SetWindowStyleFlag(long style)
1474 {
1475     // the style bits whose changes force us to recreate the toolbar
1476     static const long MASK_NEEDS_RECREATE = wxTB_TEXT | wxTB_NOICONS;
1477
1478     const long styleOld = GetWindowStyle();
1479
1480     wxToolBarBase::SetWindowStyleFlag(style);
1481
1482     // don't recreate an empty toolbar: not only this is unnecessary, but it is
1483     // also fatal as we'd then try to recreate the toolbar when it's just being
1484     // created
1485     if ( GetToolsCount() &&
1486             (style & MASK_NEEDS_RECREATE) != (styleOld & MASK_NEEDS_RECREATE) )
1487     {
1488         // to remove the text labels, simply re-realizing the toolbar is enough
1489         // but I don't know of any way to add the text to an existing toolbar
1490         // other than by recreating it entirely
1491         Recreate();
1492     }
1493 }
1494
1495 // ----------------------------------------------------------------------------
1496 // tool state
1497 // ----------------------------------------------------------------------------
1498
1499 void wxToolBar::DoEnableTool(wxToolBarToolBase *tool, bool enable)
1500 {
1501     ::SendMessage(GetHwnd(), TB_ENABLEBUTTON,
1502                   (WPARAM)tool->GetId(), (LPARAM)MAKELONG(enable, 0));
1503 }
1504
1505 void wxToolBar::DoToggleTool(wxToolBarToolBase *tool, bool toggle)
1506 {
1507     ::SendMessage(GetHwnd(), TB_CHECKBUTTON,
1508                   (WPARAM)tool->GetId(), (LPARAM)MAKELONG(toggle, 0));
1509 }
1510
1511 void wxToolBar::DoSetToggle(wxToolBarToolBase *WXUNUSED(tool), bool WXUNUSED(toggle))
1512 {
1513     // VZ: AFAIK, the button has to be created either with TBSTYLE_CHECK or
1514     //     without, so we really need to delete the button and recreate it here
1515     wxFAIL_MSG( _T("not implemented") );
1516 }
1517
1518 void wxToolBar::SetToolNormalBitmap( int id, const wxBitmap& bitmap )
1519 {
1520     wxToolBarTool* tool = static_cast<wxToolBarTool*>(FindById(id));
1521     if ( tool )
1522     {
1523         wxCHECK_RET( tool->IsButton(), wxT("Can only set bitmap on button tools."));
1524
1525         tool->SetNormalBitmap(bitmap);
1526         Realize();
1527     }
1528 }
1529
1530 void wxToolBar::SetToolDisabledBitmap( int id, const wxBitmap& bitmap )
1531 {
1532     wxToolBarTool* tool = static_cast<wxToolBarTool*>(FindById(id));
1533     if ( tool )
1534     {
1535         wxCHECK_RET( tool->IsButton(), wxT("Can only set bitmap on button tools."));
1536
1537         tool->SetDisabledBitmap(bitmap);
1538         Realize();
1539     }
1540 }
1541
1542 // ----------------------------------------------------------------------------
1543 // event handlers
1544 // ----------------------------------------------------------------------------
1545
1546 // Responds to colour changes, and passes event on to children.
1547 void wxToolBar::OnSysColourChanged(wxSysColourChangedEvent& event)
1548 {
1549     wxRGBToColour(m_backgroundColour, ::GetSysColor(COLOR_BTNFACE));
1550
1551     // Remap the buttons
1552     Realize();
1553
1554     // Relayout the toolbar
1555     int nrows = m_maxRows;
1556     m_maxRows = 0;      // otherwise SetRows() wouldn't do anything
1557     SetRows(nrows);
1558
1559     Refresh();
1560
1561     // let the event propagate further
1562     event.Skip();
1563 }
1564
1565 void wxToolBar::OnMouseEvent(wxMouseEvent& event)
1566 {
1567     if ( event.Leaving() )
1568     {
1569         if ( m_pInTool )
1570         {
1571             OnMouseEnter(wxID_ANY);
1572             m_pInTool = NULL;
1573         }
1574
1575         event.Skip();
1576         return;
1577     }
1578
1579     if ( event.RightDown() )
1580     {
1581         // find the tool under the mouse
1582         wxCoord x = 0, y = 0;
1583         event.GetPosition(&x, &y);
1584
1585         wxToolBarToolBase *tool = FindToolForPosition(x, y);
1586         OnRightClick(tool ? tool->GetId() : -1, x, y);
1587     }
1588     else
1589     {
1590         event.Skip();
1591     }
1592 }
1593
1594 // This handler is required to allow the toolbar to be set to a non-default
1595 // colour: for example, when it must blend in with a notebook page.
1596 void wxToolBar::OnEraseBackground(wxEraseEvent& event)
1597 {
1598     RECT rect = wxGetClientRect(GetHwnd());
1599
1600     wxDC *dc = event.GetDC();
1601     if (!dc) return;
1602     wxMSWDCImpl *impl = (wxMSWDCImpl*) dc->GetImpl();
1603     HDC hdc = GetHdcOf(*impl);
1604
1605     int majorVersion, minorVersion;
1606     wxGetOsVersion(& majorVersion, & minorVersion);
1607
1608 #if wxUSE_UXTHEME
1609     // we may need to draw themed colour so that we appear correctly on
1610     // e.g. notebook page under XP with themes but only do it if the parent
1611     // draws themed background itself
1612     if ( !UseBgCol() && !GetParent()->UseBgCol() )
1613     {
1614         wxUxThemeEngine *theme = wxUxThemeEngine::GetIfActive();
1615         if ( theme )
1616         {
1617             HRESULT
1618                 hr = theme->DrawThemeParentBackground(GetHwnd(), hdc, &rect);
1619             if ( hr == S_OK )
1620                 return;
1621
1622             // it can also return S_FALSE which seems to simply say that it
1623             // didn't draw anything but no error really occurred
1624             if ( FAILED(hr) )
1625                 wxLogApiError(_T("DrawThemeParentBackground(toolbar)"), hr);
1626         }
1627     }
1628
1629     // Only draw a rebar theme on Vista, since it doesn't jive so well with XP
1630     if ( !UseBgCol() && majorVersion >= 6 )
1631     {
1632         wxUxThemeEngine *theme = wxUxThemeEngine::GetIfActive();
1633         if ( theme )
1634         {
1635             wxUxThemeHandle hTheme(this, L"REBAR");
1636
1637             RECT r;
1638             wxRect rect = GetClientRect();
1639             wxCopyRectToRECT(rect, r);
1640
1641             HRESULT hr = theme->DrawThemeBackground(hTheme, hdc, 0, 0, & r, NULL);
1642             if ( hr == S_OK )
1643                 return;
1644
1645             // it can also return S_FALSE which seems to simply say that it
1646             // didn't draw anything but no error really occurred
1647             if ( FAILED(hr) )
1648                 wxLogApiError(_T("DrawThemeParentBackground(toolbar)"), hr);
1649         }
1650     }
1651
1652 #endif // wxUSE_UXTHEME
1653
1654     // we need to always draw our background under XP, as otherwise it doesn't
1655     // appear correctly with some themes (e.g. Zune one)
1656     if ( majorVersion == 5 ||
1657             UseBgCol() || (GetMSWToolbarStyle() & TBSTYLE_TRANSPARENT) )
1658     {
1659         // do draw our background
1660         //
1661         // notice that this 'dumb' implementation may cause flicker for some of
1662         // the controls in which case they should intercept wxEraseEvent and
1663         // process it themselves somehow
1664         AutoHBRUSH hBrush(wxColourToRGB(GetBackgroundColour()));
1665
1666         wxCHANGE_HDC_MAP_MODE(hdc, MM_TEXT);
1667         ::FillRect(hdc, &rect, hBrush);
1668     }
1669     else // we have no non default background colour
1670     {
1671         // let the system do it for us
1672         event.Skip();
1673     }
1674 }
1675
1676 bool wxToolBar::HandleSize(WXWPARAM WXUNUSED(wParam), WXLPARAM lParam)
1677 {
1678     // wait until we have some tools
1679     if ( !GetToolsCount() )
1680         return false;
1681
1682     // calculate our minor dimension ourselves - we're confusing the standard
1683     // logic (TB_AUTOSIZE) with our horizontal toolbars and other hacks
1684     const RECT r = wxGetTBItemRect(GetHwnd(), 0);
1685     if ( !r.right )
1686         return false;
1687
1688     int w, h;
1689
1690     if ( IsVertical() )
1691     {
1692         w = r.right - r.left;
1693         if ( m_maxRows )
1694         {
1695             w *= (m_nButtons + m_maxRows - 1)/m_maxRows;
1696         }
1697         h = HIWORD(lParam);
1698     }
1699     else
1700     {
1701         w = LOWORD(lParam);
1702         if (HasFlag( wxTB_FLAT ))
1703             h = r.bottom - r.top - 3;
1704         else
1705             h = r.bottom - r.top;
1706         if ( m_maxRows )
1707         {
1708             // FIXME: hardcoded separator line height...
1709             h += HasFlag(wxTB_NODIVIDER) ? 4 : 6;
1710             h *= m_maxRows;
1711         }
1712     }
1713
1714     if ( MAKELPARAM(w, h) != lParam )
1715     {
1716         // size really changed
1717         SetSize(w, h);
1718     }
1719
1720     // message processed
1721     return true;
1722 }
1723
1724 bool wxToolBar::HandlePaint(WXWPARAM wParam, WXLPARAM lParam)
1725 {
1726     // erase any dummy separators which were used
1727     // for aligning the controls if any here
1728
1729     // first of all, are there any controls at all?
1730     wxToolBarToolsList::compatibility_iterator node;
1731     for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
1732     {
1733         if ( node->GetData()->IsControl() )
1734             break;
1735     }
1736
1737     if ( !node )
1738         // no controls, nothing to erase
1739         return false;
1740
1741     wxSize clientSize = GetClientSize();
1742     int majorVersion, minorVersion;
1743     wxGetOsVersion(& majorVersion, & minorVersion);
1744
1745     // prepare the DC on which we'll be drawing
1746     wxClientDC dc(this);
1747     dc.SetBrush(wxBrush(GetBackgroundColour(), wxSOLID));
1748     dc.SetPen(*wxTRANSPARENT_PEN);
1749
1750     RECT r;
1751     if ( !::GetUpdateRect(GetHwnd(), &r, FALSE) )
1752         // nothing to redraw anyhow
1753         return false;
1754
1755     wxRect rectUpdate;
1756     wxCopyRECTToRect(r, rectUpdate);
1757
1758     dc.SetClippingRegion(rectUpdate);
1759
1760     // draw the toolbar tools, separators &c normally
1761     wxControl::MSWWindowProc(WM_PAINT, wParam, lParam);
1762
1763     // for each control in the toolbar find all the separators intersecting it
1764     // and erase them
1765     //
1766     // NB: this is really the only way to do it as we don't know if a separator
1767     //     corresponds to a control (i.e. is a dummy one) or a real one
1768     //     otherwise
1769     for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
1770     {
1771         wxToolBarTool *tool = (wxToolBarTool*)node->GetData();
1772         if ( tool->IsControl() )
1773         {
1774             // get the control rect in our client coords
1775             wxControl *control = tool->GetControl();
1776             wxStaticText *staticText = tool->GetStaticText();
1777             wxRect rectCtrl = control->GetRect();
1778             wxRect rectStaticText(0,0,0,0);
1779             if ( staticText )
1780             {
1781                 rectStaticText = staticText->GetRect();
1782             }
1783
1784             // iterate over all buttons
1785             TBBUTTON tbb;
1786             int count = ::SendMessage(GetHwnd(), TB_BUTTONCOUNT, 0, 0);
1787             for ( int n = 0; n < count; n++ )
1788             {
1789                 // is it a separator?
1790                 if ( !::SendMessage(GetHwnd(), TB_GETBUTTON,
1791                                     n, (LPARAM)&tbb) )
1792                 {
1793                     wxLogDebug(_T("TB_GETBUTTON failed?"));
1794
1795                     continue;
1796                 }
1797
1798                 if ( tbb.fsStyle != TBSTYLE_SEP )
1799                     continue;
1800
1801                 // get the bounding rect of the separator
1802                 RECT r = wxGetTBItemRect(GetHwnd(), n);
1803                 if ( !r.right )
1804                     continue;
1805
1806                 // does it intersect the control?
1807                 wxRect rectItem;
1808                 wxCopyRECTToRect(r, rectItem);
1809                 if ( rectCtrl.Intersects(rectItem) || (staticText && rectStaticText.Intersects(rectItem)))
1810                 {
1811                     // yes, do erase it!
1812
1813                     bool haveRefreshed = false;
1814
1815 #if wxUSE_UXTHEME
1816                     if ( !UseBgCol() && !GetParent()->UseBgCol() )
1817                     {
1818                         // Don't use DrawThemeBackground
1819                     }
1820                     else if ( !UseBgCol() && majorVersion >= 6 )
1821                     {
1822                         wxUxThemeEngine *theme = wxUxThemeEngine::GetIfActive();
1823                         if ( theme )
1824                         {
1825                             wxUxThemeHandle hTheme(this, L"REBAR");
1826
1827                             RECT clipRect = r;
1828
1829                             // Draw the whole background since the pattern may be position sensitive;
1830                             // but clip it to the area of interest.
1831                             r.left = 0;
1832                             r.right = clientSize.x;
1833                             r.top = 0;
1834                             r.bottom = clientSize.y;
1835
1836                             wxMSWDCImpl *impl = (wxMSWDCImpl*) dc.GetImpl();
1837                             HRESULT hr = theme->DrawThemeBackground(hTheme, GetHdcOf(*impl), 0, 0, & r, & clipRect);
1838                             if ( hr == S_OK )
1839                                 haveRefreshed = true;
1840                         }
1841                     }
1842 #endif
1843
1844                     if (!haveRefreshed)
1845                         dc.DrawRectangle(rectItem);
1846                 }
1847
1848                 if ( rectCtrl.Intersects(rectItem) )
1849                 {
1850                     // Necessary in case we use a no-paint-on-size
1851                     // style in the parent: the controls can disappear
1852                     control->Refresh(false);
1853                 }
1854
1855                 if ( staticText && rectStaticText.Intersects(rectItem) )
1856                 {
1857                     // Necessary in case we use a no-paint-on-size
1858                     // style in the parent: the controls can disappear
1859                     staticText->Refresh(false);
1860                 }
1861             }
1862         }
1863     }
1864
1865     return true;
1866 }
1867
1868 void wxToolBar::HandleMouseMove(WXWPARAM WXUNUSED(wParam), WXLPARAM lParam)
1869 {
1870     wxCoord x = GET_X_LPARAM(lParam),
1871             y = GET_Y_LPARAM(lParam);
1872     wxToolBarToolBase* tool = FindToolForPosition( x, y );
1873
1874     // has the current tool changed?
1875     if ( tool != m_pInTool )
1876     {
1877         m_pInTool = tool;
1878         OnMouseEnter(tool ? tool->GetId() : wxID_ANY);
1879     }
1880 }
1881
1882 WXLRESULT wxToolBar::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
1883 {
1884     switch ( nMsg )
1885     {
1886         case WM_MOUSEMOVE:
1887             // we don't handle mouse moves, so always pass the message to
1888             // wxControl::MSWWindowProc (HandleMouseMove just calls OnMouseEnter)
1889             HandleMouseMove(wParam, lParam);
1890             break;
1891
1892         case WM_SIZE:
1893             if ( HandleSize(wParam, lParam) )
1894                 return 0;
1895             break;
1896
1897 #ifndef __WXWINCE__
1898         case WM_PAINT:
1899             // refreshing the controls in the toolbar inside a composite window
1900             // results in an endless stream of WM_PAINT messages -- and seems
1901             // to be unnecessary anyhow as everything works just fine without
1902             // any special workarounds in this case
1903             if ( !IsDoubleBuffered() && HandlePaint(wParam, lParam) )
1904                 return 0;
1905             break;
1906 #endif // __WXWINCE__
1907     }
1908
1909     return wxControl::MSWWindowProc(nMsg, wParam, lParam);
1910 }
1911
1912 // ----------------------------------------------------------------------------
1913 // private functions
1914 // ----------------------------------------------------------------------------
1915
1916 #ifdef wxREMAP_BUTTON_COLOURS
1917
1918 WXHBITMAP wxToolBar::MapBitmap(WXHBITMAP bitmap, int width, int height)
1919 {
1920     MemoryHDC hdcMem;
1921
1922     if ( !hdcMem )
1923     {
1924         wxLogLastError(_T("CreateCompatibleDC"));
1925
1926         return bitmap;
1927     }
1928
1929     SelectInHDC bmpInHDC(hdcMem, (HBITMAP)bitmap);
1930
1931     if ( !bmpInHDC )
1932     {
1933         wxLogLastError(_T("SelectObject"));
1934
1935         return bitmap;
1936     }
1937
1938     wxCOLORMAP *cmap = wxGetStdColourMap();
1939
1940     for ( int i = 0; i < width; i++ )
1941     {
1942         for ( int j = 0; j < height; j++ )
1943         {
1944             COLORREF pixel = ::GetPixel(hdcMem, i, j);
1945
1946             for ( size_t k = 0; k < wxSTD_COL_MAX; k++ )
1947             {
1948                 COLORREF col = cmap[k].from;
1949                 if ( abs(GetRValue(pixel) - GetRValue(col)) < 10 &&
1950                      abs(GetGValue(pixel) - GetGValue(col)) < 10 &&
1951                      abs(GetBValue(pixel) - GetBValue(col)) < 10 )
1952                 {
1953                     if ( cmap[k].to != pixel )
1954                         ::SetPixel(hdcMem, i, j, cmap[k].to);
1955                     break;
1956                 }
1957             }
1958         }
1959     }
1960
1961     return bitmap;
1962 }
1963
1964 #endif // wxREMAP_BUTTON_COLOURS
1965
1966 #endif // wxUSE_TOOLBAR