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