[start of] a wxUniversal implementation of wxToolBar

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@14422 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

include/wx/tbarbase.h

@@ -132,11 +132,13 @@ public:
     bool CanBeToggled() const { return m_isToggle; }
 
     // attributes
-    const wxBitmap& GetBitmap1() const { return m_bitmap1; }
+    const wxBitmap& GetNormalBitmap() const { return m_bitmap1; }
-    const wxBitmap& GetBitmap2() const { return m_bitmap2; }
+    const wxBitmap& GetDisabledBitmap() const { return m_bitmap2; }
 
     const wxBitmap& GetBitmap() const
-        { return IsToggled() ? m_bitmap2 : m_bitmap1; }
+        { return IsEnabled() ? GetNormalBitmap() : GetDisabledBitmap(); }
+
+    wxString GetLabel() const { return m_label; }
 
     wxString GetShortHelp() const { return m_shortHelpString; }
     wxString GetLongHelp() const { return m_longHelpString; }
@@ -162,8 +164,10 @@ public:
 
     void Toggle() { Toggle(!IsToggled()); }
 
-    void SetBitmap1(const wxBitmap& bmp) { m_bitmap1 = bmp; }
+    void SetNormalBitmap(const wxBitmap& bmp) { m_bitmap1 = bmp; }
-    void SetBitmap2(const wxBitmap& bmp) { m_bitmap2 = bmp; }
+    void SetDisabledBitmap(const wxBitmap& bmp) { m_bitmap2 = bmp; }
+
+    void SetLabel(const wxString& label) { m_label = label; }
 
     void SetClientData(wxObject *clientData)
     {
@@ -181,6 +185,15 @@ public:
     virtual void Detach() { m_tbar = (wxToolBarBase *)NULL; }
     virtual void Attach(wxToolBarBase *tbar) { m_tbar = tbar; }
 
+    // compatibility only, don't use
+#if WXWIN_COMPATIBILITY_2_2
+    const wxBitmap& GetBitmap1() const { return GetNormalBitmap(); }
+    const wxBitmap& GetBitmap2() const { return GetDisabledBitmap(); }
+
+    void SetBitmap1(const wxBitmap& bmp) { SetNormalBitmap(bmp); }
+    void SetBitmap2(const wxBitmap& bmp) { SetDisabledBitmap(bmp); }
+#endif // WXWIN_COMPATIBILITY_2_2
+
 protected:
     wxToolBarBase *m_tbar;  // the toolbar to which we belong (may be NULL)
 
@@ -199,10 +212,13 @@ protected:
     bool m_isToggle;
     bool m_enabled;
 
-    // normal and toggles bitmaps
+    // normal and disabled bitmaps
     wxBitmap m_bitmap1;
     wxBitmap m_bitmap2;
 
+    // the button label
+    wxString m_label;
+
     // short and long help strings
     wxString m_shortHelpString;
     wxString m_longHelpString;
@@ -374,6 +390,9 @@ public:
     virtual wxToolBarToolBase *FindToolForPosition(wxCoord x,
                                                    wxCoord y) const = 0;
 
+    // return TRUE if this is a vertical toolbar, otherwise FALSE
+    bool IsVertical() const { return HasFlag(wxTB_VERTICAL); }
+
     // event handlers
     // --------------
 

include/wx/univ/inphand.h

@@ -37,6 +37,7 @@
 #define wxINP_HANDLER_SPINBTN           _T("spinbtn")
 #define wxINP_HANDLER_STATUSBAR         _T("statusbar")
 #define wxINP_HANDLER_TEXTCTRL          _T("textctrl")
+#define wxINP_HANDLER_TOOLBAR           _T("toolbar")
 #define wxINP_HANDLER_TOPLEVEL          _T("toplevel")
 
 // ----------------------------------------------------------------------------

include/wx/univ/renderer.h

@@ -188,6 +188,14 @@ public:
                                  wxAlignment align = wxALIGN_LEFT,
                                  int indexAccel = -1) = 0;
 
+    // draw a toolbar button (label may be empty, bitmap may be invalid, if
+    // both conditions are true this function draws a separator)
+    virtual void DrawToolBarButton(wxDC& dc,
+                                   const wxString& label,
+                                   const wxBitmap& bitmap,
+                                   const wxRect& rect,
+                                   int flags = 0) = 0;
+
     // draw a (part of) line in the text control
     virtual void DrawTextLine(wxDC& dc,
                               const wxString& text,
@@ -356,15 +364,22 @@ public:
     virtual wxSize GetRadioBitmapSize() const = 0;
     virtual wxCoord GetCheckItemMargin() const = 0;
 
+    // get the standard size of a toolbar button and also return the size of
+    // a toolbar separator in the provided pointer
+    virtual wxSize GetToolBarButtonSize(wxCoord *separator) const = 0;
+
+    // get the margins between/around the toolbar buttons
+    virtual wxSize GetToolBarMargin() const = 0;
+
     // convert between text rectangle and client rectangle for text controls:
     // the former is typicall smaller to leave margins around text
     virtual wxRect GetTextTotalArea(const wxTextCtrl *text,
-                                    const wxRect& rectText) = 0;
+                                    const wxRect& rectText) const = 0;
 
     // extra space is for line indicators
     virtual wxRect GetTextClientArea(const wxTextCtrl *text,
                                      const wxRect& rectTotal,
-                                     wxCoord *extraSpaceBeyond) = 0;
+                                     wxCoord *extraSpaceBeyond) const = 0;
 
     // get the overhang of a selected tab
     virtual wxSize GetTabIndent() const = 0;
@@ -591,6 +606,12 @@ public:
                                  int indexAccel = -1)
         { m_renderer->DrawRadioButton(dc, label, bitmap, rect,
                                       flags, align, indexAccel); }
+    virtual void DrawToolBarButton(wxDC& dc,
+                                   const wxString& label,
+                                   const wxBitmap& bitmap,
+                                   const wxRect& rect,
+                                   int flags = 0)
+        { m_renderer->DrawToolBarButton(dc, label, bitmap, rect, flags); }
     virtual void DrawTextLine(wxDC& dc,
                               const wxString& text,
                               const wxRect& rect,
@@ -731,11 +752,17 @@ public:
     virtual wxCoord GetCheckItemMargin() const
         { return m_renderer->GetCheckItemMargin(); }
 
-    virtual wxRect GetTextTotalArea(const wxTextCtrl *text, const wxRect& rect)
+    virtual wxSize GetToolBarButtonSize(wxCoord *separator) const
+        { return m_renderer->GetToolBarButtonSize(separator); }
+    virtual wxSize GetToolBarMargin() const
+        { return m_renderer->GetToolBarMargin(); }
+
+    virtual wxRect GetTextTotalArea(const wxTextCtrl *text,
+                                    const wxRect& rect) const
         { return m_renderer->GetTextTotalArea(text, rect); }
     virtual wxRect GetTextClientArea(const wxTextCtrl *text,
                                      const wxRect& rect,
-                                     wxCoord *extraSpaceBeyond)
+                                     wxCoord *extraSpaceBeyond) const
         { return m_renderer->GetTextClientArea(text, rect, extraSpaceBeyond); }
 
     virtual wxSize GetTabIndent() const { return m_renderer->GetTabIndent(); }

