fixes from the 2.2 branch

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

diff --git a/src/msw/tbar95.cpp b/src/msw/tbar95.cpp
index c4d19a9333c5200abb4bb45106035cbf7a555183..589df6cf6767abbdeace793076c1505e004d48db 100644 (file)
--- a/src/msw/tbar95.cpp
+++ b/src/msw/tbar95.cpp
@@ -1,483 +1,936 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        tbar95.cpp
-// Purpose:     wxToolBar95
+// Name:        msw/tbar95.cpp
+// Purpose:     wxToolBar

 // Author:      Julian Smart
 // Modified by:
 // Created:     04/01/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart and Markus Holzem
 // Author:      Julian Smart
 // Modified by:
 // Created:     04/01/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart and Markus Holzem

-// Licence:    wxWindows license
+// Licence:     wxWindows license

 /////////////////////////////////////////////////////////////////////////////
 
 /////////////////////////////////////////////////////////////////////////////
 

+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+

 #ifdef __GNUG__
 #ifdef __GNUG__

-#pragma implementation "tbar95.h"
+    #pragma implementation "tbar95.h"

 #endif
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
 #endif
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__

-#pragma hdrstop
+    #pragma hdrstop

 #endif
 
 #ifndef WX_PRECOMP
 #endif
 
 #ifndef WX_PRECOMP

-#include "wx.h"
+    #include "wx/frame.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"

 
 

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

 #endif
 
 #endif
 

-#include <windows.h>
+#include "wx/msw/private.h"

 
 

-#ifndef __GNUWIN32__
-#include <commctrl.h>
-#endif
+#ifndef __TWIN32__

 
 

-#ifdef __GNUWIN32__
-#include "wx/msw/gnuwin32/extra.h"
+#ifdef __GNUWIN32_OLD__
+    #include "wx/msw/gnuwin32/extra.h"
+#else
+    #include <commctrl.h>

 #endif
 
 #endif
 

+#endif // __TWIN32__
+

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

-#include "wx/tbar95.h"
-#include "wx/app.h"
-#include "wx/msw/private.h"
+#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
+// ----------------------------------------------------------------------------
+
+// these standard constants are not always defined in compilers headers

 
 // Styles
 #ifndef TBSTYLE_FLAT
 
 // Styles
 #ifndef TBSTYLE_FLAT

-#define TBSTYLE_LIST            0x1000
-#define TBSTYLE_FLAT            0x0800
-#define TBSTYLE_TRANSPARENT     0x8000
+    #define TBSTYLE_LIST            0x1000
+    #define TBSTYLE_FLAT            0x0800
+    #define TBSTYLE_TRANSPARENT     0x8000

 #endif
  // use TBSTYLE_TRANSPARENT if you use TBSTYLE_FLAT
 
 // Messages
 #ifndef TB_GETSTYLE
 #endif
  // use TBSTYLE_TRANSPARENT if you use TBSTYLE_FLAT
 
 // 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
 
 #endif
 

-/* Hint from a newsgroup for custom flatbar drawing:
-Set the TBSTYLE_CUSTOMERASE style, then handle the
-NM_CUSTOMDRAW message and do your custom drawing.
-*/
+#ifndef TB_HITTEST
+    #define TB_HITTEST              (WM_USER + 69)
+#endif

 
 

+// these values correspond to those used by comctl32.dll

 #define DEFAULTBITMAPX   16
 #define DEFAULTBITMAPY   15
 #define DEFAULTBUTTONX   24
 #define DEFAULTBUTTONY   24
 #define DEFAULTBARHEIGHT 27
 
 #define DEFAULTBITMAPX   16
 #define DEFAULTBITMAPY   15
 #define DEFAULTBUTTONX   24
 #define DEFAULTBUTTONY   24
 #define DEFAULTBARHEIGHT 27
 

-#if !USE_SHARED_LIBRARY
-IMPLEMENT_DYNAMIC_CLASS(wxToolBar95, wxToolBarBase)
+// ----------------------------------------------------------------------------
+// private function prototypes
+// ----------------------------------------------------------------------------
+
+// adjust toolbar bitmap colours
+static void wxMapBitmap(HBITMAP hBitmap, int width, int height);
+
+// ----------------------------------------------------------------------------
+// wxWin macros
+// ----------------------------------------------------------------------------

 
 

