better focus handling (blind fix)

[wxWidgets.git] / src / msw / tbar95.cpp

diff --git a/src/msw/tbar95.cpp b/src/msw/tbar95.cpp
index b20b58c96607c209f86f43f7433bbfbca5144b6c..f1ed7ca012dbc8808beba69bc7d6825cff8adfa2 100644 (file)
--- a/src/msw/tbar95.cpp
+++ b/src/msw/tbar95.cpp
@@ -1,6 +1,6 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        msw/tbar95.cpp
 /////////////////////////////////////////////////////////////////////////////
 // Name:        msw/tbar95.cpp

-// Purpose:     wxToolBar95
+// Purpose:     wxToolBar

 // Author:      Julian Smart
 // Modified by:
 // Created:     04/01/98
 // Author:      Julian Smart
 // Modified by:
 // Created:     04/01/98


@@ -29,12 +29,18 @@
 #endif
 
 #ifndef WX_PRECOMP
 #endif
 
 #ifndef WX_PRECOMP

+    #include "wx/frame.h"

     #include "wx/log.h"
     #include "wx/intl.h"
     #include "wx/dynarray.h"
     #include "wx/log.h"
     #include "wx/intl.h"
     #include "wx/dynarray.h"

+    #include "wx/settings.h"
+    #include "wx/bitmap.h"
+    #include "wx/dcmemory.h"

 #endif
 
 #endif
 

-#if wxUSE_BUTTONBAR && wxUSE_TOOLBAR && defined(__WIN95__)
+#if wxUSE_TOOLBAR && defined(__WIN95__) && wxUSE_TOOLBAR_NATIVE
+
+#include "wx/toolbar.h"

 
 #if !defined(__GNUWIN32__) && !defined(__SALFORDC__)
     #include "malloc.h"
 
 #if !defined(__GNUWIN32__) && !defined(__SALFORDC__)
     #include "malloc.h"


@@ -44,18 +50,29 @@
 
 #ifndef __TWIN32__
 
 
 #ifndef __TWIN32__
 

-#ifdef __GNUWIN32_OLD__
-    #include "wx/msw/gnuwin32/extra.h"
-#else
+#if defined(__WIN95__) && !((defined(__GNUWIN32_OLD__) || defined(__TWIN32__)) && !defined(__CYGWIN10__))

     #include <commctrl.h>
     #include <commctrl.h>

+#else
+    #include "wx/msw/gnuwin32/extra.h"

 #endif
 
 #endif // __TWIN32__
 
 #include "wx/msw/dib.h"
 #endif
 
 #endif // __TWIN32__
 
 #include "wx/msw/dib.h"

-#include "wx/tbar95.h"

 #include "wx/app.h"         // for GetComCtl32Version
 
 #include "wx/app.h"         // for GetComCtl32Version
 

+// ----------------------------------------------------------------------------
+// conditional compilation
+// ----------------------------------------------------------------------------
+
+// wxWindows previously always considered that toolbar buttons have light grey
+// (0xc0c0c0) background and so ignored any bitmap masks - however, this
+// doesn't work with XPMs which then appear to have black background. To make
+// this work, we must respect the bitmap masks - which we do now. This should
+// be ok in any case, but to restore 100% compatible with the old version
+// behaviour, you can set this to 0.
+#define USE_BITMAP_MASKS 1
+

 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------


@@ -72,8 +89,12 @@
 
 // Messages
 #ifndef TB_GETSTYLE
 
 // Messages
 #ifndef TB_GETSTYLE

-    #define TB_GETSTYLE             (WM_USER + 57)

     #define TB_SETSTYLE             (WM_USER + 56)
     #define TB_SETSTYLE             (WM_USER + 56)

+    #define TB_GETSTYLE             (WM_USER + 57)
+#endif
+
+#ifndef TB_HITTEST
+    #define TB_HITTEST              (WM_USER + 69)

 #endif
 
 // these values correspond to those used by comctl32.dll
 #endif
 
 // these values correspond to those used by comctl32.dll


@@ -84,83 +105,141 @@
 #define DEFAULTBARHEIGHT 27
 
 // ----------------------------------------------------------------------------
 #define DEFAULTBARHEIGHT 27
 
 // ----------------------------------------------------------------------------

-// function prototypes
+// private function prototypes

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

-static void wxMapBitmap(HBITMAP hBitmap, int width, int height);
+// adjust toolbar bitmap colours
+// static void wxMapBitmap(HBITMAP hBitmap, int width, int height);

 
 // ----------------------------------------------------------------------------
 // wxWin macros
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // wxWin macros
 // ----------------------------------------------------------------------------
 

-#if !USE_SHARED_LIBRARY
-    IMPLEMENT_DYNAMIC_CLASS(wxToolBar95, wxToolBarBase)
-#endif
+IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxToolBarBase)

 
 

-BEGIN_EVENT_TABLE(wxToolBar95, wxToolBarBase)
-    EVT_MOUSE_EVENTS(wxToolBar95::OnMouseEvent)
-    EVT_SYS_COLOUR_CHANGED(wxToolBar95::OnSysColourChanged)
+BEGIN_EVENT_TABLE(wxToolBar, wxToolBarBase)
+    EVT_MOUSE_EVENTS(wxToolBar::OnMouseEvent)
+    EVT_SYS_COLOUR_CHANGED(wxToolBar::OnSysColourChanged)

 END_EVENT_TABLE()
 
 END_EVENT_TABLE()
 

+// ----------------------------------------------------------------------------
+// private classes
+// ----------------------------------------------------------------------------
+
+class wxToolBarTool : public wxToolBarToolBase
+{
+public:
+    wxToolBarTool(wxToolBar *tbar,
+                  int id,
+                  const wxBitmap& bitmap1,
+                  const wxBitmap& bitmap2,
+                  bool toggle,
+                  wxObject *clientData,
+                  const wxString& shortHelpString,
+                  const wxString& longHelpString)
+        : wxToolBarToolBase(tbar, id, bitmap1, bitmap2, toggle,
+                            clientData, shortHelpString, longHelpString)
+    {
+        m_nSepCount = 0;
+    }
+
+    wxToolBarTool(wxToolBar *tbar, wxControl *control)
+        : wxToolBarToolBase(tbar, control)
+    {
+        m_nSepCount = 1;
+    }
+
+    // set/get the number of separators which we use to cover the space used by
+    // a control in the toolbar
+    void SetSeparatorsCount(size_t count) { m_nSepCount = count; }
+    size_t GetSeparatorsCount() const { return m_nSepCount; }
+
+private:
+    size_t m_nSepCount;
+};
+
+

 // ============================================================================
 // implementation
 // ============================================================================
 
 // ----------------------------------------------------------------------------
 // ============================================================================
 // implementation
 // ============================================================================
 
 // ----------------------------------------------------------------------------

-// wxToolBar95 construction
+// wxToolBarTool

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

-void wxToolBar95::Init()
+wxToolBarToolBase *wxToolBar::CreateTool(int id,
+                                         const wxBitmap& bitmap1,
+                                         const wxBitmap& bitmap2,
+                                         bool toggle,
+                                         wxObject *clientData,
+                                         const wxString& shortHelpString,
+                                         const wxString& longHelpString)
+{
+    return new wxToolBarTool(this, id, bitmap1, bitmap2, toggle,
+                             clientData, shortHelpString, longHelpString);
+}
+
+wxToolBarToolBase *wxToolBar::CreateTool(wxControl *control)
+{
+    return new wxToolBarTool(this, control);
+}
+
+// ----------------------------------------------------------------------------
+// wxToolBar construction
+// ----------------------------------------------------------------------------
+
+void wxToolBar::Init()

 {
 {

-    m_maxWidth = -1;
-    m_maxHeight = -1;

     m_hBitmap = 0;
     m_hBitmap = 0;

+
+    m_nButtons = 0;
+

     m_defaultWidth = DEFAULTBITMAPX;
     m_defaultHeight = DEFAULTBITMAPY;
 }
 
     m_defaultWidth = DEFAULTBITMAPX;
     m_defaultHeight = DEFAULTBITMAPY;
 }
 