include/wx/univ/toolbar.h

@@ -16,36 +16,24 @@
     #pragma interface "univtoolbar.h"
 #endif
 
-#include "wx/window.h"
+#include "wx/button.h"      // for wxStdButtonInputHandler
+
+class WXDLLEXPORT wxToolBarTool;
 
 // ----------------------------------------------------------------------------
-// wxToolbar
+// the actions supported by this control
 // ----------------------------------------------------------------------------
 
-class WXDLLEXPORT wxToolBarTool : public wxToolBarToolBase
+#define wxACTION_TOOLBAR_TOGGLE  wxACTION_BUTTON_TOGGLE
-{
+#define wxACTION_TOOLBAR_PRESS   wxACTION_BUTTON_PRESS
-public:
+#define wxACTION_TOOLBAR_RELEASE wxACTION_BUTTON_RELEASE
-    wxToolBarTool( wxToolBarBase *tbar = (wxToolBarBase *)NULL,
+#define wxACTION_TOOLBAR_CLICK   wxACTION_BUTTON_CLICK
-                   int id = wxID_SEPARATOR,
+#define wxACTION_TOOLBAR_ENTER   _T("enter")     // highlight the tool
-                   const wxBitmap& bitmap1 = wxNullBitmap,
+#define wxACTION_TOOLBAR_LEAVE   _T("leave")     // unhighlight the tool
-                   const wxBitmap& bitmap2 = wxNullBitmap,
-                   bool toggle = FALSE,
-                   wxObject *clientData = (wxObject *) NULL,
-                   const wxString& shortHelpString = wxEmptyString,
-                   const wxString& longHelpString = wxEmptyString ) :
-        wxToolBarToolBase( tbar, id, bitmap1, bitmap2, toggle, clientData,
-                           shortHelpString, longHelpString )
-    {
-        m_isDown = FALSE;
-        m_x = -1;
-        m_y = -1;
-    }
 
-public:
+// ----------------------------------------------------------------------------
-    bool        m_isDown;
+// wxToolBar
-    int         m_x;
+// ----------------------------------------------------------------------------
-    int         m_y;
-};
 
 class WXDLLEXPORT wxToolBar : public wxToolBarBase
 {    
@@ -71,9 +59,7 @@ public:
                  long style = 0,
                  const wxString& name = wxToolBarNameStr );
                  
-#ifdef __DARWIN__
+    virtual ~wxToolBar();
-    virtual ~wxToolBar() { }
-#endif
 
     virtual bool Realize();
 
@@ -102,21 +88,72 @@ protected:
                                           const wxString& longHelpString);
     virtual wxToolBarToolBase *CreateTool(wxControl *control);
 
-private:
+    // implement wxUniversal methods
-    wxToolBarTool    *m_captured;
+    virtual bool PerformAction(const wxControlAction& action,
-    wxToolBarTool    *m_underMouse;
+                               long numArg = -1,
-    wxCoord           m_maxWidth, m_maxHeight;
+                               const wxString& strArg = wxEmptyString);
+    virtual wxSize DoGetBestClientSize() const;
+    virtual void DoDraw(wxControlRenderer *renderer);
+
+    // get the bounding rect for the given tool
+    wxRect GetToolRect(wxToolBarToolBase *tool) const;
+
+    // redraw the given tool
+    void RefreshTool(wxToolBarToolBase *tool);
+
+    // (re)calculate the tool positions, should only be called if it is
+    // necessary to do it, i.e. m_needsLayout == TRUE
+    void DoLayout();
+    
+    // get the rect limits depending on the orientation: top/bottom for a
+    // vertical toolbar, left/right for a horizontal one
+    void GetRectLimits(const wxRect& rect, wxCoord *start, wxCoord *end) const;
+
+    // wxButton actions: all these use m_toolPressed and can only be called if
+    // we have one
+    void Toggle();
+    void Press();
+    void Release();
+
+    // this one used m_toolCurrent
+    void Click();
 
 private:
-    void OnMouse( wxMouseEvent &event );
+    // have we calculated the positions of our tools?
-    void OnEnter( wxMouseEvent &event );
+    bool m_needsLayout;
-    void OnLeave( wxMouseEvent &event );
-    void RefreshTool( wxToolBarTool *tool );
-    void DrawToolBarTool( wxToolBarTool *tool, wxDC &dc, bool down );
-    void OnPaint( wxPaintEvent &event );
 
-private:
+    // the width of a separator
-    DECLARE_EVENT_TABLE()
+    wxCoord m_widthSeparator;
+
+    // the total size of all toolbar elements
+    wxCoord m_maxWidth,
+            m_maxHeight;
+    
+    // the current tool or NULL
+    wxToolBarToolBase *m_toolCurrent;
+
+    // the currently pressed tool or NULL
+    wxToolBarToolBase *m_toolPressed;
+
+    DECLARE_DYNAMIC_CLASS(wxToolBar)
+};
+
+// ----------------------------------------------------------------------------
+// wxStdToolbarInputHandler: translates SPACE and ENTER keys and the left mouse
+// click into button press/release actions
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxStdToolbarInputHandler : public wxStdButtonInputHandler
+{
+public:
+    wxStdToolbarInputHandler(wxInputHandler *inphand);
+
+    virtual bool HandleKey(wxInputConsumer *consumer,
+                           const wxKeyEvent& event,
+                           bool pressed);
+    virtual bool HandleMouseMove(wxInputConsumer *consumer, const wxMouseEvent& event);
+    virtual bool HandleFocus(wxInputConsumer *consumer, const wxFocusEvent& event);
+    virtual bool HandleActivation(wxInputConsumer *consumer, bool activated);
 };
 
 #endif // _WX_UNIV_TOOLBAR_H_

src/common/tbarbase.cpp

@@ -38,11 +38,6 @@
 #include "wx/image.h"
 #include "wx/settings.h"
 
-// For ::UpdateWindow
-#ifdef __WXMSW__
-#include <windows.h>
-#endif
-
 #include "wx/tbarbase.h"
 
 // ----------------------------------------------------------------------------