-BEGIN_EVENT_TABLE(wxToolBar95, wxToolBarBase)
-       EVT_SIZE(wxToolBar95::OnSize)
-       EVT_PAINT(wxToolBar95::OnPaint)
-       EVT_KILL_FOCUS(wxToolBar95::OnKillFocus)
-       EVT_MOUSE_EVENTS(wxToolBar95::OnMouseEvent)
-    EVT_SYS_COLOUR_CHANGED(wxToolBar95::OnSysColourChanged)
+IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxToolBarBase)
+
+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
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// wxToolBarTool
+// ----------------------------------------------------------------------------
+
+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_hBitmap = 0;
+
+    m_nButtons = 0;
+
+    m_defaultWidth = DEFAULTBITMAPX;
+    m_defaultHeight = DEFAULTBITMAPY;
+}
+
+bool wxToolBar::Create(wxWindow *parent,
+                       wxWindowID id,
+                       const wxPoint& pos,
+                       const wxSize& size,
+                       long style,
+                       const wxString& name)
+{
+    // common initialisation
+    if ( !CreateControl(parent, id, pos, size, style, wxDefaultValidator, name) )
+        return FALSE;
+
+    // prepare flags
+    DWORD msflags = 0;      // WS_VISIBLE | WS_CHILD always included
+    if (style & wxBORDER)
+        msflags |= WS_BORDER;
+
+#ifdef TBSTYLE_TOOLTIPS
+    msflags |= TBSTYLE_TOOLTIPS;

 #endif
 
 #endif
 

-void wxMapBitmap(HBITMAP hBitmap, int width, int height);
+    if (style & wxTB_FLAT)
+    {
+        if (wxTheApp->GetComCtl32Version() > 400)
+            msflags |= TBSTYLE_FLAT;
+    }
+
+    // MSW-specific initialisation
+    if ( !wxControl::MSWCreateControl(TOOLBARCLASSNAME, msflags) )
+        return FALSE;
+
+    // toolbar-specific post initialisation
+    ::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));

 
 

-wxToolBar95::wxToolBar95(void)
+    // position it
+    int x = pos.x;
+    int y = pos.y;
+    int width = size.x;
+    int height = size.y;
+
+    if (width <= 0)
+        width = 100;
+    if (height <= 0)
+        height = m_defaultHeight;
+    if (x < 0)
+        x = 0;
+    if (y < 0)
+        y = 0;
+
+    SetSize(x, y, width, height);
+
+    return TRUE;
+}
+
+wxToolBar::~wxToolBar()

 {
 {

-  m_maxWidth = -1;
-  m_maxHeight = -1;
-  m_hBitmap = 0;
-  m_defaultWidth = DEFAULTBITMAPX;
-  m_defaultHeight = DEFAULTBITMAPY;
+    // 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 )
+    {
+        ::DeleteObject((HBITMAP) m_hBitmap);
+    }

 }
 
 }
 

-bool wxToolBar95::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size,
-            long style, const wxString& name)
+// ----------------------------------------------------------------------------
+// adding/removing tools
+// ----------------------------------------------------------------------------
+
+bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos),
+                             wxToolBarToolBase *tool)

 {
 {

-  m_backgroundColour = wxColour(GetRValue(GetSysColor(COLOR_BTNFACE)),
-       GetGValue(GetSysColor(COLOR_BTNFACE)), GetBValue(GetSysColor(COLOR_BTNFACE)));
-  m_foregroundColour = *wxBLACK ;
-
-  if (style & wxTB_VERTICAL)
-    wxMessageBox("Sorry, wxToolBar95 under Windows 95 only supports horizontal orientation.", "wxToolBar95 usage", wxOK);
-  m_maxWidth = -1;
-  m_maxHeight = -1;
-  
-  m_hBitmap = 0;
-
-  m_defaultWidth = DEFAULTBITMAPX;
-  m_defaultHeight = DEFAULTBITMAPY;
-  SetName(name);
-
-  int x = pos.x;
-  int y = pos.y;
-  int width = size.x;
-  int height = size.y;
-
-  m_windowStyle = style;
-
-  SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
-
-  SetParent(parent);
-
-  DWORD msflags = 0;
-  if (style & wxBORDER)
-    msflags |= WS_BORDER;
-  msflags |= WS_CHILD | WS_VISIBLE;
-  
-  if (width <= 0)
-    width = 100;
-  if (height <= 0)
-    height = 30;
-  if (x < 0)
-    x = 0;
-  if (y < 0)
-    y = 0;
-
-  m_windowId = (id < 0 ? NewControlId() : id);
-  DWORD msStyle = WS_CHILD | WS_BORDER | WS_VISIBLE | TBSTYLE_TOOLTIPS;
-
-  if (style & wxTB_FLAT)
-  {
-    if (wxTheApp->GetComCtl32Version() > 400)
-        msStyle |= TBSTYLE_FLAT;
-  }
+    // nothing special to do here - we really create the toolbar buttons in
+    // Realize() later
+    tool->Attach(this);

 
 

-  // Create the toolbar control.
-  HWND hWndToolbar = CreateWindowEx(0L,   // No extended styles.
-    TOOLBARCLASSNAME,                 // Class name for the toolbar.
-    "",                               // No default text.
-    msStyle,    // Styles and defaults.
-    x, y, width, height,                    // Standard toolbar size and position.
-    (HWND) parent->GetHWND(),                       // Parent window of the toolbar.
-    (HMENU)m_windowId,                // Toolbar ID.
-    wxGetInstance(),                            // Current instance.
-    NULL );                           // No class data.
-
-  // Toolbar-specific initialisation
-  ::SendMessage(hWndToolbar, TB_BUTTONSTRUCTSIZE, (WPARAM)sizeof(TBBUTTON), (LPARAM)0);
-
-  m_hWnd = (WXHWND) hWndToolbar;
-  if (parent) parent->AddChild(this);
-  
-  SubclassWin((WXHWND) hWndToolbar);
-
-  return TRUE;
+    return TRUE;

 }
 
 }
 