-bool wxToolBar95::Create(wxWindow *parent,
-                         wxWindowID id,
-                         const wxPoint& pos,
-                         const wxSize& size,
-                         long style,
-                         const wxString& name)
+bool wxToolBar::Create(wxWindow *parent,
+                       wxWindowID id,
+                       const wxPoint& pos,
+                       const wxSize& size,
+                       long style,
+                       const wxString& name)

 {
 {

-    wxASSERT_MSG( (style & wxTB_VERTICAL) == 0,
-                  wxT("Sorry, wxToolBar95 under Windows 95 only "
-                      "supports horizontal orientation.") );
-

     // common initialisation
     // common initialisation

-    if ( !CreateControl(parent, id, pos, size, style, name) )
+    if ( !CreateControl(parent, id, pos, size, style, wxDefaultValidator, name) )

         return FALSE;
 
         return FALSE;
 

-    // set up the colors and fonts
-#if 0
-    wxRGBToColour(m_backgroundColour, GetSysColor(COLOR_BTNFACE));
-    m_foregroundColour = *wxBLACK;
-
-    SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
-#endif
-

     // prepare flags
     DWORD msflags = 0;      // WS_VISIBLE | WS_CHILD always included
     if (style & wxBORDER)
         msflags |= WS_BORDER;
     // prepare flags
     DWORD msflags = 0;      // WS_VISIBLE | WS_CHILD always included
     if (style & wxBORDER)
         msflags |= WS_BORDER;

+
+   if ( style & wxCLIP_SIBLINGS )
+        msflags |= WS_CLIPSIBLINGS;
+
+#ifdef TBSTYLE_TOOLTIPS

     msflags |= TBSTYLE_TOOLTIPS;
     msflags |= TBSTYLE_TOOLTIPS;

+#endif

 
     if (style & wxTB_FLAT)
     {
         if (wxTheApp->GetComCtl32Version() > 400)
 
     if (style & wxTB_FLAT)
     {
         if (wxTheApp->GetComCtl32Version() > 400)

-            msflags |= TBSTYLE_FLAT | TBSTYLE_TRANSPARENT;
+            msflags |= TBSTYLE_FLAT;

     }
 
     // MSW-specific initialisation
     if ( !wxControl::MSWCreateControl(TOOLBARCLASSNAME, msflags) )
         return FALSE;
 
     }
 
     // MSW-specific initialisation
     if ( !wxControl::MSWCreateControl(TOOLBARCLASSNAME, msflags) )
         return FALSE;
 

-    // Toolbar-specific initialisation
+    // toolbar-specific post initialisation

     ::SendMessage(GetHwnd(), TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0);
 
     ::SendMessage(GetHwnd(), TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0);
 

+    // set up the colors and fonts
+    wxRGBToColour(m_backgroundColour, GetSysColor(COLOR_BTNFACE));
+    m_foregroundColour = *wxBLACK;
+
+    SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
+

     // position it
     int x = pos.x;
     int y = pos.y;
     // position it
     int x = pos.x;
     int y = pos.y;


@@ -181,190 +260,310 @@ bool wxToolBar95::Create(wxWindow *parent,
     return TRUE;
 }
 
     return TRUE;
 }
 

-wxToolBar95::~wxToolBar95()
+wxToolBar::~wxToolBar()

 {
 {

-    UnsubclassWin();
+    // we must refresh the frame size when the toolbar is deleted but the frame
+    // is not - otherwise toolbar leaves a hole in the place it used to occupy
+    //
+    // NB: a frame is being deleted only if it is not any longer in
+    //     wxTopLevelWindows list
+    wxFrame *frame = wxDynamicCast(GetParent(), wxFrame);
+    if ( frame && wxTopLevelWindows.Find(frame) )
+    {
+        frame->SendSizeEvent();
+    }

 
 

-    if (m_hBitmap)
+    if ( m_hBitmap )

     {
         ::DeleteObject((HBITMAP) m_hBitmap);
     }
 }
 
     {
         ::DeleteObject((HBITMAP) m_hBitmap);
     }
 }
 

-void wxToolBar95::ClearTools()
+// ----------------------------------------------------------------------------
+// adding/removing tools
+// ----------------------------------------------------------------------------
+
+bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos),
+                             wxToolBarToolBase *tool)

 {
 {

-    // TODO: Don't know how to reset the toolbar bitmap, as yet.
-    // But adding tools and calling CreateTools should probably
-    // recreate a buttonbar OK.
-    wxToolBarBase::ClearTools();
+    // nothing special to do here - we really create the toolbar buttons in
+    // Realize() later
+    tool->Attach(this);
+
+    return TRUE;

 }
 
 }
 

-bool wxToolBar95::AddControl(wxControl *control)
+bool wxToolBar::DoDeleteTool(size_t pos, wxToolBarToolBase *tool)

 {
 {

-    wxCHECK_MSG( control, FALSE, _T("toolbar: can't insert NULL control") );
+    // the main difficulty we have here is with the controls in the toolbars:
+    // as we (sometimes) use several separators to cover up the space used by
+    // them, the indices are not the same for us and the toolbar
+
+    // first determine the position of the first button to delete: it may be
+    // different from pos if we use several separators to cover the space used
+    // by a control
+    wxToolBarToolsList::Node *node;
+    for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
+    {
+        wxToolBarToolBase *tool2 = node->GetData();
+        if ( tool2 == tool )
+        {
+            // let node point to the next node in the list
+            node = node->GetNext();

 
 

-    wxCHECK_MSG( control->GetParent() == this, FALSE,
-                 _T("control must have toolbar as parent") );
+            break;
+        }

 
 

-    wxToolBarTool *tool = new wxToolBarTool(control);
+        if ( tool2->IsControl() )
+        {
+            pos += ((wxToolBarTool *)tool2)->GetSeparatorsCount() - 1;
+        }
+    }

 
 

-    m_tools.Append(control->GetId(), tool);
+    // now determine the number of buttons to delete and the area taken by them
+    size_t nButtonsToDelete = 1;

 
 

-    return TRUE;
-}
+    // get the size of the button we're going to delete
+    RECT r;
+    if ( !::SendMessage(GetHwnd(), TB_GETITEMRECT, pos, (LPARAM)&r) )
+    {
+        wxLogLastError(_T("TB_GETITEMRECT"));
+    }

 
 

-wxToolBarTool *wxToolBar95::AddTool(int index,
-                                    const wxBitmap& bitmap,
-                                    const wxBitmap& pushedBitmap,
-                                    bool toggle,
-                                    long xPos, long yPos,
-                                    wxObject *clientData,
-                                    const wxString& helpString1,
-                                    const wxString& helpString2)
-{
-    wxToolBarTool *tool = new wxToolBarTool(index, bitmap, wxNullBitmap,
-                                            toggle, xPos, yPos,
-                                            helpString1, helpString2);
-    tool->m_clientData = clientData;
+    int width = r.right - r.left;

 
 

-    if (xPos > -1)
-        tool->m_x = xPos;
-    else
-        tool->m_x = m_xMargin;
+    if ( tool->IsControl() )
+    {
+        nButtonsToDelete = ((wxToolBarTool *)tool)->GetSeparatorsCount();

 
 

-    if (yPos > -1)
-        tool->m_y = yPos;
-    else
-        tool->m_y = m_yMargin;
+        width *= nButtonsToDelete;
+    }

 
 

-    tool->SetSize(GetToolSize().x, GetToolSize().y);
+    // do delete all buttons
+    m_nButtons -= nButtonsToDelete;
+    while ( nButtonsToDelete-- > 0 )
+    {
+        if ( !::SendMessage(GetHwnd(), TB_DELETEBUTTON, pos, 0) )
+        {
+            wxLogLastError(wxT("TB_DELETEBUTTON"));

 
 

-    m_tools.Append((long)index, tool);
+            return FALSE;
+        }
+    }

 
 

-    return tool;
+    tool->Detach();
+
+    // and finally reposition all the controls after this button (the toolbar
+    // takes care of all normal items)
+    for ( /* node -> first after deleted */ ; node; node = node->GetNext() )
+    {
+        wxToolBarToolBase *tool2 = node->GetData();
+        if ( tool2->IsControl() )
+        {
+            int x;
+            wxControl *control = tool2->GetControl();
+            control->GetPosition(&x, NULL);
+            control->Move(x - width, -1);
+        }
+    }
+
+    return TRUE;

 }
 
 }
 