@@ -79,7 +74,9 @@ bool wxToolBarToolBase::Enable(bool enable)
 
 bool wxToolBarToolBase::Toggle(bool toggle)
 {
-    wxASSERT_MSG( m_isToggle, _T("can't toggle this tool") );
+    // wxUniv toolbar toggles even non-checkable tools temporarily - should we
+    // change the code there or just allow doing it?
+    //wxASSERT_MSG( m_isToggle, _T("can't toggle this tool") );
 
     if ( m_toggled == toggle )
         return FALSE;

src/univ/themes/gtk.cpp

@@ -39,6 +39,7 @@
     #include "wx/scrolbar.h"
     #include "wx/slider.h"
     #include "wx/textctrl.h"
+    #include "wx/toolbar.h"
 #endif // WX_PRECOMP
 
 #include "wx/notebook.h"
@@ -152,6 +153,12 @@ public:
                                  wxAlignment align = wxALIGN_LEFT,
                                  int indexAccel = -1);
 
+    virtual void DrawToolBarButton(wxDC& dc,
+                                   const wxString& label,
+                                   const wxBitmap& bitmap,
+                                   const wxRect& rect,
+                                   int flags);
+
     virtual void DrawTextLine(wxDC& dc,
                               const wxString& text,
                               const wxRect& rect,
@@ -275,11 +282,16 @@ public:
     virtual wxCoord GetCheckItemMargin() const
         { return 2; }
 
+    virtual wxSize GetToolBarButtonSize(wxCoord *separator) const
+        { if ( separator ) *separator = 5; return wxSize(16, 15); }
+    virtual wxSize GetToolBarMargin() const
+        { return wxSize(6, 6); }
+
     virtual wxRect GetTextTotalArea(const wxTextCtrl *text,
-                                    const wxRect& rect);
+                                    const wxRect& rect) const;
     virtual wxRect GetTextClientArea(const wxTextCtrl *text,
                                      const wxRect& rect,
-                                     wxCoord *extraSpaceBeyond);
+                                     wxCoord *extraSpaceBeyond) const;
 
     virtual wxSize GetTabIndent() const { return wxSize(2, 2); }
     virtual wxSize GetTabPadding() const { return wxSize(6, 6); }
@@ -385,7 +397,7 @@ protected:
     }
 
     // get the line wrap indicator bitmap
-    wxBitmap GetLineWrapBitmap();
+    wxBitmap GetLineWrapBitmap() const;
 
     // DrawCheckBitmap and DrawRadioBitmap helpers
 
@@ -678,6 +690,10 @@ wxInputHandler *wxGTKTheme::GetInputHandler(const wxString& control)
         else if ( control == wxINP_HANDLER_NOTEBOOK )
             handler = new wxStdNotebookInputHandler(GetDefaultInputHandler());
 #endif // wxUSE_NOTEBOOK
+#if wxUSE_TOOLBAR
+        else if ( control == wxINP_HANDLER_TOOLBAR )
+            handler = new wxStdToolbarInputHandler(GetDefaultInputHandler());
+#endif // wxUSE_TOOLBAR
         else if ( control == wxINP_HANDLER_TOPLEVEL )
             handler = new wxStdFrameInputHandler(GetDefaultInputHandler());
         else
@@ -1424,7 +1440,7 @@ wxBitmap wxGTKRenderer::GetCheckBitmap(int flags)
     return m_bitmapsCheckbox[row][col];
 }
 
-wxBitmap wxGTKRenderer::GetLineWrapBitmap()
+wxBitmap wxGTKRenderer::GetLineWrapBitmap() const
 {
     if ( !m_bmpLineWrap.Ok() )
     {
@@ -1443,7 +1459,7 @@ wxBitmap wxGTKRenderer::GetLineWrapBitmap()
         }
         else
         {
-            m_bmpLineWrap = bmpLineWrap;
+            wxConstCast(this, wxGTKRenderer)->m_bmpLineWrap = bmpLineWrap;
         }
     }
 
@@ -1552,12 +1568,37 @@ void wxGTKRenderer::DrawRadioButton(wxDC& dc,
                              flags, align, indexAccel);
 }
 
+void wxGTKRenderer::DrawToolBarButton(wxDC& dc,
+                                      const wxString& label,
+                                      const wxBitmap& bitmap,
+                                      const wxRect& rectOrig,
+                                      int flags)
+{
+    // we don't draw the separators at all
+    if ( !label.empty() || bitmap.Ok() )
+    {
+        wxRect rect = rectOrig;
+        rect.Deflate(BORDER_THICKNESS);
+
+        if ( flags & wxCONTROL_PRESSED )
+        {
+            DrawBorder(dc, wxBORDER_SUNKEN, rect, flags);
+        }
+        else if ( flags & wxCONTROL_CURRENT )
+        {
+            DrawBorder(dc, wxBORDER_RAISED, rect, flags);
+        }
+
+        dc.DrawLabel(label, bitmap, rect, wxALIGN_CENTRE);
+    }
+}
+
 // ----------------------------------------------------------------------------
 // text control
 // ----------------------------------------------------------------------------
 
 wxRect wxGTKRenderer::GetTextTotalArea(const wxTextCtrl *text,
-                                       const wxRect& rect)
+                                       const wxRect& rect) const
 {
     wxRect rectTotal = rect;
     rectTotal.Inflate(2*BORDER_THICKNESS);
@@ -1566,7 +1607,7 @@ wxRect wxGTKRenderer::GetTextTotalArea(const wxTextCtrl *text,
 
 wxRect wxGTKRenderer::GetTextClientArea(const wxTextCtrl *text,
                                         const wxRect& rect,
-                                        wxCoord *extraSpaceBeyond)
+                                        wxCoord *extraSpaceBeyond) const
 {
     wxRect rectText = rect;
     rectText.Deflate(2*BORDER_THICKNESS);

src/univ/themes/win32.cpp

@@ -38,6 +38,7 @@
     #include "wx/scrolbar.h"
     #include "wx/slider.h"
     #include "wx/textctrl.h"
+    #include "wx/toolbar.h"
 
     #ifdef __WXMSW__
         // for COLOR_* constants
@@ -228,6 +229,11 @@ public:
                                  int flags = 0,
                                  wxAlignment align = wxALIGN_LEFT,
                                  int indexAccel = -1);
+    virtual void DrawToolBarButton(wxDC& dc,
+                                   const wxString& label,
+                                   const wxBitmap& bitmap,
+                                   const wxRect& rect,
+                                   int flags);
     virtual void DrawTextLine(wxDC& dc,
                               const wxString& text,
                               const wxRect& rect,
@@ -346,11 +352,16 @@ public:
     virtual wxCoord GetCheckItemMargin() const
         { return 0; }
 
+    virtual wxSize GetToolBarButtonSize(wxCoord *separator) const
+        { if ( separator ) *separator = 5; return wxSize(16, 15); }
+    virtual wxSize GetToolBarMargin() const
+        { return wxSize(6, 6); }
+
     virtual wxRect GetTextTotalArea(const wxTextCtrl *text,
-                                    const wxRect& rect);
+                                    const wxRect& rect) const;
     virtual wxRect GetTextClientArea(const wxTextCtrl *text,
                                      const wxRect& rect,
-                                     wxCoord *extraSpaceBeyond);
+                                     wxCoord *extraSpaceBeyond) const;
 
     virtual wxSize GetTabIndent() const { return wxSize(2, 2); }
     virtual wxSize GetTabPadding() const { return wxSize(6, 5); }