-wxToolBar95::~wxToolBar95(void)
+bool wxToolBar::DoDeleteTool(size_t pos, wxToolBarToolBase *tool)

 {
 {

-  UnsubclassWin();
+    // 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();

 
 

-  if (m_hBitmap)
-  {
-    ::DeleteObject((HBITMAP) m_hBitmap);
-    m_hBitmap = 0;
-  }
+            break;
+        }
+
+        if ( tool2->IsControl() )
+        {
+            pos += ((wxToolBarTool *)tool2)->GetSeparatorsCount();
+        }
+    }
+
+    // now determine the number of buttons to delete and the area taken by them
+    size_t nButtonsToDelete = 1;
+
+    // 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"));
+    }
+
+    int width = r.right - r.left;
+
+    if ( tool->IsControl() )
+    {
+        nButtonsToDelete = ((wxToolBarTool *)tool)->GetSeparatorsCount();
+
+        width *= nButtonsToDelete;
+    }
+
+    // do delete all buttons
+    m_nButtons -= nButtonsToDelete;
+    while ( nButtonsToDelete-- > 0 )
+    {
+        if ( !::SendMessage(GetHwnd(), TB_DELETEBUTTON, pos, 0) )
+        {
+            wxLogLastError(wxT("TB_DELETEBUTTON"));
+
+            return FALSE;
+        }
+    }
+
+    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(void)
+bool wxToolBar::Realize()

 {
 {

-  if (m_tools.Number() == 0)
-    return FALSE;
+    size_t nTools = GetToolsCount();
+    if ( nTools == 0 )
+    {
+        // nothing to do
+        return TRUE;
+    }

 
 

-  HBITMAP oldToolBarBitmap = (HBITMAP) m_hBitmap;
-    
-  int totalBitmapWidth = (int)(m_defaultWidth * m_tools.Number());
-  int totalBitmapHeight = (int)m_defaultHeight;
+    bool isVertical = (GetWindowStyle() & wxTB_VERTICAL) != 0;
+
+    // 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;
+
+    // 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"));

 
 

-  // Create a bitmap for all the tool bitmaps
-  HDC dc = ::GetDC(NULL);
-  m_hBitmap = (WXHBITMAP) ::CreateCompatibleBitmap(dc, totalBitmapWidth, totalBitmapHeight);
-  ::ReleaseDC(NULL, dc);
-  
-  // Now blit all the tools onto this bitmap
-  HDC memoryDC = ::CreateCompatibleDC(NULL);
-  HBITMAP oldBitmap = (HBITMAP) ::SelectObject(memoryDC, (HBITMAP) m_hBitmap);
-
-  HDC memoryDC2 = ::CreateCompatibleDC(NULL);
-  int x = 0;
-  wxNode *node = m_tools.First();
-  int noButtons = 0;
-  while (node)
-  {
-    wxToolBarTool *tool = (wxToolBarTool *)node->Data();
-    if ((tool->m_toolStyle != wxTOOL_STYLE_SEPARATOR) && tool->m_bitmap1.Ok() && tool->m_bitmap1.GetHBITMAP())
+        return FALSE;
+    }
+
+    m_hBitmap = (WXHBITMAP)hBitmap;
+
+    HDC memoryDC = ::CreateCompatibleDC(NULL);
+    HBITMAP oldBitmap = (HBITMAP) ::SelectObject(memoryDC, hBitmap);
+
+    HDC memoryDC2 = ::CreateCompatibleDC(NULL);
+#endif // USE_BITMAP_MASKS/!USE_BITMAP_MASKS
+
+    // the button position
+    wxCoord x = 0;
+
+    // the number of buttons (not separators)
+    int nButtons = 0;
+
+    wxToolBarToolsList::Node *node = m_tools.GetFirst();
+    while ( node )

     {
     {

-//      wxPalette *palette = tool->m_bitmap1->GetPalette();
+        wxToolBarToolBase *tool = node->GetData();
+        if ( tool->IsButton() )
+        {
+            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) )
+                {
+                    wxLogLastError(wxT("BitBlt"));
+                }
+
+                ::SelectObject(memoryDC2, oldBitmap2);
+#endif // USE_BITMAP_MASKS/!USE_BITMAP_MASKS
+            }
+            else
+            {
+                wxFAIL_MSG( _T("invalid tool button bitmap") );
+            }

 
 

-      HBITMAP oldBitmap2 = (HBITMAP) ::SelectObject(memoryDC2, (HBITMAP) tool->m_bitmap1.GetHBITMAP());
-      /* int bltResult = */
-         BitBlt(memoryDC, x, 0, (int) m_defaultWidth, (int) m_defaultHeight, memoryDC2,
-                        0, 0, SRCCOPY);
-      ::SelectObject(memoryDC2, oldBitmap2);
-      x += (int)m_defaultWidth;
-      noButtons ++;
+            // 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->GetNext();

     }
     }