-bool wxToolBar95::CreateTools()
+bool wxToolBar::Realize()

 {
 {

-    size_t nTools = m_tools.GetCount();
+    size_t nTools = GetToolsCount();

     if ( nTools == 0 )
     if ( nTools == 0 )

-        return FALSE;
+    {
+        // nothing to do
+        return TRUE;
+    }
+
+    bool isVertical = (GetWindowStyle() & wxTB_VERTICAL) != 0;

 
 

-    HBITMAP oldToolBarBitmap = (HBITMAP) m_hBitmap;
+    // First, add the bitmap: we use one bitmap for all toolbar buttons
+    // ----------------------------------------------------------------
+
+    // if we already have a bitmap, we'll replace the existing one - otherwise
+    // we'll install a new one
+    HBITMAP oldToolBarBitmap = (HBITMAP)m_hBitmap;

 
     int totalBitmapWidth = (int)(m_defaultWidth * nTools);
     int totalBitmapHeight = (int)m_defaultHeight;
 
 
     int totalBitmapWidth = (int)(m_defaultWidth * nTools);
     int totalBitmapHeight = (int)m_defaultHeight;
 

-    // Create a bitmap for all the tool bitmaps
-    HDC dc = ::GetDC(NULL);
-    m_hBitmap = (WXHBITMAP) ::CreateCompatibleBitmap(dc,
-                                                     totalBitmapWidth,
-                                                     totalBitmapHeight);
-    ::ReleaseDC(NULL, dc);
+    // Create a bitmap and copy all the tool bitmaps to it
+#if USE_BITMAP_MASKS
+    wxMemoryDC dcAllButtons;
+    wxBitmap bitmap(totalBitmapWidth, totalBitmapHeight);
+    dcAllButtons.SelectObject(bitmap);
+    dcAllButtons.SetBackground(*wxLIGHT_GREY_BRUSH);
+    dcAllButtons.Clear();
+
+    m_hBitmap = bitmap.GetHBITMAP();
+    HBITMAP hBitmap = (HBITMAP)m_hBitmap;
+#else // !USE_BITMAP_MASKS
+    HBITMAP hBitmap = ::CreateCompatibleBitmap(ScreenHDC(),
+                                               totalBitmapWidth,
+                                               totalBitmapHeight);
+    if ( !hBitmap )
+    {
+        wxLogLastError(_T("CreateCompatibleBitmap"));
+
+        return FALSE;
+    }
+
+    m_hBitmap = (WXHBITMAP)hBitmap;

 
 

-    // Now blit all the tools onto this bitmap

     HDC memoryDC = ::CreateCompatibleDC(NULL);
     HDC memoryDC = ::CreateCompatibleDC(NULL);

-    HBITMAP oldBitmap = (HBITMAP) ::SelectObject(memoryDC, (HBITMAP)m_hBitmap);
+    HBITMAP oldBitmap = (HBITMAP) ::SelectObject(memoryDC, hBitmap);

 
     HDC memoryDC2 = ::CreateCompatibleDC(NULL);
 
     HDC memoryDC2 = ::CreateCompatibleDC(NULL);

+#endif // USE_BITMAP_MASKS/!USE_BITMAP_MASKS

 
     // the button position
     wxCoord x = 0;
 
     // the number of buttons (not separators)
 
     // the button position
     wxCoord x = 0;
 
     // the number of buttons (not separators)

-    int noButtons = 0;
+    int nButtons = 0;

 
 

-    wxNode *node = m_tools.First();
-    while (node)
+    wxToolBarToolsList::Node *node = m_tools.GetFirst();
+    while ( node )

     {
     {

-        wxToolBarTool *tool = (wxToolBarTool *)node->Data();
-        if ( tool->m_toolStyle == wxTOOL_STYLE_BUTTON && tool->m_bitmap1.Ok() )
+        wxToolBarToolBase *tool = node->GetData();
+        if ( tool->IsButton() )

         {
         {

-            HBITMAP hbmp = GetHbitmapOf(tool->m_bitmap1);
-            if ( hbmp )
+            const wxBitmap& bmp = tool->GetBitmap1();
+            if ( bmp.Ok() )

             {
             {

+#if USE_BITMAP_MASKS
+                // notice the last parameter: do use mask
+                dcAllButtons.DrawBitmap(tool->GetBitmap1(), x, 0, TRUE);
+#else // !USE_BITMAP_MASKS
+                HBITMAP hbmp = GetHbitmapOf(bmp);

                 HBITMAP oldBitmap2 = (HBITMAP)::SelectObject(memoryDC2, hbmp);
                 if ( !BitBlt(memoryDC, x, 0,  m_defaultWidth, m_defaultHeight,
                              memoryDC2, 0, 0, SRCCOPY) )
                 {
                 HBITMAP oldBitmap2 = (HBITMAP)::SelectObject(memoryDC2, hbmp);
                 if ( !BitBlt(memoryDC, x, 0,  m_defaultWidth, m_defaultHeight,
                              memoryDC2, 0, 0, SRCCOPY) )
                 {

-                    wxLogLastError("BitBlt");
+                    wxLogLastError(wxT("BitBlt"));

                 }
 
                 ::SelectObject(memoryDC2, oldBitmap2);
                 }
 
                 ::SelectObject(memoryDC2, oldBitmap2);

-
-                x += m_defaultWidth;
-                noButtons++;
+#endif // USE_BITMAP_MASKS/!USE_BITMAP_MASKS

             }
             }

+            else
+            {
+                wxFAIL_MSG( _T("invalid tool button bitmap") );
+            }
+
+            // still inc width and number of buttons because otherwise the
+            // subsequent buttons will all be shifted which is rather confusing
+            // (and like this you'd see immediately which bitmap was bad)
+            x += m_defaultWidth;
+            nButtons++;

         }
         }

-        node = node->Next();
+
+        node = node->GetNext();

     }
 
     }
 

+#if USE_BITMAP_MASKS
+    dcAllButtons.SelectObject(wxNullBitmap);
+
+    // don't delete this HBITMAP!
+    bitmap.SetHBITMAP(0);
+#else // !USE_BITMAP_MASKS

     ::SelectObject(memoryDC, oldBitmap);
     ::DeleteDC(memoryDC);
     ::DeleteDC(memoryDC2);
     ::SelectObject(memoryDC, oldBitmap);
     ::DeleteDC(memoryDC);
     ::DeleteDC(memoryDC2);

+#endif // USE_BITMAP_MASKS/!USE_BITMAP_MASKS

 
     // Map to system colours
 
     // Map to system colours

-    wxMapBitmap((HBITMAP) m_hBitmap, totalBitmapWidth, totalBitmapHeight);
+    MapBitmap((WXHBITMAP) hBitmap, totalBitmapWidth, totalBitmapHeight);
+
+    int bitmapId = 0;
+
+    bool addBitmap = TRUE;

 
     if ( oldToolBarBitmap )
     {
 
     if ( oldToolBarBitmap )
     {

-        TBREPLACEBITMAP replaceBitmap;
-        replaceBitmap.hInstOld = NULL;
-        replaceBitmap.hInstNew = NULL;
-        replaceBitmap.nIDOld = (UINT) oldToolBarBitmap;
-        replaceBitmap.nIDNew = (UINT) (HBITMAP) m_hBitmap;
-        replaceBitmap.nButtons = noButtons;
-        if ( ::SendMessage(GetHwnd(), TB_REPLACEBITMAP,
-                           0, (LPARAM) &replaceBitmap) == -1 )
+#ifdef TB_REPLACEBITMAP
+        if ( wxTheApp->GetComCtl32Version() >= 400 )

         {
         {

-            wxFAIL_MSG(wxT("Could not add bitmap to toolbar"));
+            TBREPLACEBITMAP replaceBitmap;
+            replaceBitmap.hInstOld = NULL;
+            replaceBitmap.hInstNew = NULL;
+            replaceBitmap.nIDOld = (UINT) oldToolBarBitmap;
+            replaceBitmap.nIDNew = (UINT) hBitmap;
+            replaceBitmap.nButtons = nButtons;
+            if ( !::SendMessage(GetHwnd(), TB_REPLACEBITMAP,
+                                0, (LPARAM) &replaceBitmap) )
+            {
+                wxFAIL_MSG(wxT("Could not replace the old bitmap"));
+            }
+
+            ::DeleteObject(oldToolBarBitmap);
+
+            // already done
+            addBitmap = FALSE;

         }
         }

+        else
+#endif // TB_REPLACEBITMAP
+        {
+            // we can't replace the old bitmap, so we will add another one
+            // (awfully inefficient, but what else to do?) and shift the bitmap
+            // indices accordingly
+            addBitmap = TRUE;

 
 

-        ::DeleteObject((HBITMAP) oldToolBarBitmap);
+            bitmapId = m_nButtons;
+        }

 
         // Now delete all the buttons
 
         // Now delete all the buttons

-        int i = 0;
-        while ( TRUE )
+        for ( size_t pos = 0; pos < m_nButtons; pos++ )

         {
         {

-            // TODO: What about separators???? They don't have an id!
-            if ( ! ::SendMessage( GetHwnd(), TB_DELETEBUTTON, i, 0 ) )
-                break;
+            if ( !::SendMessage(GetHwnd(), TB_DELETEBUTTON, 0, 0) )
+            {
+                wxLogDebug(wxT("TB_DELETEBUTTON failed"));
+            }

         }
         }

+

     }
     }

-    else
+
+    if ( addBitmap ) // no old bitmap or we can't replace it

     {
         TBADDBITMAP addBitmap;
         addBitmap.hInst = 0;
     {
         TBADDBITMAP addBitmap;
         addBitmap.hInst = 0;

-        addBitmap.nID = (UINT)m_hBitmap;
+        addBitmap.nID = (UINT) hBitmap;

         if ( ::SendMessage(GetHwnd(), TB_ADDBITMAP,
         if ( ::SendMessage(GetHwnd(), TB_ADDBITMAP,

-                           (WPARAM) noButtons, (LPARAM)&addBitmap) == -1 )
+                           (WPARAM) nButtons, (LPARAM)&addBitmap) == -1 )

         {
             wxFAIL_MSG(wxT("Could not add bitmap to toolbar"));
         }
     }
 
         {
             wxFAIL_MSG(wxT("Could not add bitmap to toolbar"));
         }
     }
 

-    // Now add the buttons.
+    // Next add the buttons and separators
+    // -----------------------------------
+

     TBBUTTON *buttons = new TBBUTTON[nTools];
 
     TBBUTTON *buttons = new TBBUTTON[nTools];
 

-    // this array will holds the indices of all controls in the toolbar
+    // this array will hold the indices of all controls in the toolbar

     wxArrayInt controlIds;
 
     int i = 0;
     wxArrayInt controlIds;
 
     int i = 0;

-    int bitmapId = 0;
-
-    node = m_tools.First();
-    while (node)
+    for ( node = m_tools.GetFirst(); node; node = node->GetNext() )

     {
     {

-        wxToolBarTool *tool = (wxToolBarTool *)node->Data();
+        wxToolBarToolBase *tool = node->GetData();
+
+        // don't add separators to the vertical toolbar - looks ugly
+        if ( isVertical && tool->IsSeparator() )
+            continue;
+

         TBBUTTON& button = buttons[i];
 
         wxZeroMemory(button);
 
         TBBUTTON& button = buttons[i];
 
         wxZeroMemory(button);
 

-        switch ( tool->m_toolStyle )
+        switch ( tool->GetStyle() )

         {
             case wxTOOL_STYLE_CONTROL:
         {
             case wxTOOL_STYLE_CONTROL:

-                controlIds.Add(i);
-                button.idCommand = tool->m_index;
+                button.idCommand = tool->GetId();

                 // fall through: create just a separator too
 
             case wxTOOL_STYLE_SEPARATOR:
                 // fall through: create just a separator too
 
             case wxTOOL_STYLE_SEPARATOR:


@@ -374,57 +573,112 @@ bool wxToolBar95::CreateTools()
 
             case wxTOOL_STYLE_BUTTON:
                 button.iBitmap = bitmapId;
 
             case wxTOOL_STYLE_BUTTON:
                 button.iBitmap = bitmapId;

-                button.idCommand = tool->m_index;
+                button.idCommand = tool->GetId();

 
 

-                if (tool->m_enabled)
+                if ( tool->IsEnabled() )

                     button.fsState |= TBSTATE_ENABLED;
                     button.fsState |= TBSTATE_ENABLED;

-                if (tool->m_toggleState)
+                if ( tool->IsToggled() )

                     button.fsState |= TBSTATE_CHECKED;
                     button.fsState |= TBSTATE_CHECKED;

-                button.fsStyle = tool->m_isToggle ? TBSTYLE_CHECK
-                                                  : TBSTYLE_BUTTON;
+
+                button.fsStyle = tool->CanBeToggled() ? TBSTYLE_CHECK
+                                                      : TBSTYLE_BUTTON;

 
                 bitmapId++;
                 break;
         }
 
         i++;
 
                 bitmapId++;
                 break;
         }
 
         i++;

-        node = node->Next();

     }
 
     if ( !::SendMessage(GetHwnd(), TB_ADDBUTTONS,
                         (WPARAM)i, (LPARAM)buttons) )
     {
     }
 
     if ( !::SendMessage(GetHwnd(), TB_ADDBUTTONS,
                         (WPARAM)i, (LPARAM)buttons) )
     {

-        wxLogLastError("TB_ADDBUTTONS");
+        wxLogLastError(wxT("TB_ADDBUTTONS"));

     }
 
     delete [] buttons;
 
     }
 
     delete [] buttons;
 

+    // Deal with the controls finally
+    // ------------------------------
+

     // adjust the controls size to fit nicely in the toolbar
     // adjust the controls size to fit nicely in the toolbar

-    size_t nControls = controlIds.GetCount();
-    for ( size_t nCtrl = 0; nCtrl < nControls; nCtrl++ )
+    size_t index = 0;
+    for ( node = m_tools.GetFirst(); node; node = node->GetNext(), index++ )

     {
     {

-        wxToolBarTool *tool = (wxToolBarTool *)
-                                m_tools.Nth(controlIds[nCtrl])->Data();
+        wxToolBarToolBase *tool = node->GetData();
+        if ( !tool->IsControl() )
+            continue;
+

         wxControl *control = tool->GetControl();
 
         wxSize size = control->GetSize();
 
         wxControl *control = tool->GetControl();
 
         wxSize size = control->GetSize();
 

-        // set the (underlying) separators width to be that of the control
-        TBBUTTONINFO tbbi;
-        tbbi.cbSize = sizeof(tbbi);
-        tbbi.dwMask = TBIF_SIZE;
-        tbbi.cx = size.x;
-        if ( !SendMessage(GetHwnd(), TB_SETBUTTONINFO,
-                          tool->m_index, (LPARAM)&tbbi) )
+        // the position of the leftmost controls corner
+        int left = -1;
+
+        // note that we use TB_GETITEMRECT and not TB_GETRECT because the
+        // latter only appeared in v4.70 of comctl32.dll
+        RECT r;
+        if ( !SendMessage(GetHwnd(), TB_GETITEMRECT,
+                          index, (LPARAM)(LPRECT)&r) )

         {
         {

-            // the index is probably invalid
-            wxLogLastError("TB_SETBUTTONINFO");
+            wxLogLastError(wxT("TB_GETITEMRECT"));

         }
 
         }
 

-        // and position the control itself correctly vertically
-        RECT r;
-        SendMessage(GetHwnd(), TB_GETRECT, 0, (LPARAM)(LPRECT)&r);
+        // TB_SETBUTTONINFO message is only supported by comctl32.dll 4.71+
+        #if defined(_WIN32_IE) && (_WIN32_IE >= 0x400 )
+            // available in headers, now check whether it is available now
+            // (during run-time)
+            if ( wxTheApp->GetComCtl32Version() >= 471 )
+            {
+                // set the (underlying) separators width to be that of the
+                // control
+                TBBUTTONINFO tbbi;
+                tbbi.cbSize = sizeof(tbbi);
+                tbbi.dwMask = TBIF_SIZE;
+                tbbi.cx = size.x;
+                if ( !SendMessage(GetHwnd(), TB_SETBUTTONINFO,
+                                  tool->GetId(), (LPARAM)&tbbi) )
+                {
+                    // the id is probably invalid?
+                    wxLogLastError(wxT("TB_SETBUTTONINFO"));
+                }
+            }
+            else
+        #endif // comctl32.dll 4.71
+            // TB_SETBUTTONINFO unavailable
+            {
+                // try adding several separators to fit the controls width
+                int widthSep = r.right - r.left;
+                left = r.left;
+
+                TBBUTTON tbb;
+                wxZeroMemory(tbb);
+                tbb.idCommand = 0;
+                tbb.fsState = TBSTATE_ENABLED;
+                tbb.fsStyle = TBSTYLE_SEP;
+
+                size_t nSeparators = size.x / widthSep;
+                for ( size_t nSep = 0; nSep < nSeparators; nSep++ )
+                {
+                    if ( !SendMessage(GetHwnd(), TB_INSERTBUTTON,
+                                      index, (LPARAM)&tbb) )
+                    {
+                        wxLogLastError(wxT("TB_INSERTBUTTON"));
+                    }

 
 

+                    index++;
+                }
+
+                // remember the number of separators we used - we'd have to
+                // delete all of them later
+                ((wxToolBarTool *)tool)->SetSeparatorsCount(nSeparators);
+
+                // adjust the controls width to exactly cover the separators
+                control->SetSize((nSeparators + 1)*widthSep, -1);
+            }
+
+        // and position the control itself correctly vertically

         int height = r.bottom - r.top;
         int diff = height - size.y;
         if ( diff < 0 )
         int height = r.bottom - r.top;
         int diff = height - size.y;
         if ( diff < 0 )


@@ -435,12 +689,29 @@ bool wxToolBar95::CreateTools()
             diff = 2;
         }
 
             diff = 2;
         }
 

-        control->Move(r.left, r.top + diff / 2);
+        control->Move(left == -1 ? r.left : left, r.top + (diff + 1) / 2);

     }
 
     }
 