@@ -1226,6 +1237,10 @@ wxInputHandler *wxWin32Theme::GetInputHandler(const wxString& control)
         else if ( control == wxINP_HANDLER_STATUSBAR )
             handler = new wxWin32StatusBarInputHandler(GetDefaultInputHandler());
 #endif // wxUSE_STATUSBAR
+#if wxUSE_TOOLBAR
+        else if ( control == wxINP_HANDLER_TOOLBAR )
+            handler = new wxStdToolbarInputHandler(GetDefaultInputHandler());
+#endif // wxUSE_TOOLBAR
         else if ( control == wxINP_HANDLER_TOPLEVEL )
             handler = new wxWin32FrameInputHandler(GetDefaultInputHandler());
         else
@@ -2332,6 +2347,34 @@ void wxWin32Renderer::DrawCheckButton(wxDC& dc,
                            0); // no focus rect offset for checkboxes
 }
 
+void wxWin32Renderer::DrawToolBarButton(wxDC& dc,
+                                        const wxString& label,
+                                        const wxBitmap& bitmap,
+                                        const wxRect& rectOrig,
+                                        int flags)
+{
+    if ( !label.empty() || bitmap.Ok() )
+    {
+        wxRect rect = rectOrig;
+        rect.Deflate(BORDER_THICKNESS);
+
+        if ( flags & wxCONTROL_PRESSED )
+        {
+            DrawBorder(dc, wxBORDER_SUNKEN, rect, flags);
+        }
+        else if ( flags & wxCONTROL_CURRENT )
+        {
+            DrawBorder(dc, wxBORDER_RAISED, rect, flags);
+        }
+
+        dc.DrawLabel(label, bitmap, rect, wxALIGN_CENTRE);
+    }
+    else // a separator
+    {
+        // TODO
+    }
+}
+
 // ----------------------------------------------------------------------------
 // text control
 // ----------------------------------------------------------------------------