-    node = node->Next();
-  }
-  ::SelectObject(memoryDC, oldBitmap);
-  ::DeleteDC(memoryDC);
-  ::DeleteDC(memoryDC2);

 
 

-  // Map to system colours
-  wxMapBitmap((HBITMAP) m_hBitmap, totalBitmapWidth, totalBitmapHeight);
+#if USE_BITMAP_MASKS
+    dcAllButtons.SelectObject(wxNullBitmap);

 
 

-  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((HWND) GetHWND(), TB_REPLACEBITMAP, (WPARAM) 0, (LPARAM) &replaceBitmap) == -1)
-      wxMessageBox("Could not add bitmap to toolbar");
-
-    ::DeleteObject((HBITMAP) oldToolBarBitmap);
-
-    // Now delete all the buttons
-    int i = 0;
-    while ( TRUE )
+    // don't delete this HBITMAP!
+    bitmap.SetHBITMAP(0);
+#else // !USE_BITMAP_MASKS
+    ::SelectObject(memoryDC, oldBitmap);
+    ::DeleteDC(memoryDC);
+    ::DeleteDC(memoryDC2);
+#endif // USE_BITMAP_MASKS/!USE_BITMAP_MASKS
+
+    // Map to system colours
+    wxMapBitmap(hBitmap, totalBitmapWidth, totalBitmapHeight);
+
+    int bitmapId = 0;
+
+    bool addBitmap = TRUE;
+
+    if ( oldToolBarBitmap )

     {
     {

-        // TODO: What about separators???? They don't have an id!
-        if ( ! ::SendMessage( (HWND) GetHWND(), TB_DELETEBUTTON, i, 0 ) )
-            break;
+#ifdef TB_REPLACEBITMAP
+        if ( wxTheApp->GetComCtl32Version() >= 400 )
+        {
+            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;
+
+            bitmapId = m_nButtons;
+        }
+
+        // Now delete all the buttons
+        for ( size_t pos = 0; pos < m_nButtons; pos++ )
+        {
+            if ( !::SendMessage(GetHwnd(), TB_DELETEBUTTON, 0, 0) )
+            {
+                wxLogLastError(wxT("TB_DELETEBUTTON"));
+            }
+        }
+

     }
     }

-  }
-  else
-  {
-    TBADDBITMAP addBitmap;
-    addBitmap.hInst = 0;
-    addBitmap.nID = (UINT)m_hBitmap;
-    if (::SendMessage((HWND) GetHWND(), TB_ADDBITMAP, (WPARAM) noButtons, (LPARAM) &addBitmap) == -1)
-      wxMessageBox("Could not add bitmap to toolbar");
-  }

 
 

-  // Now add the buttons.
-  TBBUTTON buttons[50];
+    if ( addBitmap ) // no old bitmap or we can't replace it
+    {
+        TBADDBITMAP addBitmap;
+        addBitmap.hInst = 0;
+        addBitmap.nID = (UINT) hBitmap;
+        if ( ::SendMessage(GetHwnd(), TB_ADDBITMAP,
+                           (WPARAM) nButtons, (LPARAM)&addBitmap) == -1 )
+        {
+            wxFAIL_MSG(wxT("Could not add bitmap to toolbar"));
+        }
+    }

 
 