-    (void)::SendMessage(GetHwnd(), TB_AUTOSIZE, (WPARAM)0, (LPARAM) 0);
+    // the max index is the "real" number of buttons - i.e. counting even the
+    // separators which we added just for aligning the controls
+    m_nButtons = index;

 
 

-    SetRows(m_maxRows);
+    if ( !isVertical )
+    {
+        if ( m_maxRows == 0 )
+        {
+            // if not set yet, only one row
+            SetRows(1);
+        }
+    }
+    else if ( m_nButtons > 0 ) // vertical non empty toolbar
+    {
+        if ( m_maxRows == 0 )
+        {
+            // if not set yet, have one column
+            SetRows(m_nButtons);
+        }
+    }

 
     return TRUE;
 }
 
     return TRUE;
 }


@@ -449,33 +720,37 @@ bool wxToolBar95::CreateTools()
 // message handlers
 // ----------------------------------------------------------------------------
 
 // message handlers
 // ----------------------------------------------------------------------------
 

-bool wxToolBar95::MSWCommand(WXUINT cmd, WXWORD id)
+bool wxToolBar::MSWCommand(WXUINT WXUNUSED(cmd), WXWORD id)

 {
 {

-    wxNode *node = m_tools.Find((long)id);
-    if (!node)
+    wxToolBarToolBase *tool = FindById((int)id);
+    if ( !tool )

         return FALSE;
 
         return FALSE;
 

-    wxToolBarTool *tool = (wxToolBarTool *)node->Data();
-    if (tool->m_isToggle)
+    if ( tool->CanBeToggled() )

     {
         LRESULT state = ::SendMessage(GetHwnd(), TB_GETSTATE, id, 0);
     {
         LRESULT state = ::SendMessage(GetHwnd(), TB_GETSTATE, id, 0);

-        tool->m_toggleState = state & TBSTATE_CHECKED;
+        tool->Toggle((state & TBSTATE_CHECKED) != 0);

     }
 
     }
 

-    BOOL ret = OnLeftClick((int)id, tool->m_toggleState);
-    if ( ret == FALSE && tool->m_isToggle )
+    bool toggled = tool->IsToggled();
+
+    // OnLeftClick() can veto the button state change - for buttons which may
+    // be toggled only, of couse
+    if ( !OnLeftClick((int)id, toggled) && tool->CanBeToggled() )

     {
     {

-        tool->m_toggleState = !tool->m_toggleState;
-        ::SendMessage(GetHwnd(), TB_CHECKBUTTON,
-                      (WPARAM)id, (LPARAM)MAKELONG(tool->m_toggleState, 0));
+        // revert back
+        toggled = !toggled;
+        tool->SetToggle(toggled);
+
+        ::SendMessage(GetHwnd(), TB_CHECKBUTTON, id, MAKELONG(toggled, 0));

     }
 
     return TRUE;
 }
 
     }
 
     return TRUE;
 }
 