@@ -3829,7 +3872,7 @@ static inline int GetTextBorderWidth()
 }
 
 wxRect wxWin32Renderer::GetTextTotalArea(const wxTextCtrl *text,
-                                         const wxRect& rect)
+                                         const wxRect& rect) const
 {
     wxRect rectTotal = rect;
 
@@ -3844,7 +3887,7 @@ wxRect wxWin32Renderer::GetTextTotalArea(const wxTextCtrl *text,
 
 wxRect wxWin32Renderer::GetTextClientArea(const wxTextCtrl *text,
                                           const wxRect& rect,
-                                          wxCoord *extraSpaceBeyond)
+                                          wxCoord *extraSpaceBeyond) const
 {
     wxRect rectText = rect;
 

src/univ/toolbar.cpp

@@ -1,8 +1,12 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        src/univ/toolbar.cpp
-// Author:      Robert Roebling
+// Purpose:     implementation of wxToolBar for wxUniversal
+// Author:      Robert Roebling, Vadim Zeitlin (universalization)
+// Modified by:
+// Created:     20.02.02
 // Id:          $Id$
-// Copyright:   (c) 2001 Robert Roebling
+// Copyright:   (c) 2001 Robert Roebling,
+//              (c) 2002 SciTech Software, Inc. (www.scitechsoft.com)
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
@@ -28,82 +32,187 @@
 #ifndef WX_PRECOMP
     #include "wx/utils.h"
     #include "wx/app.h"
+
+    #include "wx/univ/renderer.h"
 #endif
 
 #include "wx/toolbar.h"
 #include "wx/image.h"
 
-//-----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
-// wxToolBar
+// constants
-//-----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
-BEGIN_EVENT_TABLE(wxToolBar,wxToolBarBase)
+// value meaning that m_widthSeparator is not initialized
-    EVT_MOUSE_EVENTS( wxToolBar::OnMouse )
+static const wxCoord INVALID_WIDTH = -1;
-    EVT_PAINT( wxToolBar::OnPaint )
-    EVT_SIZE( wxToolBar::OnSize )
-    EVT_ENTER_WINDOW( wxToolBar::OnEnter )
-    EVT_LEAVE_WINDOW( wxToolBar::OnLeave )
-END_EVENT_TABLE()
 
-bool wxToolBar::Create( wxWindow *parent, wxWindowID id,
+// ----------------------------------------------------------------------------
-                 const wxPoint& pos, const wxSize& size,
+// wxToolBarTool: our implementation of wxToolBarToolBase
-                 long style, const wxString& name )
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxToolBarTool : public wxToolBarToolBase
 {
-    bool ret = wxToolBarBase::Create( parent, id, pos, size, style, wxDefaultValidator, name );
+public:
-    
+    wxToolBarTool( wxToolBarBase *tbar = (wxToolBarBase *)NULL,
-    return ret;
+                   int id = wxID_SEPARATOR,
+                   const wxBitmap& bitmap1 = wxNullBitmap,
+                   const wxBitmap& bitmap2 = wxNullBitmap,
+                   bool toggle = FALSE,
+                   wxObject *clientData = (wxObject *) NULL,
+                   const wxString& shortHelpString = wxEmptyString,
+                   const wxString& longHelpString = wxEmptyString )
+        : wxToolBarToolBase(tbar, id, bitmap1, bitmap2, toggle, clientData,
+                            shortHelpString, longHelpString)
+    {
+        // no position yet
+        m_x =
+        m_y = -1;
     }
 
+public:
+    // the tool position (the size is known by the toolbar itself)
+    int m_x,
+        m_y;
+};
+
+// ============================================================================
+// wxToolBar implementation
+// ============================================================================
+
+IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxControl);
+
+// ----------------------------------------------------------------------------
+// wxToolBar creation
+// ----------------------------------------------------------------------------
+
 void wxToolBar::Init()
 {
-    // TODO: this is from tbarbase.cpp, but should be in
+    // no tools yet
-    // wxToolbarBase::Init
+    m_needsLayout = FALSE;
-    // the list owns the pointers
-    m_tools.DeleteContents(TRUE);
-    m_xMargin = m_yMargin = 0;
-    m_maxRows = m_maxCols = 0;
-    // End TODO
 
-    m_maxWidth = 0;
+    // unknown widths for the tools and separators
+    m_widthSeparator = INVALID_WIDTH;
+
+    m_maxWidth =
     m_maxHeight = 0;
 
-    m_captured = NULL;
+    m_toolPressed =
-    m_underMouse = NULL;
+    m_toolCurrent = NULL;
 
-    SetToolBitmapSize( wxSize(16,15) );
+    wxRenderer *renderer = GetRenderer();
+
+    SetToolBitmapSize(renderer->GetToolBarButtonSize(&m_widthSeparator));
+    SetMargins(renderer->GetToolBarMargin());
 }
 
-wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord x, wxCoord y) const
+bool wxToolBar::Create(wxWindow *parent,
+                       wxWindowID id,
+                       const wxPoint& pos,
+                       const wxSize& size,
+                       long style,
+                       const wxString& name)
 {
-    return NULL;
+    if ( !wxToolBarBase::Create(parent, id, pos, size, style,
+                                wxDefaultValidator, name) )
+    {
+        return FALSE;
     }
 
-void wxToolBar::SetToolShortHelp(int id, const wxString& helpString)
+    CreateInputHandler(wxINP_HANDLER_TOOLBAR);
-{
+
-}
+    SetBestSize(size);
 
-bool wxToolBar::DoInsertTool(size_t pos, wxToolBarToolBase *tool)
-{
     return TRUE;
 }
 
-bool wxToolBar::DoDeleteTool(size_t pos, wxToolBarToolBase *tool)
+wxToolBar::~wxToolBar()
 {
+}
+
+// ----------------------------------------------------------------------------
+// wxToolBar tool-related methods
+// ----------------------------------------------------------------------------
+
+wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord x, wxCoord y) const
+{
+    // check the "other" direction first: it must be inside the toolbar or we
+    // don't risk finding anything
+    if ( IsVertical() )
+    {
+        if ( x < 0 || x > m_maxWidth )
+            return NULL;
+
+        // we always use x, even for a vertical toolbar, this makes the code
+        // below simpler
+        x = y;
+    }
+    else // horizontal
+    {
+        if ( y < 0 || y > m_maxHeight )
+            return NULL;
+    }
+
+    for ( wxToolBarToolsList::Node *node = m_tools.GetFirst();
+          node;
+          node = node->GetNext() )
+    {
+        wxToolBarToolBase *tool =  node->GetData();
+        wxRect rectTool = GetToolRect(tool);
+
+        wxCoord startTool, endTool;
+        GetRectLimits(rectTool, &startTool, &endTool);
+
+        if ( x >= startTool && x <= endTool )
+        {
+            // don't return the separators from here, they don't accept any
+            // input anyhow
+            return tool->IsSeparator() ? NULL : tool;
+        }
+    }
+
+    return NULL;
+}
+
+void wxToolBar::SetToolShortHelp(int id, const wxString& help)
+{
+    wxToolBarToolBase *tool = FindById(id);
+
+    wxCHECK_RET( tool, _T("SetToolShortHelp: no such tool") );
+
+    tool->SetShortHelp(help);
+}
+
+bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos),
+                             wxToolBarToolBase * WXUNUSED(tool))
+{
+    // recalculate the toolbar geometry before redrawing it the next time
+    m_needsLayout = TRUE;
+
+    // and ensure that we indeed are going to redraw
+    Refresh();
+
+    return TRUE;
+}
+
+bool wxToolBar::DoDeleteTool(size_t WXUNUSED(pos),
+                             wxToolBarToolBase * WXUNUSED(tool))
+{
+    // as above
+    m_needsLayout = TRUE;
+
+    Refresh();
+
     return TRUE;
 }
 
 void wxToolBar::DoEnableTool(wxToolBarToolBase *tool, bool enable)
 {
-    // Comment this out if you don't want the disabled look,
+    // created disabled-state bitmap on demand
-    // which currently acts weirdly for the scissors icon
+    if ( !enable && !tool->GetDisabledBitmap().Ok() )
-    // in the toolbar sample. See src/common/tbarbase.cpp
-    // for the wxCreateGreyedImage function.
-#if 1
-    // Created disabled-state bitmap on demand
-    if (!enable && !tool->GetBitmap2().Ok())
     {
-        wxImage image( tool->GetBitmap1() );
+        wxImage image( tool->GetNormalBitmap() );
 
+        // TODO: don't hardcode 180
         unsigned char bg_red = 180;
         unsigned char bg_green = 180;
         unsigned char bg_blue = 180;
@@ -149,27 +258,22 @@ void wxToolBar::DoEnableTool(wxToolBarToolBase *tool, bool enable)
             }
         }
 
-        tool->SetBitmap2( image.ConvertToBitmap() );
+        tool->SetDisabledBitmap( image.ConvertToBitmap() );
     }
 
-    RefreshTool((wxToolBarTool*) tool);
+    RefreshTool(tool);
-#endif
 }
 
-void wxToolBar::DoToggleTool(wxToolBarToolBase *tool, bool toggle)
+void wxToolBar::DoToggleTool(wxToolBarToolBase *tool, bool WXUNUSED(toggle))
 {
-    wxToolBarTool *my_tool = (wxToolBarTool*) tool;
+    // note that if we're called the tool did change state (the base class
-    
+    // checks for it), so it's not necessary to check for this again here
-    bool refresh = (my_tool->IsToggled() != toggle);
+    RefreshTool(tool);
-    
-    my_tool->m_isDown = toggle;
-    
-    if (refresh)
-        RefreshTool( my_tool );
 }
 