-  node = m_tools.First();
-  int i = 0;
-  int bitmapId = 0;
-  while (node)
-  {
-    wxToolBarTool *tool = (wxToolBarTool *)node->Data();
-    if (tool->m_toolStyle == wxTOOL_STYLE_SEPARATOR)
+    // Next add the buttons and separators
+    // -----------------------------------
+
+    TBBUTTON *buttons = new TBBUTTON[nTools];
+
+    // this array will hold the indices of all controls in the toolbar
+    wxArrayInt controlIds;
+
+    int i = 0;
+    for ( node = m_tools.GetFirst(); node; node = node->GetNext() )

     {
     {

-      buttons[i].iBitmap = 0;
-      buttons[i].idCommand = 0;
+        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);

 
 

-      buttons[i].fsState = TBSTATE_ENABLED;
-      buttons[i].fsStyle = TBSTYLE_SEP;
-      buttons[i].dwData = 0L;
-      buttons[i].iString = 0;
+        switch ( tool->GetStyle() )
+        {
+            case wxTOOL_STYLE_CONTROL:
+                button.idCommand = tool->GetId();
+                // fall through: create just a separator too
+
+            case wxTOOL_STYLE_SEPARATOR:
+                button.fsState = TBSTATE_ENABLED;
+                button.fsStyle = TBSTYLE_SEP;
+                break;
+
+            case wxTOOL_STYLE_BUTTON:
+                button.iBitmap = bitmapId;
+                button.idCommand = tool->GetId();
+
+                if ( tool->IsEnabled() )
+                    button.fsState |= TBSTATE_ENABLED;
+                if ( tool->IsToggled() )
+                    button.fsState |= TBSTATE_CHECKED;
+
+                button.fsStyle = tool->CanBeToggled() ? TBSTYLE_CHECK
+                                                      : TBSTYLE_BUTTON;
+
+                bitmapId++;
+                break;
+        }
+
+        i++;

     }
     }

-    else
+
+    if ( !::SendMessage(GetHwnd(), TB_ADDBUTTONS,
+                        (WPARAM)i, (LPARAM)buttons) )

     {
     {

-      buttons[i].iBitmap = bitmapId;
-      buttons[i].idCommand = tool->m_index;
+        wxLogLastError(wxT("TB_ADDBUTTONS"));
+    }
+
+    delete [] buttons;
+
+    // Deal with the controls finally
+    // ------------------------------
+
+    // adjust the controls size to fit nicely in the toolbar
+    size_t index = 0;
+    for ( node = m_tools.GetFirst(); node; node = node->GetNext(), index++ )
+    {
+        wxToolBarToolBase *tool = node->GetData();
+        if ( !tool->IsControl() )
+            continue;
+
+        wxControl *control = tool->GetControl();
+
+        wxSize size = control->GetSize();
+
+        // 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) )
+        {
+            wxLogLastError(wxT("TB_GETITEMRECT"));
+        }
+
+        // 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);
+            }

 
 

-      buttons[i].fsState = 0;
-      if (tool->m_enabled)
-        buttons[i].fsState |= TBSTATE_ENABLED;
-      if (tool->m_toggleState)
-        buttons[i].fsState |= TBSTATE_CHECKED;
-      buttons[i].fsStyle = tool->m_isToggle ? TBSTYLE_CHECK : TBSTYLE_BUTTON;
-      buttons[i].dwData = 0L;
-      buttons[i].iString = 0;
+        // and position the control itself correctly vertically
+        int height = r.bottom - r.top;
+        int diff = height - size.y;
+        if ( diff < 0 )
+        {
+            // the control is too high, resize to fit
+            control->SetSize(-1, height - 2);

 
 

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

     }
     }

-        
-    i ++;
-    node = node->Next();
-  }

 
 

-  int ans = (int)::SendMessage((HWND) GetHWND(), TB_ADDBUTTONS, (WPARAM)i, (LPARAM)& buttons);
-  ans = (int)::SendMessage((HWND) 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;

 
 

-  RECT rect;
-  ::SendMessage((HWND) GetHWND(), TB_SETROWS, MAKEWPARAM(m_maxRows, TRUE), (LPARAM) & rect);
-  m_maxWidth = (rect.right - rect.left + 2);
-  m_maxHeight = (rect.bottom - rect.top + 2);
+    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;

 }
 
 }
 

