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