-void wxToolBar::DoSetToggle(wxToolBarToolBase *tool, bool toggle)
+void wxToolBar::DoSetToggle(wxToolBarToolBase *tool, bool WXUNUSED(toggle))
 {
+    RefreshTool(tool);
 }
 
 wxToolBarToolBase *wxToolBar::CreateTool(int id,
@@ -186,85 +290,47 @@ wxToolBarToolBase *wxToolBar::CreateTool(int id,
 
 wxToolBarToolBase *wxToolBar::CreateTool(wxControl *control)
 {
-    wxFAIL_MSG( wxT("Toolbar doesn't support controls yet.") );
+    wxFAIL_MSG( wxT("Toolbar doesn't support controls yet (TODO)") );
 
     return NULL;
 }
 
-void wxToolBar::RefreshTool( wxToolBarTool *tool )
+// ----------------------------------------------------------------------------
+// wxToolBar geometry
+// ----------------------------------------------------------------------------
+
+wxRect wxToolBar::GetToolRect(wxToolBarToolBase *toolBase) const
 {
-    wxRect rect( tool->m_x, tool->m_y, m_defaultWidth+6, m_defaultHeight+6 );
+    const wxToolBarTool *tool = (wxToolBarTool *)toolBase;
-    Refresh( TRUE, &rect );
+
+    wxRect rect;
+
+    wxCHECK_MSG( tool, rect, _T("GetToolRect: NULL tool") );
+
+    // ensure that we always have the valid tool position
+    if ( m_needsLayout )
+    {
+        wxConstCast(this, wxToolBar)->DoLayout();
     }
 
-void wxToolBar::DrawToolBarTool( wxToolBarTool *tool, wxDC &dc, bool down )
+    rect.x = tool->m_x - m_xMargin;
-{
+    rect.y = tool->m_y - m_yMargin;
-    const wxBitmap& bitmap = (tool->IsEnabled() || !tool->GetBitmap2().Ok()) ? tool->GetBitmap1() : tool->GetBitmap2() ;
 
-    if (HasFlag(wxTB_FLAT) && (tool != m_underMouse))
+    if ( IsVertical() )
     {
-        if (down)
+        rect.width = m_defaultWidth;
-            dc.DrawBitmap( bitmap, tool->m_x+4, tool->m_y+4, TRUE );
+        rect.height = tool->IsSeparator() ? m_widthSeparator : m_defaultHeight;
-        else
+    }
-            dc.DrawBitmap( bitmap, tool->m_x+3, tool->m_y+3, TRUE );
+    else // horizontal
-            
+    {
-        return;
+        rect.width = tool->IsSeparator() ? m_widthSeparator : m_defaultWidth;
+        rect.height = m_defaultHeight;
     }
 
-    if (down)
+    rect.width += 2*m_xMargin;
-    {
+    rect.height += 2*m_yMargin;
-        dc.DrawBitmap( bitmap, tool->m_x+4, tool->m_y+4, TRUE );
 
-        dc.SetPen( *wxGREY_PEN );
+    return rect;
-        dc.DrawLine( tool->m_x, tool->m_y, tool->m_x+m_defaultWidth+5, tool->m_y );
-        dc.DrawLine( tool->m_x, tool->m_y, tool->m_x, tool->m_y+m_defaultHeight+5 );
-        
-        dc.SetPen( *wxBLACK_PEN );
-        dc.DrawLine( tool->m_x+1, tool->m_y+1, tool->m_x+m_defaultWidth+4, tool->m_y+1 );
-        dc.DrawLine( tool->m_x+1, tool->m_y+1, tool->m_x+1, tool->m_y+m_defaultHeight+4 );
-        
-        dc.SetPen( *wxWHITE_PEN );
-        dc.DrawLine( tool->m_x, tool->m_y+m_defaultHeight+5, tool->m_x+m_defaultWidth+6, tool->m_y+m_defaultHeight+5 );
-        dc.DrawLine( tool->m_x+m_defaultWidth+5, tool->m_y, tool->m_x+m_defaultWidth+5, tool->m_y+m_defaultHeight+6 );
-    }
-    else
-    {
-        dc.DrawBitmap( bitmap, tool->m_x+3, tool->m_y+3, TRUE );
-        
-        dc.SetPen( *wxWHITE_PEN );
-        dc.DrawLine( tool->m_x, tool->m_y, tool->m_x+m_defaultWidth+5, tool->m_y );
-        dc.DrawLine( tool->m_x, tool->m_y, tool->m_x, tool->m_y+m_defaultHeight+5 );
-        dc.DrawLine( tool->m_x+m_defaultWidth+4, tool->m_y, tool->m_x+m_defaultWidth+4, tool->m_y+2 );
-        dc.DrawLine( tool->m_x, tool->m_y+m_defaultHeight+4, tool->m_x+2, tool->m_y+m_defaultHeight+4 );
-        
-        dc.SetPen( *wxBLACK_PEN );
-        dc.DrawLine( tool->m_x, tool->m_y+m_defaultHeight+5, tool->m_x+m_defaultWidth+6, tool->m_y+m_defaultHeight+5 );
-        dc.DrawLine( tool->m_x+m_defaultWidth+5, tool->m_y, tool->m_x+m_defaultWidth+5, tool->m_y+m_defaultHeight+6 );
-        
-        dc.SetPen( *wxGREY_PEN );
-        dc.DrawLine( tool->m_x+1, tool->m_y+m_defaultHeight+4, tool->m_x+m_defaultWidth+5, tool->m_y+m_defaultHeight+4 );
-        dc.DrawLine( tool->m_x+m_defaultWidth+4, tool->m_y+1, tool->m_x+m_defaultWidth+4, tool->m_y+m_defaultHeight+5 );
-    }
-}
-
-void wxToolBar::OnPaint(wxPaintEvent &event)
-{
-    wxPaintDC dc(this);
-    
-    wxSize clientSize = GetClientSize();
-    dc.SetPen( *wxBLACK_PEN );
-    dc.DrawLine( 0,0, clientSize.x,0 );
-    
-    for ( wxToolBarToolsList::Node *node = m_tools.GetFirst();
-          node;
-          node = node->GetNext() )
-    {
-        wxToolBarTool *tool = (wxToolBarTool*) node->Data();
-        
-        if (tool->GetId() == -1) continue;
-        
-        DrawToolBarTool( tool, dc, tool->m_isDown );
-    }
 }
 
 bool wxToolBar::Realize()
@@ -272,181 +338,324 @@ bool wxToolBar::Realize()
     if ( !wxToolBarBase::Realize() )
         return FALSE;
 
-    int x;
+    m_needsLayout = TRUE;
-    int y;
+    DoLayout();
 
-    if (GetWindowStyleFlag() & wxTB_VERTICAL)
+    SetBestSize(wxDefaultSize);
-    {
-        m_xMargin += 1;   // Cannot help it, but otherwise it look ugly
-        
-        x = m_xMargin;
-        y = 5;
-    }
-    else
-    {
-        m_yMargin += 1;   // Cannot help it, but otherwise it look ugly
-        
-        y = m_yMargin;
-        x = 5;
-    }
-
-    for ( wxToolBarToolsList::Node *node = m_tools.GetFirst();
-          node;
-          node = node->GetNext() )
-    {
-        wxToolBarTool *tool = (wxToolBarTool*) node->Data();
-        
-        if (GetWindowStyleFlag() & wxTB_VERTICAL)
-        {
-            if (tool->GetId() == -1)
-            {
-                y += 6;
-                continue;
-            }
-            tool->m_x = m_xMargin;
-            tool->m_y = y;
-            y += m_defaultHeight + 6;
-
-            // Calculate the maximum height or width (depending on style)
-            // so we know how to size the toolbar in Realize.
-            // We could get the size of the tool instead of the
-            // default bitmap size
-            if (m_maxWidth < (m_defaultWidth + 2*(m_xMargin + 2)))
-                m_maxWidth = (m_defaultWidth + 2*(m_xMargin + 2)) ;
-        }
-        else
-        {
-            if (tool->GetId() == -1)
-            {
-                x += 6;
-                continue;
-            }
-            tool->m_x = x;
-            tool->m_y = m_yMargin;
-            x += m_defaultWidth + 6;
-
-            // Calculate the maximum height or width (depending on style)
-            // so we know how to size the toolbar in Realize.
-            // We could get the size of the tool instead of the
-            // default bitmap size
-            if (m_maxHeight < (m_defaultHeight + 2*(m_yMargin + 2)))
-                m_maxHeight = (m_defaultHeight + 2*(m_yMargin + 2)) ;
-        }
-        
-    }
-
-    wxSize sz = GetSize();
-    if (GetWindowStyleFlag() & wxTB_VERTICAL)
-    {
-        SetSize(m_maxWidth, sz.y);
-    }
-    else
-    {
-        SetSize(sz.x, m_maxHeight);
-    }
 
     return TRUE;
 }
 
-void wxToolBar::OnLeave(wxMouseEvent &event)
+void wxToolBar::DoLayout()
 {
-    if (HasFlag( wxTB_FLAT ))
+    wxASSERT_MSG( m_needsLayout, _T("why are we called?") );
-    {
-        wxToolBarTool *oldMouseUnder = m_underMouse;
-        if (m_underMouse)
-        {
-            m_underMouse = NULL;
-            RefreshTool( oldMouseUnder );
-        }
-    }
-}
 
-void wxToolBar::OnEnter(wxMouseEvent &event)
+    m_needsLayout = FALSE;
-{
-}
 
-void wxToolBar::OnMouse(wxMouseEvent &event)
+    wxCoord x = m_xMargin,
-{
+            y = m_yMargin;
-    wxToolBarTool *hit = NULL;
-    int x = event.GetX();
-    int y = event.GetY();
 
+    const wxCoord widthTool = IsVertical() ? m_defaultHeight : m_defaultWidth;
+    wxCoord margin = IsVertical() ? m_xMargin : m_yMargin,
+           *pCur = IsVertical() ? &y : &x;
+
+    // calculate the positions of all elements
     for ( wxToolBarToolsList::Node *node = m_tools.GetFirst();
           node;
           node = node->GetNext() )
     {
-        wxToolBarTool *tool = (wxToolBarTool*) node->Data();
+        wxToolBarTool *tool = (wxToolBarTool *) node->GetData();
 
-        if ((x > tool->m_x) && (x < tool->m_x+m_defaultWidth+5)  &&
+        tool->m_x = x;
-            (y > tool->m_y) && (y < tool->m_y+m_defaultHeight+5))
+        tool->m_y = y;
+
+        *pCur += (tool->IsSeparator() ? m_widthSeparator : widthTool) + margin;
+    }
+
+    // calculate the total toolbar size
+    wxCoord xMin = m_defaultWidth + 2*m_xMargin,
+            yMin = m_defaultHeight + 2*m_yMargin;
+
+    m_maxWidth = x < xMin ? xMin : x;
+    m_maxHeight = y < yMin ? yMin : y;
+}
+
+wxSize wxToolBar::DoGetBestClientSize() const
 {
-            hit = tool;
+    return wxSize(m_maxWidth, m_maxHeight);
+}
+
+// ----------------------------------------------------------------------------
+// wxToolBar drawing
+// ----------------------------------------------------------------------------
+
+void wxToolBar::RefreshTool(wxToolBarToolBase *tool)
+{
+    RefreshRect(GetToolRect(tool));
+}
+
+void wxToolBar::GetRectLimits(const wxRect& rect,
+                              wxCoord *start,
+                              wxCoord *end) const
+{
+    wxCHECK_RET( start && end, _T("NULL pointer in GetRectLimits") );
+
+    if ( IsVertical() )
+    {
+        *start = rect.GetTop();
+        *end = rect.GetBottom();
+    }
+    else // horizontal
+    {
+        *start = rect.GetLeft();
+        *end = rect.GetRight();
+    }
+}
+
+void wxToolBar::DoDraw(wxControlRenderer *renderer)
+{
+    // prepare the variables used below
+    wxDC& dc = renderer->GetDC();
+    wxRenderer *rend = renderer->GetRenderer();
+    // dc.SetFont(GetFont()); -- uncomment when we support labels
+
+    // draw the border separating us from the menubar (if there is no menubar
+    // we probably shouldn't draw it?)
+    if ( !IsVertical() )
+    {
+        rend->DrawHorizontalLine(dc, 0, 0, GetClientSize().x);
+    }
+
+    // get the update rect and its limits depending on the orientation
+    wxRect rectUpdate = GetUpdateClientRect();
+    wxCoord start, end;
+    GetRectLimits(rectUpdate, &start, &end);
+
+    // and redraw all the tools intersecting it
+    for ( wxToolBarToolsList::Node *node = m_tools.GetFirst();
+          node;
+          node = node->GetNext() )
+    {
+        wxToolBarToolBase *tool = node->GetData();
+        wxRect rectTool = GetToolRect(tool);
+        wxCoord startTool, endTool;
+        GetRectLimits(rectTool, &startTool, &endTool);
+
+        if ( endTool < start )
+        {
+            // we're still to the left of the area to redraw
+            continue;
+        }
+
+        if ( startTool > end )
+        {
+            // we're beyond the area to redraw, nothing left to do
             break;
         }
+
+        // deal with the flags
+        int flags = 0;
+
+        if ( tool->IsEnabled() )
+        {
+            // the toolbars without wxTB_FLAT don't react to the mouse hovering
+            if ( HasFlag(wxTB_FLAT) && (tool == m_toolCurrent) )
+                flags |= wxCONTROL_CURRENT;
+        }
+        else // disabled tool
+        {
+            flags |= wxCONTROL_DISABLED;
         }
 
-    wxToolBarTool *oldMouseUnder = m_underMouse;
+        if ( tool->IsToggled() )
+            flags |= wxCONTROL_PRESSED;
+
+        wxString label;
+        wxBitmap bitmap;
+        if ( !tool->IsSeparator() )
+        {
+            label = tool->GetLabel();
+            bitmap = tool->GetBitmap();
+        }
+        //else: leave both the label and the bitmap invalid to draw a separator
+
+        rend->DrawToolBarButton(dc, label, bitmap, rectTool, flags);
+    }
+}
+
+// ----------------------------------------------------------------------------
+// wxToolBar actions
+// ----------------------------------------------------------------------------
+
+void wxToolBar::Press()
+{
+    wxCHECK_RET( m_toolCurrent, _T("no tool to press?") );
+
+    m_toolPressed = m_toolCurrent;
+    if ( !m_toolPressed->IsToggled() )
+    {
+        m_toolPressed->Toggle(TRUE);
+
+        RefreshTool(m_toolPressed);
+    }
+}
+
+void wxToolBar::Release()
+{
+    wxCHECK_RET( m_toolPressed, _T("no tool to release?") );
+
+    if ( m_toolPressed->IsToggled() )
+    {
+        m_toolPressed->Toggle(FALSE);
+
+        RefreshTool(m_toolPressed);
+
+        m_toolPressed = NULL;
+    }
+}
+
+void wxToolBar::Toggle()
+{
+    wxCHECK_RET( m_toolPressed, _T("no tool to toggle?") );
+
+    // the togglable tools should keep their state when the mouse is released
+    if ( !m_toolPressed->CanBeToggled() )
+    {
+        m_toolPressed->Toggle();
+    }
+
+    RefreshTool(m_toolPressed);
+
+    m_toolCurrent = m_toolPressed;
+    m_toolPressed = NULL;
+
+    Click();
+}
+
+void wxToolBar::Click()
+{
+    wxCHECK_RET( m_toolCurrent, _T("no tool to click?") );
+
+    OnLeftClick(m_toolCurrent->GetId(), m_toolCurrent->IsToggled());
+}
+
+bool wxToolBar::PerformAction(const wxControlAction& action,
+                              long numArg,
+                              const wxString& strArg)
+{
+    if ( action == wxACTION_TOOLBAR_TOGGLE )
+        Toggle();
+    else if ( action == wxACTION_TOOLBAR_PRESS )
+        Press();
+    else if ( action == wxACTION_TOOLBAR_RELEASE )
+        Release();
+    else if ( action == wxACTION_TOOLBAR_CLICK )
+        Click();
+    else if ( action == wxACTION_TOOLBAR_ENTER )
+    {
+        wxToolBarToolBase *toolCurrentOld = m_toolCurrent;
+        m_toolCurrent = FindById((int)numArg);
+
+        if ( m_toolCurrent != toolCurrentOld )
+        {
+            // the appearance of the current tool only changes for the flat
+            // toolbars
             if ( HasFlag(wxTB_FLAT) )
             {
-        if (m_underMouse && (m_underMouse != hit))
+                // and only if the tool was/is enabled
+                if ( toolCurrentOld && toolCurrentOld->IsEnabled() )
+                    RefreshTool(toolCurrentOld);
+
+                if ( m_toolCurrent )
                 {
-            m_underMouse = NULL;
+                    if ( m_toolCurrent->IsEnabled() )
-            RefreshTool( oldMouseUnder );
+                        RefreshTool(m_toolCurrent);
                 }
-        m_underMouse = hit;
+                else
-    }
-    
-    if (event.LeftDown() && (hit) && hit->IsEnabled())
                 {
-        CaptureMouse();
+                    wxFAIL_MSG( _T("no current tool in wxACTION_TOOLBAR_ENTER?") );
-        m_captured = hit;
-        
-        m_captured->m_isDown = TRUE;
-        RefreshTool( m_captured );
-        
-        return;
                 }
-    
+            }
-    if (event.Dragging() && (m_captured))
+        }
+    }
+    else if ( action == wxACTION_TOOLBAR_LEAVE )
     {
-        bool is_down = (hit == m_captured);
+        if ( m_toolCurrent )
-        if (is_down != m_captured->m_isDown)
         {
-            m_captured->m_isDown = is_down;
+            wxToolBarToolBase *toolCurrentOld = m_toolCurrent;
-            RefreshTool( m_captured );
+            m_toolCurrent = NULL;
+
+            RefreshTool(toolCurrentOld);
+        }
+    }
+    else
+        return wxControl::PerformAction(action, numArg, strArg);
+
+    return TRUE;
 }
 
-        return;
+// ============================================================================
-    }
+// wxStdToolbarInputHandler implementation
+// ============================================================================
 