-bool wxToolBar95::MSWCommand(WXUINT cmd, WXWORD id)
+// ----------------------------------------------------------------------------
+// message handlers
+// ----------------------------------------------------------------------------
+
+bool wxToolBar::MSWCommand(WXUINT cmd, WXWORD id)

 {
 {

-  wxNode *node = m_tools.Find((long)id);
-  if (!node)
-    return FALSE;
-  wxToolBarTool *tool = (wxToolBarTool *)node->Data();
-  if (tool->m_isToggle)
-    tool->m_toggleState = (1 == (1 & (int)::SendMessage((HWND) GetHWND(), TB_GETSTATE, (WPARAM) id, (LPARAM) 0)));
-
-  BOOL ret = OnLeftClick((int)id, tool->m_toggleState);
-  if (ret == FALSE && tool->m_isToggle)
-  {
-    tool->m_toggleState = !tool->m_toggleState;
-    ::SendMessage((HWND) GetHWND(), TB_CHECKBUTTON, (WPARAM)id, (LPARAM)MAKELONG(tool->m_toggleState, 0));
-  }
-  return TRUE;
+    wxToolBarToolBase *tool = FindById((int)id);
+    if ( !tool )
+        return FALSE;
+
+    if ( tool->CanBeToggled() )
+    {
+        LRESULT state = ::SendMessage(GetHwnd(), TB_GETSTATE, id, 0);
+        tool->Toggle((state & TBSTATE_CHECKED) != 0);
+    }
+
+    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() )
+    {
+        // revert back
+        toggled = !toggled;
+        tool->SetToggle(toggled);
+
+        ::SendMessage(GetHwnd(), TB_CHECKBUTTON, id, MAKELONG(toggled, 0));
+    }
+
+    return TRUE;

 }
 
 }
 

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

                             WXLPARAM lParam,
                             WXLPARAM *result)
 {
                             WXLPARAM lParam,
                             WXLPARAM *result)
 {

-       // First check if this applies to us
+    // First check if this applies to us

     NMHDR *hdr = (NMHDR *)lParam;
     NMHDR *hdr = (NMHDR *)lParam;

-    if (hdr->code != TTN_NEEDTEXT)
-               return FALSE;
-
-       HWND toolTipWnd = (HWND) ::SendMessage((HWND) GetHWND(), TB_GETTOOLTIPS, 0, 0);
-       if ( toolTipWnd != hdr->hwndFrom )
-               return FALSE;
-
-  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();
-
-  switch (ttText->hdr.code)
-  {
-    case TTN_NEEDTEXT:
-    {
-      if (tool->m_shortHelpString != "")
-        ttText->lpszText = (char *) (const char *)tool->m_shortHelpString;

 
 

-      // For backward compatibility...
-      OnMouseEnter(tool->m_index);
-      break;
+    // the tooltips control created by the toolbar is sometimes Unicode, even
+    // in an ANSI application - this seems to be a bug in comctl32.dll v5
+    int code = (int)hdr->code;
+    if ( (code != TTN_NEEDTEXTA) && (code != TTN_NEEDTEXTW) )
+        return FALSE;
+
+    HWND toolTipWnd = (HWND)::SendMessage((HWND)GetHWND(), TB_GETTOOLTIPS, 0, 0);
+    if ( toolTipWnd != hdr->hwndFrom )
+        return FALSE;
+
+    LPTOOLTIPTEXT ttText = (LPTOOLTIPTEXT)lParam;
+    int id = (int)ttText->hdr.idFrom;
+
+    wxToolBarToolBase *tool = FindById(id);
+    if ( !tool )
+        return FALSE;
+
+    const wxString& help = tool->GetShortHelp();
+
+    if ( !help.IsEmpty() )
+    {
+        if ( code == TTN_NEEDTEXTA )
+        {
+            ttText->lpszText = (wxChar *)help.c_str();
+        }
+        else
+        {
+#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__
+                // MetroWerks doesn't like calling mbstowcs with NULL argument
+                size_t lenUnicode = 2*lenAnsi;
+            #else
+                size_t lenUnicode = mbstowcs(NULL, help, lenAnsi);
+            #endif
+
+            // using the pointer of right type avoids us doing all sorts of
+            // pointer arithmetics ourselves
+            wchar_t *dst = (wchar_t *)ttText->szText,
+                    *pwz = new wchar_t[lenUnicode + 1];
+            mbstowcs(pwz, help, lenAnsi + 1);
+            memcpy(dst, pwz, lenUnicode*sizeof(wchar_t));
+
+            // put the terminating _wide_ NUL
+            dst[lenUnicode] = 0;
+
+            delete [] pwz;
+#endif
+        }

     }
     }

-    default:
-      return FALSE;
-      break;
-  }
-  
-  return TRUE;
-}

 
 

