src/msw/tbar95.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        msw/tbar95.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 #ifdef __GNUG__
  21     #pragma implementation "tbar95.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/frame.h"
  33     #include "wx/log.h"
  34     #include "wx/intl.h"
  35     #include "wx/dynarray.h"
  36     #include "wx/settings.h"
  37     #include "wx/bitmap.h"
  38     #include "wx/dcmemory.h"
  39     #include "wx/control.h"
  40 #endif
  41
  42 #if wxUSE_TOOLBAR && defined(__WIN95__) && wxUSE_TOOLBAR_NATIVE
  43
  44 #include "wx/toolbar.h"
  45
  46 #if !defined(__GNUWIN32__) && !defined(__SALFORDC__)
  47     #include "malloc.h"
  48 #endif
  49
  50 #include "wx/msw/private.h"
  51
  52 #if defined(__WIN95__) && !(defined(__GNUWIN32_OLD__) && !defined(__CYGWIN10__))
  53     #include <commctrl.h>
  54 #else
  55     #include "wx/msw/gnuwin32/extra.h"
  56 #endif
  57
  58 #include "wx/app.h"         // for GetComCtl32Version
  59
  60 #if defined(__MWERKS__) && defined(__WXMSW__)
  61 // including <windef.h> for max definition doesn't seem
  62 // to work using CodeWarrior 6 Windows. So we define it
  63 // here. (Otherwise we get a undefined identifier 'max'
  64 // later on in this file.) (Added by dimitri@shortcut.nl)
  65 #   ifndef max
  66 #       define max(a,b)            (((a) > (b)) ? (a) : (b))
  67 #   endif
  68
  69 #endif
  70
  71 // ----------------------------------------------------------------------------
  72 // conditional compilation
  73 // ----------------------------------------------------------------------------
  74
  75 // wxWindows previously always considered that toolbar buttons have light grey
  76 // (0xc0c0c0) background and so ignored any bitmap masks - however, this
  77 // doesn't work with XPMs which then appear to have black background. To make
  78 // this work, we must respect the bitmap masks - which we do now. This should
  79 // be ok in any case, but to restore 100% compatible with the old version
  80 // behaviour, you can set this to 0.
  81 #define USE_BITMAP_MASKS 1
  82
  83 // ----------------------------------------------------------------------------
  84 // constants
  85 // ----------------------------------------------------------------------------
  86
  87 // these standard constants are not always defined in compilers headers
  88
  89 // Styles
  90 #ifndef TBSTYLE_FLAT
  91     #define TBSTYLE_LIST            0x1000
  92     #define TBSTYLE_FLAT            0x0800
  93 #endif
  94
  95 #ifndef TBSTYLE_TRANSPARENT
  96     #define TBSTYLE_TRANSPARENT     0x8000
  97 #endif
  98
  99 #ifndef TBSTYLE_TOOLTIPS
 100     #define TBSTYLE_TOOLTIPS        0x0100
 101 #endif
 102
 103 // Messages
 104 #ifndef TB_GETSTYLE
 105     #define TB_SETSTYLE             (WM_USER + 56)
 106     #define TB_GETSTYLE             (WM_USER + 57)
 107 #endif
 108
 109 #ifndef TB_HITTEST
 110     #define TB_HITTEST              (WM_USER + 69)
 111 #endif
 112
 113 // these values correspond to those used by comctl32.dll
 114 #define DEFAULTBITMAPX   16
 115 #define DEFAULTBITMAPY   15
 116 #define DEFAULTBUTTONX   24
 117 #define DEFAULTBUTTONY   24
 118 #define DEFAULTBARHEIGHT 27
 119
 120 // ----------------------------------------------------------------------------
 121 // wxWin macros
 122 // ----------------------------------------------------------------------------
 123
 124 IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxToolBarBase)
 125
 126 BEGIN_EVENT_TABLE(wxToolBar, wxToolBarBase)
 127     EVT_MOUSE_EVENTS(wxToolBar::OnMouseEvent)
 128     EVT_SYS_COLOUR_CHANGED(wxToolBar::OnSysColourChanged)
 129 END_EVENT_TABLE()
 130
 131 // ----------------------------------------------------------------------------
 132 // private classes
 133 // ----------------------------------------------------------------------------
 134
 135 class wxToolBarTool : public wxToolBarToolBase
 136 {
 137 public:
 138     wxToolBarTool(wxToolBar *tbar,
 139                   int id,
 140                   const wxString& label,
 141                   const wxBitmap& bmpNormal,
 142                   const wxBitmap& bmpDisabled,
 143                   wxItemKind kind,
 144                   wxObject *clientData,
 145                   const wxString& shortHelp,
 146                   const wxString& longHelp)
 147         : wxToolBarToolBase(tbar, id, label, bmpNormal, bmpDisabled, kind,
 148                             clientData, shortHelp, longHelp)
 149     {
 150         m_nSepCount = 0;
 151     }
 152
 153     wxToolBarTool(wxToolBar *tbar, wxControl *control)
 154         : wxToolBarToolBase(tbar, control)
 155     {
 156         m_nSepCount = 1;
 157     }
 158
 159     virtual void SetLabel(const wxString& label)
 160     {
 161         if ( label == m_label )
 162             return;
 163
 164         wxToolBarToolBase::SetLabel(label);
 165
 166         // we need to update the label shown in the toolbar because it has a
 167         // pointer to the internal buffer of the old label
 168         //
 169         // TODO: use TB_SETBUTTONINFO
 170     }
 171
 172     // set/get the number of separators which we use to cover the space used by
 173     // a control in the toolbar
 174     void SetSeparatorsCount(size_t count) { m_nSepCount = count; }
 175     size_t GetSeparatorsCount() const { return m_nSepCount; }
 176
 177 private:
 178     size_t m_nSepCount;
 179 };
 180
 181
 182 // ============================================================================
 183 // implementation
 184 // ============================================================================
 185
 186 // ----------------------------------------------------------------------------
 187 // wxToolBarTool
 188 // ----------------------------------------------------------------------------
 189
 190 wxToolBarToolBase *wxToolBar::CreateTool(int id,
 191                                          const wxString& label,
 192                                          const wxBitmap& bmpNormal,
 193                                          const wxBitmap& bmpDisabled,
 194                                          wxItemKind kind,
 195                                          wxObject *clientData,
 196                                          const wxString& shortHelp,
 197                                          const wxString& longHelp)
 198 {
 199     return new wxToolBarTool(this, id, label, bmpNormal, bmpDisabled, kind,
 200                              clientData, shortHelp, longHelp);
 201 }
 202
 203 wxToolBarToolBase *wxToolBar::CreateTool(wxControl *control)
 204 {
 205     return new wxToolBarTool(this, control);
 206 }
 207
 208 // ----------------------------------------------------------------------------
 209 // wxToolBar construction
 210 // ----------------------------------------------------------------------------
 211
 212 void wxToolBar::Init()
 213 {
 214     m_hBitmap = 0;
 215
 216     m_nButtons = 0;
 217
 218     m_defaultWidth = DEFAULTBITMAPX;
 219     m_defaultHeight = DEFAULTBITMAPY;
 220
 221     m_pInTool = 0;
 222 }
 223
 224 bool wxToolBar::Create(wxWindow *parent,
 225                        wxWindowID id,
 226                        const wxPoint& pos,
 227                        const wxSize& size,
 228                        long style,
 229                        const wxString& name)
 230 {
 231     // common initialisation
 232     if ( !CreateControl(parent, id, pos, size, style, wxDefaultValidator, name) )
 233         return FALSE;
 234
 235     // MSW-specific initialisation
 236     if ( !MSWCreateToolbar(pos, size) )
 237         return FALSE;
 238
 239     // set up the colors and fonts
 240     SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_MENUBAR));
 241     SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
 242
 243     return TRUE;
 244 }
 245
 246 bool wxToolBar::MSWCreateToolbar(const wxPoint& pos, const wxSize& size)
 247 {
 248     if ( !MSWCreateControl(TOOLBARCLASSNAME, _T(""), pos, size) )
 249         return FALSE;
 250
 251     // toolbar-specific post initialisation
 252     ::SendMessage(GetHwnd(), TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0);
 253
 254     return TRUE;
 255 }
 256
 257 void wxToolBar::Recreate()
 258 {
 259     const HWND hwndOld = GetHwnd();
 260     if ( !hwndOld )
 261     {
 262         // we haven't been created yet, no need to recreate
 263         return;
 264     }
 265
 266     // get the position and size before unsubclassing the old toolbar
 267     const wxPoint pos = GetPosition();
 268     const wxSize size = GetSize();
 269
 270     UnsubclassWin();
 271
 272     if ( !MSWCreateToolbar(pos, size) )
 273     {
 274         // what can we do?
 275         wxFAIL_MSG( _T("recreating the toolbar failed") );
 276
 277         return;
 278     }
 279
 280     // reparent all our children under the new toolbar
 281     for ( wxWindowList::Node *node = m_children.GetFirst();
 282           node;
 283           node = node->GetNext() )
 284     {
 285         wxWindow *win = node->GetData();
 286         if ( !win->IsTopLevel() )
 287             ::SetParent(GetHwndOf(win), GetHwnd());
 288     }
 289
 290     // only destroy the old toolbar now -- after all the children had been
 291     // reparented
 292     ::DestroyWindow(hwndOld);
 293
 294     // it is for the old bitmap control and can't be used with the new one
 295     if ( m_hBitmap )
 296     {
 297         ::DeleteObject((HBITMAP) m_hBitmap);
 298         m_hBitmap = 0;
 299     }
 300
 301     Realize();
 302     UpdateSize();
 303 }
 304
 305 wxToolBar::~wxToolBar()
 306 {
 307     // we must refresh the frame size when the toolbar is deleted but the frame
 308     // is not - otherwise toolbar leaves a hole in the place it used to occupy
 309     wxFrame *frame = wxDynamicCast(GetParent(), wxFrame);
 310     if ( frame && !frame->IsBeingDeleted() )
 311     {
 312         frame->SendSizeEvent();
 313     }
 314
 315     if ( m_hBitmap )
 316     {
 317         ::DeleteObject((HBITMAP) m_hBitmap);
 318     }
 319 }
 320
 321 wxSize wxToolBar::DoGetBestSize() const
 322 {
 323     wxSize sizeBest = GetToolSize();
 324     sizeBest.x *= GetToolsCount();
 325
 326     // reverse horz and vertical components if necessary
 327     return HasFlag(wxTB_VERTICAL) ? wxSize(sizeBest.y, sizeBest.x) : sizeBest;
 328 }
 329
 330 WXDWORD wxToolBar::MSWGetStyle(long style, WXDWORD *exstyle) const
 331 {
 332     // toolbars never have border, giving one to them results in broken
 333     // appearance
 334     WXDWORD msStyle = wxControl::MSWGetStyle
 335                       (
 336                         (style & ~wxBORDER_MASK) | wxBORDER_NONE, exstyle
 337                       );
 338
 339     // always include this one, it never hurts and setting it later only if we
 340     // do have tooltips wouldn't work
 341     msStyle |= TBSTYLE_TOOLTIPS;
 342
 343     if ( style & wxTB_FLAT )
 344     {
 345         // static as it doesn't change during the program lifetime
 346         static int s_verComCtl = wxTheApp->GetComCtl32Version();
 347
 348         // comctl32.dll 4.00 doesn't support the flat toolbars and using this
 349         // style with 6.00 (part of Windows XP) leads to the toolbar with
 350         // incorrect background colour - and not using it still results in the
 351         // correct (flat) toolbar, so don't use it there
 352         if ( s_verComCtl > 400 && s_verComCtl < 600 )
 353         {
 354             msStyle |= TBSTYLE_FLAT | TBSTYLE_TRANSPARENT;
 355         }
 356     }
 357
 358     if ( style & wxTB_NODIVIDER )
 359         msStyle |= CCS_NODIVIDER;
 360
 361     if ( style & wxTB_NOALIGN )
 362         msStyle |= CCS_NOPARENTALIGN;
 363
 364     return msStyle;
 365 }
 366
 367 // ----------------------------------------------------------------------------
 368 // adding/removing tools
 369 // ----------------------------------------------------------------------------
 370
 371 bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *tool)
 372 {
 373     // nothing special to do here - we really create the toolbar buttons in
 374     // Realize() later
 375     tool->Attach(this);
 376
 377     return TRUE;
 378 }
 379
 380 bool wxToolBar::DoDeleteTool(size_t pos, wxToolBarToolBase *tool)
 381 {
 382     // the main difficulty we have here is with the controls in the toolbars:
 383     // as we (sometimes) use several separators to cover up the space used by
 384     // them, the indices are not the same for us and the toolbar
 385
 386     // first determine the position of the first button to delete: it may be
 387     // different from pos if we use several separators to cover the space used
 388     // by a control
 389     wxToolBarToolsList::Node *node;
 390     for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
 391     {
 392         wxToolBarToolBase *tool2 = node->GetData();
 393         if ( tool2 == tool )
 394         {
 395             // let node point to the next node in the list
 396             node = node->GetNext();
 397
 398             break;
 399         }
 400
 401         if ( tool2->IsControl() )
 402         {
 403             pos += ((wxToolBarTool *)tool2)->GetSeparatorsCount() - 1;
 404         }
 405     }
 406
 407     // now determine the number of buttons to delete and the area taken by them
 408     size_t nButtonsToDelete = 1;
 409
 410     // get the size of the button we're going to delete
 411     RECT r;
 412     if ( !::SendMessage(GetHwnd(), TB_GETITEMRECT, pos, (LPARAM)&r) )
 413     {
 414         wxLogLastError(_T("TB_GETITEMRECT"));
 415     }
 416
 417     int width = r.right - r.left;
 418
 419     if ( tool->IsControl() )
 420     {
 421         nButtonsToDelete = ((wxToolBarTool *)tool)->GetSeparatorsCount();
 422
 423         width *= nButtonsToDelete;
 424     }
 425
 426     // do delete all buttons
 427     m_nButtons -= nButtonsToDelete;
 428     while ( nButtonsToDelete-- > 0 )
 429     {
 430         if ( !::SendMessage(GetHwnd(), TB_DELETEBUTTON, pos, 0) )
 431         {
 432             wxLogLastError(wxT("TB_DELETEBUTTON"));
 433
 434             return FALSE;
 435         }
 436     }
 437
 438     tool->Detach();
 439
 440     // and finally reposition all the controls after this button (the toolbar
 441     // takes care of all normal items)
 442     for ( /* node -> first after deleted */ ; node; node = node->GetNext() )
 443     {
 444         wxToolBarToolBase *tool2 = node->GetData();
 445         if ( tool2->IsControl() )
 446         {
 447             int x;
 448             wxControl *control = tool2->GetControl();
 449             control->GetPosition(&x, NULL);
 450             control->Move(x - width, -1);
 451         }
 452     }
 453
 454     return TRUE;
 455 }
 456
 457 bool wxToolBar::Realize()
 458 {
 459     const size_t nTools = GetToolsCount();
 460     if ( nTools == 0 )
 461     {
 462         // nothing to do
 463         return TRUE;
 464     }
 465
 466     const bool isVertical = HasFlag(wxTB_VERTICAL);
 467
 468     // delete all old buttons, if any
 469     for ( size_t pos = 0; pos < m_nButtons; pos++ )
 470     {
 471         if ( !::SendMessage(GetHwnd(), TB_DELETEBUTTON, 0, 0) )
 472         {
 473             wxLogDebug(wxT("TB_DELETEBUTTON failed"));
 474         }
 475     }
 476
 477     // First, add the bitmap: we use one bitmap for all toolbar buttons
 478     // ----------------------------------------------------------------
 479
 480     wxToolBarToolsList::Node *node;
 481     int bitmapId = 0;
 482
 483     wxSize sizeBmp;
 484     if ( HasFlag(wxTB_NOICONS) )
 485     {
 486         // no icons, don't leave space for them
 487         sizeBmp.x =
 488         sizeBmp.y = 0;
 489     }
 490     else // do show icons
 491     {
 492         // if we already have a bitmap, we'll replace the existing one --
 493         // otherwise we'll install a new one
 494         HBITMAP oldToolBarBitmap = (HBITMAP)m_hBitmap;
 495
 496         sizeBmp.x = m_defaultWidth;
 497         sizeBmp.y = m_defaultHeight;
 498
 499         const wxCoord totalBitmapWidth = m_defaultWidth * nTools,
 500                       totalBitmapHeight = m_defaultHeight;
 501
 502         // Create a bitmap and copy all the tool bitmaps to it
 503 #if USE_BITMAP_MASKS
 504         wxMemoryDC dcAllButtons;
 505         wxBitmap bitmap(totalBitmapWidth, totalBitmapHeight);
 506         dcAllButtons.SelectObject(bitmap);
 507         dcAllButtons.SetBackground(*wxLIGHT_GREY_BRUSH);
 508         dcAllButtons.Clear();
 509
 510         m_hBitmap = bitmap.GetHBITMAP();
 511         HBITMAP hBitmap = (HBITMAP)m_hBitmap;
 512 #else // !USE_BITMAP_MASKS
 513         HBITMAP hBitmap = ::CreateCompatibleBitmap(ScreenHDC(),
 514                                                    totalBitmapWidth,
 515                                                    totalBitmapHeight);
 516         if ( !hBitmap )
 517         {
 518             wxLogLastError(_T("CreateCompatibleBitmap"));
 519
 520             return FALSE;
 521         }
 522
 523         m_hBitmap = (WXHBITMAP)hBitmap;
 524
 525         MemoryHDC memoryDC;
 526         SelectInHDC hdcSelector(memoryDC, hBitmap);
 527
 528         MemoryHDC memoryDC2;
 529 #endif // USE_BITMAP_MASKS/!USE_BITMAP_MASKS
 530
 531         // the button position
 532         wxCoord x = 0;
 533
 534         // the number of buttons (not separators)
 535         int nButtons = 0;
 536
 537         for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
 538         {
 539             wxToolBarToolBase *tool = node->GetData();
 540             if ( tool->IsButton() )
 541             {
 542                 const wxBitmap& bmp = tool->GetNormalBitmap();
 543                 if ( bmp.Ok() )
 544                 {
 545 #if USE_BITMAP_MASKS
 546                     // notice the last parameter: do use mask
 547                     dcAllButtons.DrawBitmap(bmp, x, 0, TRUE);
 548 #else // !USE_BITMAP_MASKS
 549                     SelectInHDC hdcSelector2(memoryDC2, GetHbitmapOf(bmp));
 550                     if ( !BitBlt(memoryDC,
 551                                  x, 0,  m_defaultWidth, m_defaultHeight,
 552                                  memoryDC2,
 553                                  0, 0, SRCCOPY) )
 554                     {
 555                         wxLogLastError(wxT("BitBlt"));
 556                     }
 557 #endif // USE_BITMAP_MASKS/!USE_BITMAP_MASKS
 558                 }
 559                 else
 560                 {
 561                     wxFAIL_MSG( _T("invalid tool button bitmap") );
 562                 }
 563
 564                 // still inc width and number of buttons because otherwise the
 565                 // subsequent buttons will all be shifted which is rather confusing
 566                 // (and like this you'd see immediately which bitmap was bad)
 567                 x += m_defaultWidth;
 568                 nButtons++;
 569             }
 570         }
 571
 572 #if USE_BITMAP_MASKS
 573         dcAllButtons.SelectObject(wxNullBitmap);
 574
 575         // don't delete this HBITMAP!
 576         bitmap.SetHBITMAP(0);
 577 #endif // USE_BITMAP_MASKS/!USE_BITMAP_MASKS
 578
 579         // Map to system colours
 580         hBitmap = (HBITMAP)MapBitmap((WXHBITMAP) hBitmap,
 581                                      totalBitmapWidth, totalBitmapHeight);
 582
 583         bool addBitmap = TRUE;
 584
 585         if ( oldToolBarBitmap )
 586         {
 587 #ifdef TB_REPLACEBITMAP
 588             if ( wxTheApp->GetComCtl32Version() >= 400 )
 589             {
 590                 TBREPLACEBITMAP replaceBitmap;
 591                 replaceBitmap.hInstOld = NULL;
 592                 replaceBitmap.hInstNew = NULL;
 593                 replaceBitmap.nIDOld = (UINT) oldToolBarBitmap;
 594                 replaceBitmap.nIDNew = (UINT) hBitmap;
 595                 replaceBitmap.nButtons = nButtons;
 596                 if ( !::SendMessage(GetHwnd(), TB_REPLACEBITMAP,
 597                                     0, (LPARAM) &replaceBitmap) )
 598                 {
 599                     wxFAIL_MSG(wxT("Could not replace the old bitmap"));
 600                 }
 601
 602                 ::DeleteObject(oldToolBarBitmap);
 603
 604                 // already done
 605                 addBitmap = FALSE;
 606             }
 607             else
 608 #endif // TB_REPLACEBITMAP
 609             {
 610                 // we can't replace the old bitmap, so we will add another one
 611                 // (awfully inefficient, but what else to do?) and shift the bitmap
 612                 // indices accordingly
 613                 addBitmap = TRUE;
 614
 615                 bitmapId = m_nButtons;
 616             }
 617         }
 618
 619         if ( addBitmap ) // no old bitmap or we can't replace it
 620         {
 621             TBADDBITMAP addBitmap;
 622             addBitmap.hInst = 0;
 623             addBitmap.nID = (UINT) hBitmap;
 624             if ( ::SendMessage(GetHwnd(), TB_ADDBITMAP,
 625                                (WPARAM) nButtons, (LPARAM)&addBitmap) == -1 )
 626             {
 627                 wxFAIL_MSG(wxT("Could not add bitmap to toolbar"));
 628             }
 629         }
 630     }
 631
 632     // don't call SetToolBitmapSize() as we don't want to change the values of
 633     // m_defaultWidth/Height
 634     if ( !::SendMessage(GetHwnd(), TB_SETBITMAPSIZE, 0,
 635                         MAKELONG(sizeBmp.x, sizeBmp.y)) )
 636     {
 637         wxLogLastError(_T("TB_SETBITMAPSIZE"));
 638     }
 639
 640     // Next add the buttons and separators
 641     // -----------------------------------
 642
 643     TBBUTTON *buttons = new TBBUTTON[nTools];
 644
 645     // this array will hold the indices of all controls in the toolbar
 646     wxArrayInt controlIds;
 647
 648     bool lastWasRadio = FALSE;
 649     int i = 0;
 650     for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
 651     {
 652         wxToolBarToolBase *tool = node->GetData();
 653
 654         // don't add separators to the vertical toolbar - looks ugly
 655         if ( isVertical && tool->IsSeparator() )
 656             continue;
 657
 658         TBBUTTON& button = buttons[i];
 659
 660         wxZeroMemory(button);
 661
 662         bool isRadio = FALSE;
 663         switch ( tool->GetStyle() )
 664         {
 665             case wxTOOL_STYLE_CONTROL:
 666                 button.idCommand = tool->GetId();
 667                 // fall through: create just a separator too
 668
 669             case wxTOOL_STYLE_SEPARATOR:
 670                 button.fsState = TBSTATE_ENABLED;
 671                 button.fsStyle = TBSTYLE_SEP;
 672                 break;
 673
 674             case wxTOOL_STYLE_BUTTON:
 675                 if ( !HasFlag(wxTB_NOICONS) )
 676                     button.iBitmap = bitmapId;
 677
 678                 if ( HasFlag(wxTB_TEXT) )
 679                 {
 680                     const wxString& label = tool->GetLabel();
 681                     if ( !label.empty() )
 682                     {
 683                         button.iString = (int)label.c_str();
 684                     }
 685                 }
 686
 687                 button.idCommand = tool->GetId();
 688
 689                 if ( tool->IsEnabled() )
 690                     button.fsState |= TBSTATE_ENABLED;
 691                 if ( tool->IsToggled() )
 692                     button.fsState |= TBSTATE_CHECKED;
 693
 694                 switch ( tool->GetKind() )
 695                 {
 696                     case wxITEM_RADIO:
 697                         button.fsStyle = TBSTYLE_CHECKGROUP;
 698
 699                         if ( !lastWasRadio )
 700                         {
 701                             // the first item in the radio group is checked by
 702                             // default to be consistent with wxGTK and the menu
 703                             // radio items
 704                             button.fsState |= TBSTATE_CHECKED;
 705
 706                             tool->Toggle(TRUE);
 707                         }
 708
 709                         isRadio = TRUE;
 710                         break;
 711
 712                     case wxITEM_CHECK:
 713                         button.fsStyle = TBSTYLE_CHECK;
 714                         break;
 715
 716                     default:
 717                         wxFAIL_MSG( _T("unexpected toolbar button kind") );
 718                         // fall through
 719
 720                     case wxITEM_NORMAL:
 721                         button.fsStyle = TBSTYLE_BUTTON;
 722                 }
 723
 724                 bitmapId++;
 725                 break;
 726         }
 727
 728         lastWasRadio = isRadio;
 729
 730         i++;
 731     }
 732
 733     if ( !::SendMessage(GetHwnd(), TB_ADDBUTTONS, (WPARAM)i, (LPARAM)buttons) )
 734     {
 735         wxLogLastError(wxT("TB_ADDBUTTONS"));
 736     }
 737
 738     delete [] buttons;
 739
 740     // Deal with the controls finally
 741     // ------------------------------
 742
 743     // adjust the controls size to fit nicely in the toolbar
 744     int y = 0;
 745     size_t index = 0;
 746     for ( node = m_tools.GetFirst(); node; node = node->GetNext(), index++ )
 747     {
 748         wxToolBarToolBase *tool = node->GetData();
 749
 750         // we calculate the running y coord for vertical toolbars so we need to
 751         // get the items size for all items but for the horizontal ones we
 752         // don't need to deal with the non controls
 753         bool isControl = tool->IsControl();
 754         if ( !isControl && !isVertical )
 755             continue;
 756
 757         // note that we use TB_GETITEMRECT and not TB_GETRECT because the
 758         // latter only appeared in v4.70 of comctl32.dll
 759         RECT r;
 760         if ( !SendMessage(GetHwnd(), TB_GETITEMRECT,
 761                           index, (LPARAM)(LPRECT)&r) )
 762         {
 763             wxLogLastError(wxT("TB_GETITEMRECT"));
 764         }
 765
 766         if ( !isControl )
 767         {
 768             // can only be control if isVertical
 769             y += r.bottom - r.top;
 770
 771             continue;
 772         }
 773
 774         wxControl *control = tool->GetControl();
 775
 776         wxSize size = control->GetSize();
 777
 778         // the position of the leftmost controls corner
 779         int left = -1;
 780
 781         // TB_SETBUTTONINFO message is only supported by comctl32.dll 4.71+
 782 #if defined(_WIN32_IE) && (_WIN32_IE >= 0x400 )
 783         // available in headers, now check whether it is available now
 784         // (during run-time)
 785         if ( wxTheApp->GetComCtl32Version() >= 471 )
 786         {
 787             // set the (underlying) separators width to be that of the
 788             // control
 789             TBBUTTONINFO tbbi;
 790             tbbi.cbSize = sizeof(tbbi);
 791             tbbi.dwMask = TBIF_SIZE;
 792             tbbi.cx = size.x;
 793             if ( !SendMessage(GetHwnd(), TB_SETBUTTONINFO,
 794                               tool->GetId(), (LPARAM)&tbbi) )
 795             {
 796                 // the id is probably invalid?
 797                 wxLogLastError(wxT("TB_SETBUTTONINFO"));
 798             }
 799         }
 800         else
 801 #endif // comctl32.dll 4.71
 802         // TB_SETBUTTONINFO unavailable
 803         {
 804             // try adding several separators to fit the controls width
 805             int widthSep = r.right - r.left;
 806             left = r.left;
 807
 808             TBBUTTON tbb;
 809             wxZeroMemory(tbb);
 810             tbb.idCommand = 0;
 811             tbb.fsState = TBSTATE_ENABLED;
 812             tbb.fsStyle = TBSTYLE_SEP;
 813
 814             size_t nSeparators = size.x / widthSep;
 815             for ( size_t nSep = 0; nSep < nSeparators; nSep++ )
 816             {
 817                 if ( !SendMessage(GetHwnd(), TB_INSERTBUTTON,
 818                                   index, (LPARAM)&tbb) )
 819                 {
 820                     wxLogLastError(wxT("TB_INSERTBUTTON"));
 821                 }
 822
 823                 index++;
 824             }
 825
 826             // remember the number of separators we used - we'd have to
 827             // delete all of them later
 828             ((wxToolBarTool *)tool)->SetSeparatorsCount(nSeparators);
 829
 830             // adjust the controls width to exactly cover the separators
 831             control->SetSize((nSeparators + 1)*widthSep, -1);
 832         }
 833
 834         // position the control itself correctly vertically
 835         int height = r.bottom - r.top;
 836         int diff = height - size.y;
 837         if ( diff < 0 )
 838         {
 839             // the control is too high, resize to fit
 840             control->SetSize(-1, height - 2);
 841
 842             diff = 2;
 843         }
 844
 845         int top;
 846         if ( isVertical )
 847         {
 848             left = 0;
 849             top = y;
 850
 851             y += height + 2*GetMargins().y;
 852         }
 853         else // horizontal toolbar
 854         {
 855             if ( left == -1 )
 856                 left = r.left;
 857
 858             top = r.top;
 859         }
 860
 861         control->Move(left, top + (diff + 1) / 2);
 862     }
 863
 864     // the max index is the "real" number of buttons - i.e. counting even the
 865     // separators which we added just for aligning the controls
 866     m_nButtons = index;
 867
 868     if ( !isVertical )
 869     {
 870         if ( m_maxRows == 0 )
 871         {
 872             // if not set yet, only one row
 873             SetRows(1);
 874         }
 875     }
 876     else if ( m_nButtons > 0 ) // vertical non empty toolbar
 877     {
 878         if ( m_maxRows == 0 )
 879         {
 880             // if not set yet, have one column
 881             SetRows(m_nButtons);
 882         }
 883     }
 884
 885     return TRUE;
 886 }
 887
 888 // ----------------------------------------------------------------------------
 889 // message handlers
 890 // ----------------------------------------------------------------------------
 891
 892 bool wxToolBar::MSWCommand(WXUINT WXUNUSED(cmd), WXWORD id)
 893 {
 894     wxToolBarToolBase *tool = FindById((int)id);
 895     if ( !tool )
 896         return FALSE;
 897
 898     if ( tool->CanBeToggled() )
 899     {
 900         LRESULT state = ::SendMessage(GetHwnd(), TB_GETSTATE, id, 0);
 901         tool->Toggle((state & TBSTATE_CHECKED) != 0);
 902     }
 903
 904     bool toggled = tool->IsToggled();
 905
 906     // avoid sending the event when a radio button is released, this is not
 907     // interesting
 908     if ( !tool->CanBeToggled() || tool->GetKind() != wxITEM_RADIO || toggled )
 909     {
 910         // OnLeftClick() can veto the button state change - for buttons which
 911         // may be toggled only, of couse
 912         if ( !OnLeftClick((int)id, toggled) && tool->CanBeToggled() )
 913         {
 914             // revert back
 915             toggled = !toggled;
 916             tool->SetToggle(toggled);
 917
 918             ::SendMessage(GetHwnd(), TB_CHECKBUTTON, id, MAKELONG(toggled, 0));
 919         }
 920     }
 921
 922     return TRUE;
 923 }
 924
 925 bool wxToolBar::MSWOnNotify(int WXUNUSED(idCtrl),
 926                             WXLPARAM lParam,
 927                             WXLPARAM *WXUNUSED(result))
 928 {
 929 #if wxUSE_TOOLTIPS
 930     // First check if this applies to us
 931     NMHDR *hdr = (NMHDR *)lParam;
 932
 933     // the tooltips control created by the toolbar is sometimes Unicode, even
 934     // in an ANSI application - this seems to be a bug in comctl32.dll v5
 935     UINT code = hdr->code;
 936     if ( (code != (UINT) TTN_NEEDTEXTA) && (code != (UINT) TTN_NEEDTEXTW) )
 937         return FALSE;
 938
 939     HWND toolTipWnd = (HWND)::SendMessage((HWND)GetHWND(), TB_GETTOOLTIPS, 0, 0);
 940     if ( toolTipWnd != hdr->hwndFrom )
 941         return FALSE;
 942
 943     LPTOOLTIPTEXT ttText = (LPTOOLTIPTEXT)lParam;
 944     int id = (int)ttText->hdr.idFrom;
 945
 946     wxToolBarToolBase *tool = FindById(id);
 947     if ( !tool )
 948         return FALSE;
 949
 950     return HandleTooltipNotify(code, lParam, tool->GetShortHelp());
 951 #else
 952     return FALSE;
 953 #endif
 954 }
 955
 956 // ----------------------------------------------------------------------------
 957 // toolbar geometry
 958 // ----------------------------------------------------------------------------
 959
 960 void wxToolBar::SetToolBitmapSize(const wxSize& size)
 961 {
 962     wxToolBarBase::SetToolBitmapSize(size);
 963
 964     ::SendMessage(GetHwnd(), TB_SETBITMAPSIZE, 0, MAKELONG(size.x, size.y));
 965 }
 966
 967 void wxToolBar::SetRows(int nRows)
 968 {
 969     if ( nRows == m_maxRows )
 970     {
 971         // avoid resizing the frame uselessly
 972         return;
 973     }
 974
 975     // TRUE in wParam means to create at least as many rows, FALSE -
 976     // at most as many
 977     RECT rect;
 978     ::SendMessage(GetHwnd(), TB_SETROWS,
 979                   MAKEWPARAM(nRows, !(GetWindowStyle() & wxTB_VERTICAL)),
 980                   (LPARAM) &rect);
 981
 982     m_maxRows = nRows;
 983
 984     UpdateSize();
 985 }
 986
 987 // The button size is bigger than the bitmap size
 988 wxSize wxToolBar::GetToolSize() const
 989 {
 990     // TB_GETBUTTONSIZE is supported from version 4.70
 991 #if defined(_WIN32_IE) && (_WIN32_IE >= 0x300 ) \
 992     && !( defined(__GNUWIN32__) && !wxCHECK_W32API_VERSION( 1, 0 ) )
 993     if ( wxTheApp->GetComCtl32Version() >= 470 )
 994     {
 995         DWORD dw = ::SendMessage(GetHwnd(), TB_GETBUTTONSIZE, 0, 0);
 996
 997         return wxSize(LOWORD(dw), HIWORD(dw));
 998     }
 999     else
1000 #endif // comctl32.dll 4.70+
1001     {
1002         // defaults
1003         return wxSize(m_defaultWidth + 8, m_defaultHeight + 7);
1004     }
1005 }
1006
1007 static
1008 wxToolBarToolBase *GetItemSkippingDummySpacers(const wxToolBarToolsList& tools,
1009                                                size_t index )
1010 {
1011     wxToolBarToolsList::Node* current = tools.GetFirst();
1012
1013     for ( ; current != 0; current = current->GetNext() )
1014     {
1015         if ( index == 0 )
1016             return current->GetData();
1017
1018         wxToolBarTool *tool = (wxToolBarTool *)current->GetData();
1019         size_t separators = tool->GetSeparatorsCount();
1020
1021         // if it is a normal button, sepcount == 0, so skip 1 item (the button)
1022         // otherwise, skip as many items as the separator count, plus the
1023         // control itself
1024         index -= separators ? separators + 1 : 1;
1025     }
1026
1027     return 0;
1028 }
1029
1030 wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord x, wxCoord y) const
1031 {
1032     POINT pt;
1033     pt.x = x;
1034     pt.y = y;
1035     int index = (int)::SendMessage(GetHwnd(), TB_HITTEST, 0, (LPARAM)&pt);
1036     // MBN: when the point ( x, y ) is close to the toolbar border
1037     //      TB_HITTEST returns m_nButtons ( not -1 )
1038     if ( index < 0 || (size_t)index >= m_nButtons )
1039     {
1040         // it's a separator or there is no tool at all there
1041         return (wxToolBarToolBase *)NULL;
1042     }
1043
1044     // if comctl32 version < 4.71 wxToolBar95 adds dummy spacers
1045 #if defined(_WIN32_IE) && (_WIN32_IE >= 0x400 )
1046     if ( wxTheApp->GetComCtl32Version() >= 471 )
1047     {
1048         return m_tools.Item((size_t)index)->GetData();
1049     }
1050     else
1051 #endif
1052     {
1053         return GetItemSkippingDummySpacers( m_tools, (size_t) index );
1054     }
1055 }
1056
1057 void wxToolBar::UpdateSize()
1058 {
1059     // the toolbar size changed
1060     SendMessage(GetHwnd(), TB_AUTOSIZE, 0, 0);
1061
1062     // we must also refresh the frame after the toolbar size (possibly) changed
1063     wxFrame *frame = wxDynamicCast(GetParent(), wxFrame);
1064     if ( frame )
1065     {
1066         frame->SendSizeEvent();
1067     }
1068 }
1069
1070 // ----------------------------------------------------------------------------
1071 // toolbar styles
1072 // ---------------------------------------------------------------------------
1073
1074 void wxToolBar::SetWindowStyleFlag(long style)
1075 {
1076     // the style bits whose changes force us to recreate the toolbar
1077     static const long MASK_NEEDS_RECREATE = wxTB_TEXT | wxTB_NOICONS;
1078
1079     const long styleOld = GetWindowStyle();
1080
1081     wxToolBarBase::SetWindowStyleFlag(style);
1082
1083     // don't recreate an empty toolbar: not only this is unnecessary, but it is
1084     // also fatal as we'd then try to recreate the toolbar when it's just being
1085     // created
1086     if ( GetToolsCount() &&
1087             (style & MASK_NEEDS_RECREATE) != (styleOld & MASK_NEEDS_RECREATE) )
1088     {
1089         // to remove the text labels, simply re-realizing the toolbar is enough
1090         // but I don't know of any way to add the text to an existing toolbar
1091         // other than by recreating it entirely
1092         Recreate();
1093     }
1094 }
1095
1096 // ----------------------------------------------------------------------------
1097 // tool state
1098 // ----------------------------------------------------------------------------
1099
1100 void wxToolBar::DoEnableTool(wxToolBarToolBase *tool, bool enable)
1101 {
1102     ::SendMessage(GetHwnd(), TB_ENABLEBUTTON,
1103                   (WPARAM)tool->GetId(), (LPARAM)MAKELONG(enable, 0));
1104 }
1105
1106 void wxToolBar::DoToggleTool(wxToolBarToolBase *tool, bool toggle)
1107 {
1108     ::SendMessage(GetHwnd(), TB_CHECKBUTTON,
1109                   (WPARAM)tool->GetId(), (LPARAM)MAKELONG(toggle, 0));
1110 }
1111
1112 void wxToolBar::DoSetToggle(wxToolBarToolBase *WXUNUSED(tool), bool WXUNUSED(toggle))
1113 {
1114     // VZ: AFAIK, the button has to be created either with TBSTYLE_CHECK or
1115     //     without, so we really need to delete the button and recreate it here
1116     wxFAIL_MSG( _T("not implemented") );
1117 }
1118
1119 // ----------------------------------------------------------------------------
1120 // event handlers
1121 // ----------------------------------------------------------------------------
1122
1123 // Responds to colour changes, and passes event on to children.
1124 void wxToolBar::OnSysColourChanged(wxSysColourChangedEvent& event)
1125 {
1126     wxRGBToColour(m_backgroundColour, ::GetSysColor(COLOR_BTNFACE));
1127
1128     // Remap the buttons
1129     Realize();
1130
1131     // Relayout the toolbar
1132     int nrows = m_maxRows;
1133     m_maxRows = 0;      // otherwise SetRows() wouldn't do anything
1134     SetRows(nrows);
1135
1136     Refresh();
1137
1138     // let the event propagate further
1139     event.Skip();
1140 }
1141
1142 void wxToolBar::OnMouseEvent(wxMouseEvent& event)
1143 {
1144     if (event.Leaving() && m_pInTool)
1145     {
1146         OnMouseEnter( -1 );
1147         event.Skip();
1148         return;
1149     }
1150
1151     if (event.RightDown())
1152     {
1153         // For now, we don't have an id. Later we could
1154         // try finding the tool.
1155         OnRightClick((int)-1, event.GetX(), event.GetY());
1156     }
1157     else
1158     {
1159         event.Skip();
1160     }
1161 }
1162
1163 bool wxToolBar::HandleSize(WXWPARAM wParam, WXLPARAM lParam)
1164 {
1165     // calculate our minor dimenstion ourselves - we're confusing the standard
1166     // logic (TB_AUTOSIZE) with our horizontal toolbars and other hacks
1167     RECT r;
1168     if ( ::SendMessage(GetHwnd(), TB_GETITEMRECT, 0, (LPARAM)&r) )
1169     {
1170         int w, h;
1171
1172         if ( GetWindowStyle() & wxTB_VERTICAL )
1173         {
1174             w = r.right - r.left;
1175             if ( m_maxRows )
1176             {
1177                 w *= (m_nButtons + m_maxRows - 1)/m_maxRows;
1178             }
1179             h = HIWORD(lParam);
1180         }
1181         else
1182         {
1183             w = LOWORD(lParam);
1184             if (HasFlag( wxTB_FLAT ))
1185                 h = r.bottom - r.top - 3;
1186             else
1187                 h = r.bottom - r.top;
1188             if ( m_maxRows )
1189             {
1190                 // FIXME: 6 is hardcoded separator line height...
1191                 //h += 6;
1192                 if (HasFlag(wxTB_NODIVIDER))
1193                     h += 4;
1194                 else
1195                     h += 6;
1196                 h *= m_maxRows;
1197             }
1198         }
1199
1200         if ( MAKELPARAM(w, h) != lParam )
1201         {
1202             // size really changed
1203             SetSize(w, h);
1204         }
1205
1206         // message processed
1207         return TRUE;
1208     }
1209
1210     return FALSE;
1211 }
1212
1213 bool wxToolBar::HandlePaint(WXWPARAM wParam, WXLPARAM lParam)
1214 {
1215     // erase any dummy separators which we used for aligning the controls if
1216     // any here
1217
1218     // first of all, do we have any controls at all?
1219     wxToolBarToolsList::Node *node;
1220     for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
1221     {
1222         if ( node->GetData()->IsControl() )
1223             break;
1224     }
1225
1226     if ( !node )
1227     {
1228         // no controls, nothing to erase
1229         return FALSE;
1230     }
1231
1232     // prepare the DC on which we'll be drawing
1233     wxClientDC dc(this);
1234     dc.SetBrush(wxBrush(GetBackgroundColour(), wxSOLID));
1235     dc.SetPen(*wxTRANSPARENT_PEN);
1236
1237     RECT r;
1238     if ( !GetUpdateRect(GetHwnd(), &r, FALSE) )
1239     {
1240         // nothing to redraw anyhow
1241         return FALSE;
1242     }
1243
1244     wxRect rectUpdate;
1245     wxCopyRECTToRect(r, rectUpdate);
1246
1247     dc.SetClippingRegion(rectUpdate);
1248
1249     // draw the toolbar tools, separators &c normally
1250     wxControl::MSWWindowProc(WM_PAINT, wParam, lParam);
1251
1252     // for each control in the toolbar find all the separators intersecting it
1253     // and erase them
1254     //
1255     // NB: this is really the only way to do it as we don't know if a separator
1256     //     corresponds to a control (i.e. is a dummy one) or a real one
1257     //     otherwise
1258     for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
1259     {
1260         wxToolBarToolBase *tool = node->GetData();
1261         if ( tool->IsControl() )
1262         {
1263             // get the control rect in our client coords
1264             wxControl *control = tool->GetControl();
1265             wxRect rectCtrl = control->GetRect();
1266
1267             // iterate over all buttons
1268             TBBUTTON tbb;
1269             int count = ::SendMessage(GetHwnd(), TB_BUTTONCOUNT, 0, 0);
1270             for ( int n = 0; n < count; n++ )
1271             {
1272                 // is it a separator?
1273                 if ( !::SendMessage(GetHwnd(), TB_GETBUTTON,
1274                                     n, (LPARAM)&tbb) )
1275                 {
1276                     wxLogDebug(_T("TB_GETBUTTON failed?"));
1277
1278                     continue;
1279                 }
1280
1281                 if ( tbb.fsStyle != TBSTYLE_SEP )
1282                     continue;
1283
1284                 // get the bounding rect of the separator
1285                 RECT r;
1286                 if ( !::SendMessage(GetHwnd(), TB_GETITEMRECT,
1287                                     n, (LPARAM)&r) )
1288                 {
1289                     wxLogDebug(_T("TB_GETITEMRECT failed?"));
1290
1291                     continue;
1292                 }
1293
1294                 // does it intersect the control?
1295                 wxRect rectItem;
1296                 wxCopyRECTToRect(r, rectItem);
1297                 if ( rectCtrl.Intersects(rectItem) )
1298                 {
1299                     // yes, do erase it!
1300                     dc.DrawRectangle(rectItem);
1301                 }
1302             }
1303         }
1304     }
1305
1306     return TRUE;
1307 }
1308
1309 void wxToolBar::HandleMouseMove(WXWPARAM wParam, WXLPARAM lParam)
1310 {
1311     wxCoord x = GET_X_LPARAM(lParam),
1312             y = GET_Y_LPARAM(lParam);
1313     wxToolBarToolBase* tool = FindToolForPosition( x, y );
1314
1315     // cursor left current tool
1316     if( tool != m_pInTool && !tool )
1317     {
1318         m_pInTool = 0;
1319         OnMouseEnter( -1 );
1320     }
1321
1322     // cursor entered a tool
1323     if( tool != m_pInTool && tool )
1324     {
1325         m_pInTool = tool;
1326         OnMouseEnter( tool->GetId() );
1327     }
1328 }
1329
1330 long wxToolBar::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
1331 {
1332     switch ( nMsg )
1333     {
1334         case WM_SIZE:
1335             if ( HandleSize(wParam, lParam) )
1336                 return 0;
1337             break;
1338
1339         case WM_MOUSEMOVE:
1340             // we don't handle mouse moves, so always pass the message to
1341             // wxControl::MSWWindowProc
1342             HandleMouseMove(wParam, lParam);
1343             break;
1344
1345         case WM_PAINT:
1346             if ( HandlePaint(wParam, lParam) )
1347                 return 0;
1348     }
1349
1350     return wxControl::MSWWindowProc(nMsg, wParam, lParam);
1351 }
1352
1353 // ----------------------------------------------------------------------------
1354 // private functions
1355 // ----------------------------------------------------------------------------
1356
1357 WXHBITMAP wxToolBar::MapBitmap(WXHBITMAP bitmap, int width, int height)
1358 {
1359     MemoryHDC hdcMem;
1360
1361     if ( !hdcMem )
1362     {
1363         wxLogLastError(_T("CreateCompatibleDC"));
1364
1365         return bitmap;
1366     }
1367
1368     SelectInHDC bmpInHDC(hdcMem, (HBITMAP)bitmap);
1369
1370     if ( !bmpInHDC )
1371     {
1372         wxLogLastError(_T("SelectObject"));
1373
1374         return bitmap;
1375     }
1376
1377     wxCOLORMAP *cmap = wxGetStdColourMap();
1378
1379     for ( int i = 0; i < width; i++ )
1380     {
1381         for ( int j = 0; j < height; j++ )
1382         {
1383             COLORREF pixel = ::GetPixel(hdcMem, i, j);
1384
1385             for ( size_t k = 0; k < wxSTD_COL_MAX; k++ )
1386             {
1387                 COLORREF col = cmap[k].from;
1388                 if ( abs(GetRValue(pixel) - GetRValue(col)) < 10 &&
1389                      abs(GetGValue(pixel) - GetGValue(col)) < 10 &&
1390                      abs(GetBValue(pixel) - GetBValue(col)) < 10 )
1391                 {
1392                     ::SetPixel(hdcMem, i, j, cmap[k].to);
1393                     break;
1394                 }
1395             }
1396         }
1397     }
1398
1399     return bitmap;
1400
1401     // VZ: I leave here my attempts to map the bitmap to the system colours
1402     //     faster by using BitBlt() even though it's broken currently - but
1403     //     maybe someone else can finish it? It should be faster than iterating
1404     //     over all pixels...
1405 #if 0
1406     MemoryHDC hdcMask, hdcDst;
1407     if ( !hdcMask || !hdcDst )
1408     {
1409         wxLogLastError(_T("CreateCompatibleDC"));
1410
1411         return bitmap;
1412     }
1413
1414     // create the target bitmap
1415     HBITMAP hbmpDst = ::CreateCompatibleBitmap(hdcDst, width, height);
1416     if ( !hbmpDst )
1417     {
1418         wxLogLastError(_T("CreateCompatibleBitmap"));
1419
1420         return bitmap;
1421     }
1422
1423     // create the monochrome mask bitmap
1424     HBITMAP hbmpMask = ::CreateBitmap(width, height, 1, 1, 0);
1425     if ( !hbmpMask )
1426     {
1427         wxLogLastError(_T("CreateBitmap(mono)"));
1428
1429         ::DeleteObject(hbmpDst);
1430
1431         return bitmap;
1432     }
1433
1434     SelectInHDC bmpInDst(hdcDst, hbmpDst),
1435                 bmpInMask(hdcMask, hbmpMask);
1436
1437     // for each colour:
1438     for ( n = 0; n < NUM_OF_MAPPED_COLOURS; n++ )
1439     {
1440         // create the mask for this colour
1441         ::SetBkColor(hdcMem, ColorMap[n].from);
1442         ::BitBlt(hdcMask, 0, 0, width, height, hdcMem, 0, 0, SRCCOPY);
1443
1444         // replace this colour with the target one in the dst bitmap
1445         HBRUSH hbr = ::CreateSolidBrush(ColorMap[n].to);
1446         HGDIOBJ hbrOld = ::SelectObject(hdcDst, hbr);
1447
1448         ::MaskBlt(hdcDst, 0, 0, width, height,
1449                   hdcMem, 0, 0,
1450                   hbmpMask, 0, 0,
1451                   MAKEROP4(PATCOPY, SRCCOPY));
1452
1453         (void)::SelectObject(hdcDst, hbrOld);
1454         ::DeleteObject(hbr);
1455     }
1456
1457     ::DeleteObject((HBITMAP)bitmap);
1458
1459     return (WXHBITMAP)hbmpDst;
1460 #endif // 0
1461 }
1462
1463 #endif // wxUSE_TOOLBAR && Win95
1464