-    if (event.LeftUp() && (m_captured))
+wxStdToolbarInputHandler::wxStdToolbarInputHandler(wxInputHandler *handler)
+                        : wxStdButtonInputHandler(handler)
 {
-        ReleaseMouse();
+}
 
-        m_captured->m_isDown = FALSE;
+bool wxStdToolbarInputHandler::HandleKey(wxInputConsumer *consumer,
-        
+                                         const wxKeyEvent& event,
-        // Bad trick...
+                                         bool pressed)
-        m_underMouse = NULL;
-        
-        RefreshTool( m_captured );
-        
-        if (hit == m_captured)
 {
-            wxCommandEvent cevent( wxEVT_COMMAND_TOOL_CLICKED, m_captured->GetId() );
+    // TODO: when we have a current button we should allow the arrow
-            cevent.SetEventObject( this );
+    //       keys to move it
-            // cevent.SetExtraLong((long) toggleDown);
+    return wxStdInputHandler::HandleKey(consumer, event, pressed);
-            GetEventHandler()->ProcessEvent( cevent );
 }
 
-        m_captured = NULL;
+bool wxStdToolbarInputHandler::HandleMouseMove(wxInputConsumer *consumer,
-        
+                                               const wxMouseEvent& event)
-        return;
-    }
-    
-    if (HasFlag(wxTB_FLAT))
 {
-        if (m_underMouse && (m_underMouse != oldMouseUnder))
+    if ( !wxStdButtonInputHandler::HandleMouseMove(consumer, event) )
-            RefreshTool( m_underMouse );
+    {
+        wxToolBarToolBase *tool;
+
+        if ( event.Leaving() )
+        {
+            tool = NULL;
         }
+        else
+        {
+            wxToolBar *tbar = wxStaticCast(consumer->GetInputWindow(), wxToolBar);
+            tool = tbar->FindToolForPosition(event.GetX(), event.GetY());
+        }
+
+        if ( tool )
+            consumer->PerformAction(wxACTION_TOOLBAR_ENTER, tool->GetId());
+        else
+            consumer->PerformAction(wxACTION_TOOLBAR_LEAVE);
+
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+bool wxStdToolbarInputHandler::HandleFocus(wxInputConsumer *consumer,
+                                           const wxFocusEvent& event)
+{
+    // we shouldn't be left with a highlighted button
+    consumer->PerformAction(wxACTION_TOOLBAR_LEAVE);
+
+    return TRUE;
+}
+
+bool wxStdToolbarInputHandler::HandleActivation(wxInputConsumer *consumer,
+                                                bool activated)
+{
+    // as above
+    if ( !activated )
+        consumer->PerformAction(wxACTION_TOOLBAR_LEAVE);
+
+    return TRUE;
 }