-void wxToolBar95::SetToolBitmapSize(const wxSize& size)
-{
-  m_defaultWidth = size.x; m_defaultHeight = size.y;
-  ::SendMessage((HWND) GetHWND(), TB_SETBITMAPSIZE, 0, (LPARAM) MAKELONG ((int)size.x, (int)size.y));
+    // For backward compatibility...
+    OnMouseEnter(tool->GetId());
+
+    return TRUE;

 }
 
 }
 

-void wxToolBar95::SetRows(int nRows)
+// ----------------------------------------------------------------------------
+// toolbar geometry
+// ----------------------------------------------------------------------------
+
+void wxToolBar::SetToolBitmapSize(const wxSize& size)

 {
 {

-  RECT rect;
-  ::SendMessage((HWND) GetHWND(), TB_SETROWS, MAKEWPARAM(nRows, TRUE), (LPARAM) & rect);
-  m_maxWidth = (rect.right - rect.left + 2);
-  m_maxHeight = (rect.bottom - rect.top + 2);
+    wxToolBarBase::SetToolBitmapSize(size);
+
+    ::SendMessage(GetHwnd(), TB_SETBITMAPSIZE, 0, MAKELONG(size.x, size.y));

 }
 
 }
 

-wxSize wxToolBar95::GetMaxSize(void) const
+void wxToolBar::SetRows(int nRows)

 {
 {

-  if ((m_maxWidth == -1) || (m_maxHeight == -1))
-  {
+    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;
     RECT rect;

-    ::SendMessage((HWND) GetHWND(), TB_SETROWS, MAKEWPARAM(m_maxRows, TRUE), (LPARAM) & rect);
-    ((wxToolBar95 *)this)->m_maxWidth = (rect.right - rect.left + 2); // ???
-    ((wxToolBar95 *)this)->m_maxHeight = (rect.bottom - rect.top + 2); // ???
-  }
-  return wxSize(m_maxWidth, m_maxHeight);
-}
+    ::SendMessage(GetHwnd(), TB_SETROWS,
+                  MAKEWPARAM(nRows, !(GetWindowStyle() & wxTB_VERTICAL)),
+                  (LPARAM) &rect);

 
 

-void wxToolBar95::GetSize(int *w, int *h) const
-{
-  wxWindow::GetSize(w, h);
-  // For some reason, the returned height is several pixels bigger than that
-  // displayed!
-  *h -= 2;
+    m_maxRows = nRows;
+
+    UpdateSize();

 }
 
 // The button size is bigger than the bitmap size
 }
 
 // The button size is bigger than the bitmap size

-wxSize wxToolBar95::GetToolSize(void) const
+wxSize wxToolBar::GetToolSize() const

 {
 {

-  return wxSize(m_defaultWidth + 8, m_defaultHeight + 7);
+    // TB_GETBUTTONSIZE is supported from version 4.70
+#if defined(_WIN32_IE) && (_WIN32_IE >= 0x300 )
+    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);
+    }

 }
 
 }
 

-void wxToolBar95::EnableTool(int toolIndex, bool enable)
+wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord x, wxCoord y) const

 {
 {

-  wxNode *node = m_tools.Find((long)toolIndex);
-  if (node)
-  {
-    wxToolBarTool *tool = (wxToolBarTool *)node->Data();
-    tool->m_enabled = enable;
-    ::SendMessage((HWND) GetHWND(), TB_ENABLEBUTTON, (WPARAM)toolIndex, (LPARAM)MAKELONG(enable, 0));
-  }
+    POINT pt;
+    pt.x = x;
+    pt.y = y;
+    int index = (int)::SendMessage(GetHwnd(), TB_HITTEST, 0, (LPARAM)&pt);
+    if ( index < 0 )
+    {
+        // it's a separator or there is no tool at all there
+        return (wxToolBarToolBase *)NULL;
+    }
+
+    return m_tools.Item((size_t)index)->GetData();

 }
 
 }
 

-void wxToolBar95::ToggleTool(int toolIndex, bool toggle)
+void wxToolBar::UpdateSize()

 {
 {

-  wxNode *node = m_tools.Find((long)toolIndex);
-  if (node)
-  {
-    wxToolBarTool *tool = (wxToolBarTool *)node->Data();
-    if (tool->m_isToggle)
+    // 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 )

     {
     {

-      tool->m_toggleState = toggle;
-      ::SendMessage((HWND) GetHWND(), TB_CHECKBUTTON, (WPARAM)toolIndex, (LPARAM)MAKELONG(toggle, 0));
+        frame->SendSizeEvent();

     }
     }

-  }

 }
 
 }
 