-bool wxToolBar95::MSWOnNotify(int WXUNUSED(idCtrl),
+bool wxToolBar::MSWOnNotify(int WXUNUSED(idCtrl),

                             WXLPARAM lParam,
                             WXLPARAM lParam,

-                            WXLPARAM *result)
+                            WXLPARAM *WXUNUSED(result))

 {
     // First check if this applies to us
     NMHDR *hdr = (NMHDR *)lParam;
 {
     // First check if this applies to us
     NMHDR *hdr = (NMHDR *)lParam;


@@ -492,13 +767,12 @@ bool wxToolBar95::MSWOnNotify(int WXUNUSED(idCtrl),
 
     LPTOOLTIPTEXT ttText = (LPTOOLTIPTEXT)lParam;
     int id = (int)ttText->hdr.idFrom;
 
     LPTOOLTIPTEXT ttText = (LPTOOLTIPTEXT)lParam;
     int id = (int)ttText->hdr.idFrom;

-    wxNode *node = m_tools.Find((long)id);
-    if (!node)
-        return FALSE;

 
 

-    wxToolBarTool *tool = (wxToolBarTool *)node->Data();
+    wxToolBarToolBase *tool = FindById(id);
+    if ( !tool )
+        return FALSE;

 
 

-    const wxString& help = tool->m_shortHelpString;
+    const wxString& help = tool->GetShortHelp();

 
     if ( !help.IsEmpty() )
     {
 
     if ( !help.IsEmpty() )
     {


@@ -506,11 +780,17 @@ bool wxToolBar95::MSWOnNotify(int WXUNUSED(idCtrl),
         {
             ttText->lpszText = (wxChar *)help.c_str();
         }
         {
             ttText->lpszText = (wxChar *)help.c_str();
         }

-#if (_WIN32_IE >= 0x0300)

         else
         {
         else
         {

-            // FIXME this is a temp hack only until I understand better what
-            //       must be done in both ANSI and Unicode builds
+#if wxUSE_UNICODE
+            ttText->lpszText = (wxChar *)help.c_str();
+#else
+            // VZ: I don't know why it happens, but the versions of
+            //     comctl32.dll starting from 4.70 sometimes send TTN_NEEDTEXTW
+            //     even to ANSI programs (normally, this message is supposed
+            //     to be sent to Unicode programs only) - hence we need to
+            //     handle it as well, otherwise no tooltips will be shown in
+            //     this case

 
             size_t lenAnsi = help.Len();
             #ifdef __MWERKS__
 
             size_t lenAnsi = help.Len();
             #ifdef __MWERKS__


@@ -531,92 +811,116 @@ bool wxToolBar95::MSWOnNotify(int WXUNUSED(idCtrl),
             dst[lenUnicode] = 0;
 
             delete [] pwz;
             dst[lenUnicode] = 0;
 
             delete [] pwz;

+#endif

         }
         }

-#endif // _WIN32_IE >= 0x0300

     }
 
     // For backward compatibility...
     }
 
     // For backward compatibility...

-    OnMouseEnter(tool->m_index);
+    OnMouseEnter(tool->GetId());

 
     return TRUE;
 }
 
 // ----------------------------------------------------------------------------
 
     return TRUE;
 }
 
 // ----------------------------------------------------------------------------

-// sizing stuff
+// toolbar geometry

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

-void wxToolBar95::SetToolBitmapSize(const wxSize& size)
+void wxToolBar::SetToolBitmapSize(const wxSize& size)

 {
     wxToolBarBase::SetToolBitmapSize(size);
 
     ::SendMessage(GetHwnd(), TB_SETBITMAPSIZE, 0, MAKELONG(size.x, size.y));
 }
 
 {
     wxToolBarBase::SetToolBitmapSize(size);
 
     ::SendMessage(GetHwnd(), TB_SETBITMAPSIZE, 0, MAKELONG(size.x, size.y));
 }
 

-void wxToolBar95::SetRows(int nRows)
+void wxToolBar::SetRows(int nRows)

 {
 {

-    // TRUE in wParam means to create at least as many rows
+    if ( nRows == m_maxRows )
+    {
+        // avoid resizing the frame uselessly
+        return;
+    }
+
+    // TRUE in wParam means to create at least as many rows, FALSE -
+    // at most as many

     RECT rect;
     ::SendMessage(GetHwnd(), TB_SETROWS,
     RECT rect;
     ::SendMessage(GetHwnd(), TB_SETROWS,

-                  MAKEWPARAM(nRows, TRUE), (LPARAM) &rect);
-
-    m_maxWidth = (rect.right - rect.left + 2);
-    m_maxHeight = (rect.bottom - rect.top + 2);
+                  MAKEWPARAM(nRows, !(GetWindowStyle() & wxTB_VERTICAL)),
+                  (LPARAM) &rect);

 
     m_maxRows = nRows;
 
     m_maxRows = nRows;

+
+    UpdateSize();
+}
+
+// The button size is bigger than the bitmap size
+wxSize wxToolBar::GetToolSize() const
+{
+    // TB_GETBUTTONSIZE is supported from version 4.70
+#if defined(_WIN32_IE) && (_WIN32_IE >= 0x300 ) \
+    && !( defined(__GNUWIN32__) && !wxCHECK_W32API_VERSION( 1, 0 ) )
+    if ( wxTheApp->GetComCtl32Version() >= 470 )
+    {
+        DWORD dw = ::SendMessage(GetHwnd(), TB_GETBUTTONSIZE, 0, 0);
+
+        return wxSize(LOWORD(dw), HIWORD(dw));
+    }
+    else
+#endif // comctl32.dll 4.70+
+    {
+        // defaults
+        return wxSize(m_defaultWidth + 8, m_defaultHeight + 7);
+    }

 }
 
 }
 

-wxSize wxToolBar95::GetMaxSize() const
+wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord x, wxCoord y) const

 {
 {

-    if ( (m_maxWidth == -1) || (m_maxHeight == -1) )
+    POINT pt;
+    pt.x = x;
+    pt.y = y;
+    int index = (int)::SendMessage(GetHwnd(), TB_HITTEST, 0, (LPARAM)&pt);
+    if ( index < 0 )

     {
     {

-        // it has a side effect of filling m_maxWidth/Height variables
-        ((wxToolBar95 *)this)->SetRows(m_maxRows);  // const_cast
+        // it's a separator or there is no tool at all there
+        return (wxToolBarToolBase *)NULL;

     }
 
     }
 

-    return wxSize(m_maxWidth, m_maxHeight);
+    return m_tools.Item((size_t)index)->GetData();

 }
 
 }
 

-// The button size is bigger than the bitmap size
-wxSize wxToolBar95::GetToolSize() const
+void wxToolBar::UpdateSize()

 {
 {

-    // FIXME: this is completely bogus (VZ)
-    return wxSize(m_defaultWidth + 8, m_defaultHeight + 7);
+    // the toolbar size changed
+    SendMessage(GetHwnd(), TB_AUTOSIZE, 0, 0);
+
+    // we must also refresh the frame after the toolbar size (possibly) changed
+    wxFrame *frame = wxDynamicCast(GetParent(), wxFrame);
+    if ( frame )
+    {
+        frame->SendSizeEvent();
+    }

 }
 
 // ----------------------------------------------------------------------------
 // tool state
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // tool state
 // ----------------------------------------------------------------------------
 

-void wxToolBar95::EnableTool(int toolIndex, bool enable)
+void wxToolBar::DoEnableTool(wxToolBarToolBase *tool, bool enable)

 {
 {

-    wxNode *node = m_tools.Find((long)toolIndex);
-    if (node)
-    {
-        wxToolBarTool *tool = (wxToolBarTool *)node->Data();
-        tool->m_enabled = enable;
-        ::SendMessage(GetHwnd(), TB_ENABLEBUTTON,
-                      (WPARAM)toolIndex, (LPARAM)MAKELONG(enable, 0));
-    }
+    ::SendMessage(GetHwnd(), TB_ENABLEBUTTON,
+                  (WPARAM)tool->GetId(), (LPARAM)MAKELONG(enable, 0));

 }
 
 }
 

-void wxToolBar95::ToggleTool(int toolIndex, bool toggle)
+void wxToolBar::DoToggleTool(wxToolBarToolBase *tool, bool toggle)

 {
 {

-    wxNode *node = m_tools.Find((long)toolIndex);
-    if (node)
-    {
-        wxToolBarTool *tool = (wxToolBarTool *)node->Data();
-        if (tool->m_isToggle)
-        {
-            tool->m_toggleState = toggle;
-            ::SendMessage(GetHwnd(), TB_CHECKBUTTON,
-                          (WPARAM)toolIndex, (LPARAM)MAKELONG(toggle, 0));
-        }
-    }
+    ::SendMessage(GetHwnd(), TB_CHECKBUTTON,
+                  (WPARAM)tool->GetId(), (LPARAM)MAKELONG(toggle, 0));

 }
 
 }
 

-bool wxToolBar95::GetToolState(int toolIndex) const
+void wxToolBar::DoSetToggle(wxToolBarToolBase *WXUNUSED(tool), bool WXUNUSED(toggle))

 {
 {

-    return (::SendMessage(GetHwnd(), TB_ISBUTTONCHECKED, (WPARAM)toolIndex, (LPARAM)0) != 0);
+    // VZ: AFAIK, the button has to be created either with TBSTYLE_CHECK or
+    //     without, so we really need to delete the button and recreate it here
+    wxFAIL_MSG( _T("not implemented") );

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -624,21 +928,25 @@ bool wxToolBar95::GetToolState(int toolIndex) const
 // ----------------------------------------------------------------------------
 
 // Responds to colour changes, and passes event on to children.
 // ----------------------------------------------------------------------------
 
 // Responds to colour changes, and passes event on to children.

-void wxToolBar95::OnSysColourChanged(wxSysColourChangedEvent& event)
+void wxToolBar::OnSysColourChanged(wxSysColourChangedEvent& event)

 {
 {

-    m_backgroundColour = wxColour(GetRValue(GetSysColor(COLOR_BTNFACE)),
-          GetGValue(GetSysColor(COLOR_BTNFACE)), GetBValue(GetSysColor(COLOR_BTNFACE)));
+    wxRGBToColour(m_backgroundColour, ::GetSysColor(COLOR_BTNFACE));

 
     // Remap the buttons
 
     // Remap the buttons

-    CreateTools();
+    Realize();
+
+    // Relayout the toolbar
+    int nrows = m_maxRows;
+    m_maxRows = 0;      // otherwise SetRows() wouldn't do anything
+    SetRows(nrows);

 
     Refresh();
 
 
     Refresh();
 

-    // Propagate the event to the non-top-level children
-    wxWindow::OnSysColourChanged(event);
+    // let the event propagate further
+    event.Skip();

 }
 
 }
 

-void wxToolBar95::OnMouseEvent(wxMouseEvent& event)
+void wxToolBar::OnMouseEvent(wxMouseEvent& event)

 {
     if (event.RightDown())
     {
 {
     if (event.RightDown())
     {


@@ -652,107 +960,172 @@ void wxToolBar95::OnMouseEvent(wxMouseEvent& event)
     }
 }
 
     }
 }
 

+long wxToolBar::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
+{
+    if ( nMsg == WM_SIZE )
+    {
+        // calculate our minor dimenstion ourselves - we're confusing the
+        // standard logic (TB_AUTOSIZE) with our horizontal toolbars and other
+        // hacks
+        RECT r;
+        if ( ::SendMessage(GetHwnd(), TB_GETITEMRECT, 0, (LPARAM)&r) )
+        {
+            int w, h;
+
+            if ( GetWindowStyle() & wxTB_VERTICAL )
+            {
+                w = r.right - r.left;
+                if ( m_maxRows )
+                {
+                    w *= (m_nButtons + m_maxRows - 1)/m_maxRows;
+                }
+                h = HIWORD(lParam);
+            }
+            else
+            {
+                w = LOWORD(lParam);
+                h = r.bottom - r.top;
+                if ( m_maxRows )
+                {
+                    h += 6; // FIXME: this is the separator line height...
+                    h *= m_maxRows;
+                }
+            }
+
+            if ( MAKELPARAM(w, h) != lParam )
+            {
+                // size really changed
+                SetSize(w, h);
+            }
+
+            // message processed
+            return 0;
+        }
+    }
+
+    return wxControl::MSWWindowProc(nMsg, wParam, lParam);
+}
+

 // ----------------------------------------------------------------------------
 // private functions
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // private functions
 // ----------------------------------------------------------------------------
 

-// These are the default colors used to map the bitmap colors
-// to the current system colors
-
-// VZ: why are they BGR and not RGB? just to confuse the people or is there a
-//     deeper reason?
-#define BGR_BUTTONTEXT      (RGB(000,000,000))  // black
-#define BGR_BUTTONSHADOW    (RGB(128,128,128))  // dark grey
-#define BGR_BUTTONFACE      (RGB(192,192,192))  // bright grey
-#define BGR_BUTTONHILIGHT   (RGB(255,255,255))  // white
-#define BGR_BACKGROUNDSEL   (RGB(255,000,000))  // blue
-#define BGR_BACKGROUND      (RGB(255,000,255))  // magenta
+bool wxToolBar::sm_coloursInit = FALSE;
+long wxToolBar::sm_stdColours[6];

 
 

-void wxMapBitmap(HBITMAP hBitmap, int width, int height)
+void wxToolBar::MapBitmap(WXHBITMAP bitmap, int width, int height)

 {
 {

-  COLORMAP ColorMap[] =
-  {
-    {BGR_BUTTONTEXT,    COLOR_BTNTEXT},     // black
-    {BGR_BUTTONSHADOW,  COLOR_BTNSHADOW},   // dark grey
-    {BGR_BUTTONFACE,    COLOR_BTNFACE},     // bright grey
-    {BGR_BUTTONHILIGHT, COLOR_BTNHIGHLIGHT},// white
-    {BGR_BACKGROUNDSEL, COLOR_HIGHLIGHT},   // blue
-    {BGR_BACKGROUND,    COLOR_WINDOW}       // magenta
-  };
-
-  int NUM_MAPS = (sizeof(ColorMap)/sizeof(COLORMAP));
-  int n;
-  for ( n = 0; n < NUM_MAPS; n++)
-  {
-    ColorMap[n].to = ::GetSysColor(ColorMap[n].to);
-  }
-
-  HBITMAP hbmOld;
-  HDC hdcMem = CreateCompatibleDC(NULL);
-
-  if (hdcMem)
-  {
-    hbmOld = (HBITMAP) SelectObject(hdcMem, hBitmap);
-
-    int i, j, k;
-    for ( i = 0; i < width; i++)
-    {
-        for ( j = 0; j < height; j++)
+    if (!sm_coloursInit)
+    {
+        // When a bitmap is loaded, the RGB values can change. So we need to have a
+        // reference bitmap which can tell us what the RGB values change to.
+        wxBitmap stdColourBitmap("wxBITMAP_STD_COLOURS", wxBITMAP_TYPE_RESOURCE);
+        if (stdColourBitmap.Ok())

         {
         {

-            COLORREF pixel = ::GetPixel(hdcMem, i, j);
-/*
-            BYTE red = GetRValue(pixel);
-            BYTE green = GetGValue(pixel);
-            BYTE blue = GetBValue(pixel);
-*/
-
-            for ( k = 0; k < NUM_MAPS; k ++)
+            wxMemoryDC memDC;
+            memDC.SelectObject(stdColourBitmap);
+
+            int i = 0;
+            wxColour colour;
+            for (i = 0; i < 6; i++)

             {
             {

-                if ( ColorMap[k].from == pixel )
-                {
-                    /* COLORREF actualPixel = */ ::SetPixel(hdcMem, i, j, ColorMap[k].to);
-                    break;
-                }
+                memDC.GetPixel(i, 0, & colour);
+                sm_stdColours[i] = RGB(colour.Red(), colour.Green(), colour.Blue());

             }
             }

+            sm_coloursInit = TRUE;
+            memDC.SelectObject(wxNullBitmap);
+        }
+        else
+        {
+            sm_stdColours[0] = RGB(000,000,000) ;
+            sm_stdColours[1] = RGB(128,128,128) ;
+            sm_stdColours[2] = RGB(192,192,192) ;
+            sm_stdColours[3] = RGB(255,255,255) ;
+            sm_stdColours[4] = RGB(000,000,255) ;
+            sm_stdColours[5] = RGB(255,000,255) ;
+            sm_coloursInit = TRUE;

         }
     }
 
         }
     }
 

+    HBITMAP hBitmap = (HBITMAP) bitmap;
+
+    COLORMAP ColorMap[5];

 
 

-    SelectObject(hdcMem, hbmOld);
-    DeleteObject(hdcMem);
-  }
+    ColorMap[0].from = sm_stdColours[0]; ColorMap[0].to = COLOR_BTNTEXT;      // black        (0, 0 0)
+    ColorMap[1].from = sm_stdColours[1]; ColorMap[1].to = COLOR_BTNSHADOW;    // dark grey    (128, 128, 128)
+    ColorMap[2].from = sm_stdColours[2]; ColorMap[2].to = COLOR_BTNFACE;      // bright grey  (192, 192, 192)
+    ColorMap[3].from = sm_stdColours[3]; ColorMap[3].to = COLOR_BTNHIGHLIGHT; // white        (255, 255, 255)
+    //  ColorMap[4].from = sm_stdColours[4]; ColorMap[4].to = COLOR_HIGHLIGHT;  // blue         (0, 0, 255)
+    ColorMap[4].from = sm_stdColours[5]; ColorMap[4].to = COLOR_WINDOW;       // magenta      (255, 0, 255)
+
+    for ( size_t n = 0; n < WXSIZEOF(ColorMap); n++)
+    {
+        ColorMap[n].to = ::GetSysColor(ColorMap[n].to);
+    }

 
 

+    HBITMAP hbmOld;
+    HDC hdcMem = CreateCompatibleDC(NULL);
+
+    if (hdcMem)
+    {
+        hbmOld = (HBITMAP) SelectObject(hdcMem, hBitmap);
+
+        for ( int i = 0; i < width; i++ )
+        {
+            for ( int j = 0; j < height; j++ )
+            {
+                COLORREF pixel = ::GetPixel(hdcMem, i, j);
+
+                for ( size_t k = 0; k < WXSIZEOF(ColorMap); k++ )
+                {
+                    int distance = abs( GetRValue( pixel ) - GetRValue( ColorMap[k].from )) ;
+                    distance = max( distance , abs(GetGValue(pixel ) - GetGValue( ColorMap[k].from ))) ;
+                    distance = max( distance , abs(GetBValue(pixel ) - GetBValue( ColorMap[k].from ))) ;
+                    if ( distance < 0x10 )
+                    {
+                        ::SetPixel(hdcMem, i, j, ColorMap[k].to);
+                        break;
+                    }
+                }
+            }
+        }
+
+
+        SelectObject(hdcMem, hbmOld);
+        DeleteObject(hdcMem);
+    }

 }
 
 // Some experiments...
 #if 0
 }
 
 // Some experiments...
 #if 0

-  // What we want to do is create another bitmap which has a depth of 4,
-  // and set the bits. So probably we want to convert this HBITMAP into a
-  // DIB, then call SetDIBits.
-  // AAAGH. The stupid thing is that if newBitmap has a depth of 4 (less than that of
-  // the screen), then SetDIBits fails.
-  HBITMAP newBitmap = ::CreateBitmap(totalBitmapWidth, totalBitmapHeight, 1, 4, NULL);
-  HANDLE newDIB = ::BitmapToDIB((HBITMAP) m_hBitmap, NULL);
-  LPBITMAPINFOHEADER lpbmi = (LPBITMAPINFOHEADER) GlobalLock(newDIB);
-
-  dc = ::GetDC(NULL);
+// What we want to do is create another bitmap which has a depth of 4,
+// and set the bits. So probably we want to convert this HBITMAP into a
+// DIB, then call SetDIBits.
+// AAAGH. The stupid thing is that if newBitmap has a depth of 4 (less than that of
+// the screen), then SetDIBits fails.
+HBITMAP newBitmap = ::CreateBitmap(totalBitmapWidth, totalBitmapHeight, 1, 4, NULL);
+HANDLE newDIB = ::BitmapToDIB((HBITMAP) m_hBitmap, NULL);
+LPBITMAPINFOHEADER lpbmi = (LPBITMAPINFOHEADER) GlobalLock(newDIB);
+
+dc = ::GetDC(NULL);

 //  LPBITMAPINFOHEADER lpbmi = (LPBITMAPINFOHEADER) newDIB;
 
 //  LPBITMAPINFOHEADER lpbmi = (LPBITMAPINFOHEADER) newDIB;
 

-  int result = ::SetDIBits(dc, newBitmap, 0, lpbmi->biHeight, FindDIBBits((LPSTR)lpbmi), (LPBITMAPINFO)lpbmi,
-    DIB_PAL_COLORS);
-  DWORD err = GetLastError();
+int result = ::SetDIBits(dc, newBitmap, 0, lpbmi->biHeight, FindDIBBits((LPSTR)lpbmi), (LPBITMAPINFO)lpbmi,
+                         DIB_PAL_COLORS);
+DWORD err = GetLastError();

 
 

-  ::ReleaseDC(NULL, dc);
+::ReleaseDC(NULL, dc);

 
 

-  // Delete the DIB
-  GlobalUnlock (newDIB);
-  GlobalFree (newDIB);
+// Delete the DIB
+GlobalUnlock (newDIB);
+GlobalFree (newDIB);

 
 //  WXHBITMAP hBitmap2 = wxCreateMappedBitmap((WXHINSTANCE) wxGetInstance(), (WXHBITMAP) m_hBitmap);
 
 //  WXHBITMAP hBitmap2 = wxCreateMappedBitmap((WXHINSTANCE) wxGetInstance(), (WXHBITMAP) m_hBitmap);

-  // Substitute our new bitmap for the old one
-  ::DeleteObject((HBITMAP) m_hBitmap);
-  m_hBitmap = (WXHBITMAP) newBitmap;
+// Substitute our new bitmap for the old one
+::DeleteObject((HBITMAP) m_hBitmap);
+m_hBitmap = (WXHBITMAP) newBitmap;

 #endif
 
 
 #endif
 
 

-#endif // !(wxUSE_TOOLBAR && Win95)
+#endif // wxUSE_TOOLBAR && Win95
+