-bool wxToolBar95::GetToolState(int toolIndex) const
+// ----------------------------------------------------------------------------
+// tool state
+// ----------------------------------------------------------------------------
+
+void wxToolBar::DoEnableTool(wxToolBarToolBase *tool, bool enable)

 {
 {

-    return (::SendMessage((HWND) GetHWND(), TB_ISBUTTONCHECKED, (WPARAM)toolIndex, (LPARAM)0) != 0);
+    ::SendMessage(GetHwnd(), TB_ENABLEBUTTON,
+                  (WPARAM)tool->GetId(), (LPARAM)MAKELONG(enable, 0));

 }
 
 }
 

-void wxToolBar95::ClearTools(void)
+void wxToolBar::DoToggleTool(wxToolBarToolBase *tool, bool toggle)

 {
 {

-  // 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();
+    ::SendMessage(GetHwnd(), TB_CHECKBUTTON,
+                  (WPARAM)tool->GetId(), (LPARAM)MAKELONG(toggle, 0));

 }
 
 }
 

-// If pushedBitmap is NULL, a reversed version of bitmap is
-// created and used as the pushed/toggled image.
-// If toggle is TRUE, the button toggles between the two states.
-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)
+void wxToolBar::DoSetToggle(wxToolBarToolBase *tool, bool toggle)

 {
 {

-  wxToolBarTool *tool = new wxToolBarTool(index, bitmap, wxNullBitmap, toggle, xPos, yPos, helpString1, helpString2);
-  tool->m_clientData = clientData;
-
-  if (xPos > -1)
-    tool->m_x = xPos;
-  else
-    tool->m_x = m_xMargin;
-
-  if (yPos > -1)
-    tool->m_y = yPos;
-  else
-    tool->m_y = m_yMargin;
-
-  tool->SetSize(GetDefaultButtonWidth(), GetDefaultButtonHeight());
-
-  m_tools.Append((long)index, tool);
-  return tool;
+    // 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") );

 }
 
 }
 

+// ----------------------------------------------------------------------------
+// event handlers
+// ----------------------------------------------------------------------------
+

 // 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)),
 {
     m_backgroundColour = wxColour(GetRValue(GetSysColor(COLOR_BTNFACE)),

-           GetGValue(GetSysColor(COLOR_BTNFACE)), GetBValue(GetSysColor(COLOR_BTNFACE)));
+          GetGValue(GetSysColor(COLOR_BTNFACE)), GetBValue(GetSysColor(COLOR_BTNFACE)));

 
     // Remap the buttons
 
     // Remap the buttons

-    CreateTools();
-
-    Default();
+    Realize();

 
     Refresh();
 
 
     Refresh();
 


@@ -485,24 +938,90 @@ void wxToolBar95::OnSysColourChanged(wxSysColourChangedEvent& event)
     wxWindow::OnSysColourChanged(event);
 }
 
     wxWindow::OnSysColourChanged(event);
 }
 

-// These are the default colors used to map the bitmap colors
-// to the current system colors
+void wxToolBar::OnMouseEvent(wxMouseEvent& event)
+{
+    if (event.RightDown())
+    {
+        // For now, we don't have an id. Later we could
+        // try finding the tool.
+        OnRightClick((int)-1, event.GetX(), event.GetY());
+    }
+    else
+    {
+        event.Skip();
+    }
+}
+
+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
+// ----------------------------------------------------------------------------
+
+// These are the default colors used to map the bitmap colors to the current
+// system colors. Note that they are in BGR format because this is what Windows
+// wants (and not RGB)

 
 #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_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_BACKGROUNDSEL   (RGB(000,000,255))  // blue

 #define BGR_BACKGROUND      (RGB(255,000,255))  // magenta
 
 void wxMapBitmap(HBITMAP hBitmap, int width, int height)
 {
 #define BGR_BACKGROUND      (RGB(255,000,255))  // magenta
 
 void wxMapBitmap(HBITMAP hBitmap, int width, int height)
 {

-  COLORMAP ColorMap[] = {
+  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_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_BACKGROUNDSEL, COLOR_HIGHLIGHT},   // blue */

     {BGR_BACKGROUND,    COLOR_WINDOW}       // magenta
   };
 
     {BGR_BACKGROUND,    COLOR_WINDOW}       // magenta
   };
 


@@ -581,4 +1100,4 @@ void wxMapBitmap(HBITMAP hBitmap, int width, int height)
 #endif
 
 
 #endif
 
 

-#endif
+#endif // wxUSE_TOOLBAR && Win95