Use the data scheme to load resources in the WebKitGTK+ implementation, rather than...

[wxWidgets.git] / src / univ / toolbar.cpp

diff --git a/src/univ/toolbar.cpp b/src/univ/toolbar.cpp
index 6692e1fbff018f62c30bbdcf44c9b8d3cc63e0b0..da03781e9c06d6d37a9341225c66bdce9fc7dd03 100644 (file)
--- a/src/univ/toolbar.cpp
+++ b/src/univ/toolbar.cpp
@@ -18,10 +18,6 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#ifdef __GNUG__
-    #pragma implementation "univtoolbar.h"
-#endif
-

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


@@ -29,22 +25,52 @@
     #pragma hdrstop
 #endif
 
     #pragma hdrstop
 #endif
 

+#if wxUSE_TOOLBAR
+
+#include "wx/toolbar.h"
+

 #ifndef WX_PRECOMP
     #include "wx/utils.h"
     #include "wx/app.h"
 #ifndef WX_PRECOMP
     #include "wx/utils.h"
     #include "wx/app.h"

-
-    #include "wx/univ/renderer.h"
+    #include "wx/log.h"
+    #include "wx/frame.h"
+    #include "wx/dc.h"
+    #include "wx/image.h"

 #endif
 
 #endif
 

-#include "wx/toolbar.h"
-#include "wx/image.h"
+#include "wx/univ/renderer.h"
+
+// ----------------------------------------------------------------------------
+// wxStdToolbarInputHandler: translates SPACE and ENTER keys and the left mouse
+// click into button press/release actions
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxStdToolbarInputHandler : public wxStdInputHandler
+{
+public:
+    wxStdToolbarInputHandler(wxInputHandler *inphand);
+
+    virtual bool HandleKey(wxInputConsumer *consumer,
+                           const wxKeyEvent& event,
+                           bool pressed);
+    virtual bool HandleMouse(wxInputConsumer *consumer,
+                             const wxMouseEvent& event);
+    virtual bool HandleMouseMove(wxInputConsumer *consumer, const wxMouseEvent& event);
+    virtual bool HandleFocus(wxInputConsumer *consumer, const wxFocusEvent& event);
+    virtual bool HandleActivation(wxInputConsumer *consumer, bool activated);
+
+private:
+    wxWindow            *m_winCapture;
+    wxToolBarToolBase   *m_toolCapture;
+    wxToolBarToolBase   *m_toolLast;
+};

 
 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------
 
 // value meaning that m_widthSeparator is not initialized
 
 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------
 
 // value meaning that m_widthSeparator is not initialized

-static const wxCoord INVALID_WIDTH = -1;
+static const wxCoord INVALID_WIDTH = wxDefaultCoord;

 
 // ----------------------------------------------------------------------------
 // wxToolBarTool: our implementation of wxToolBarToolBase
 
 // ----------------------------------------------------------------------------
 // wxToolBarTool: our implementation of wxToolBarToolBase


@@ -53,33 +79,82 @@ static const wxCoord INVALID_WIDTH = -1;
 class WXDLLEXPORT wxToolBarTool : public wxToolBarToolBase
 {
 public:
 class WXDLLEXPORT wxToolBarTool : public wxToolBarToolBase
 {
 public:

-    wxToolBarTool( wxToolBarBase *tbar = (wxToolBarBase *)NULL,
-                   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)
+    wxToolBarTool(wxToolBar *tbar,
+                  int id,
+                  const wxString& label,
+                  const wxBitmap& bmpNormal,
+                  const wxBitmap& bmpDisabled,
+                  wxItemKind kind,
+                  wxObject *clientData,
+                  const wxString& shortHelp,
+                  const wxString& longHelp)
+        : wxToolBarToolBase(tbar, id, label, bmpNormal, bmpDisabled, kind,
+                            clientData, shortHelp, longHelp)
+    {
+        // no position yet
+        m_x =
+        m_y = wxDefaultCoord;
+        m_width =
+        m_height = 0;
+
+        // not pressed yet
+        m_isInverted = false;
+
+        // mouse not here yet
+        m_underMouse = false;
+    }
+
+    wxToolBarTool(wxToolBar *tbar, wxControl *control, const wxString& label)
+        : wxToolBarToolBase(tbar, control, label)

     {
         // no position yet
         m_x =
     {
         // no position yet
         m_x =

-        m_y = -1;
+        m_y = wxDefaultCoord;
+        m_width =
+        m_height = 0;
+
+        // not pressed yet
+        m_isInverted = false;
+
+        // mouse not here yet
+        m_underMouse = false;

     }
 
     }
 

+    // is this tool pressed, even temporarily? (this is different from being
+    // permanently toggled which is what IsToggled() returns)
+    bool IsPressed() const
+        { return CanBeToggled() ? IsToggled() != m_isInverted : m_isInverted; }
+
+    // are we temporarily pressed/unpressed?
+    bool IsInverted() const { return m_isInverted; }
+
+    // press the tool temporarily by inverting its toggle state
+    void Invert() { m_isInverted = !m_isInverted; }
+
+    // Set underMouse
+    void SetUnderMouse( bool under = true ) { m_underMouse = under; }
+    bool IsUnderMouse() { return m_underMouse; }
+

 public:
 public:

-    // the tool position (the size is known by the toolbar itself)
-    int m_x,
-        m_y;
+    // the tool position (for controls)
+    wxCoord m_x;
+    wxCoord m_y;
+    wxCoord m_width;
+    wxCoord m_height;
+
+private:
+    // true if the tool is pressed
+    bool m_isInverted;
+
+    // true if the tool is under the mouse
+    bool m_underMouse;

 };
 
 // ============================================================================
 // wxToolBar implementation
 // ============================================================================
 
 };
 
 // ============================================================================
 // wxToolBar implementation
 // ============================================================================
 

-IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxControl);
+IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxControl)

 
 // ----------------------------------------------------------------------------
 // wxToolBar creation
 
 // ----------------------------------------------------------------------------
 // wxToolBar creation


@@ -88,7 +163,7 @@ IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxControl);
 void wxToolBar::Init()
 {
     // no tools yet
 void wxToolBar::Init()
 {
     // no tools yet

-    m_needsLayout = FALSE;
+    m_needsLayout = false;

 
     // unknown widths for the tools and separators
     m_widthSeparator = INVALID_WIDTH;
 
     // unknown widths for the tools and separators
     m_widthSeparator = INVALID_WIDTH;


@@ -96,9 +171,6 @@ void wxToolBar::Init()
     m_maxWidth =
     m_maxHeight = 0;
 
     m_maxWidth =
     m_maxHeight = 0;
 

-    m_toolPressed =
-    m_toolCurrent = NULL;
-

     wxRenderer *renderer = GetRenderer();
 
     SetToolBitmapSize(renderer->GetToolBarButtonSize(&m_widthSeparator));
     wxRenderer *renderer = GetRenderer();
 
     SetToolBitmapSize(renderer->GetToolBarButtonSize(&m_widthSeparator));


@@ -115,18 +187,29 @@ bool wxToolBar::Create(wxWindow *parent,
     if ( !wxToolBarBase::Create(parent, id, pos, size, style,
                                 wxDefaultValidator, name) )
     {
     if ( !wxToolBarBase::Create(parent, id, pos, size, style,
                                 wxDefaultValidator, name) )
     {

-        return FALSE;
+        return false;

     }
 
     }
 

+    FixupStyle();
+

     CreateInputHandler(wxINP_HANDLER_TOOLBAR);
 
     CreateInputHandler(wxINP_HANDLER_TOOLBAR);
 

-    SetBestSize(size);
+    SetInitialSize(size);

 
 

-    return TRUE;
+    return true;

 }
 
 wxToolBar::~wxToolBar()
 {
 }
 
 wxToolBar::~wxToolBar()
 {

+    // Make sure the toolbar is removed from the parent.
+    SetSize(0,0);
+}
+
+void wxToolBar::SetMargins(int x, int y)
+{
+    // This required for similar visual effects under
+    // native platforms and wxUniv.
+    wxToolBarBase::SetMargins( x + 3, y + 3 );

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


@@ -152,7 +235,7 @@ wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord x, wxCoord y) const
             return NULL;
     }
 
             return NULL;
     }
 

-    for ( wxToolBarToolsList::Node *node = m_tools.GetFirst();
+    for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();

           node;
           node = node->GetNext() )
     {
           node;
           node = node->GetNext() )
     {


@@ -177,7 +260,7 @@ void wxToolBar::SetToolShortHelp(int id, const wxString& help)
 {
     wxToolBarToolBase *tool = FindById(id);
 
 {
     wxToolBarToolBase *tool = FindById(id);
 

-    wxCHECK_RET( tool, _T("SetToolShortHelp: no such tool") );
+    wxCHECK_RET( tool, wxT("SetToolShortHelp: no such tool") );

 
     tool->SetShortHelp(help);
 }
 
     tool->SetShortHelp(help);
 }


@@ -186,80 +269,36 @@ bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos),
                              wxToolBarToolBase * WXUNUSED(tool))
 {
     // recalculate the toolbar geometry before redrawing it the next time
                              wxToolBarToolBase * WXUNUSED(tool))
 {
     // recalculate the toolbar geometry before redrawing it the next time

-    m_needsLayout = TRUE;
+    m_needsLayout = true;

 
     // and ensure that we indeed are going to redraw
     Refresh();
 
 
     // and ensure that we indeed are going to redraw
     Refresh();
 

-    return TRUE;
+    return true;

 }
 
 bool wxToolBar::DoDeleteTool(size_t WXUNUSED(pos),
                              wxToolBarToolBase * WXUNUSED(tool))
 {
     // as above
 }
 
 bool wxToolBar::DoDeleteTool(size_t WXUNUSED(pos),
                              wxToolBarToolBase * WXUNUSED(tool))
 {
     // as above

-    m_needsLayout = TRUE;
+    m_needsLayout = true;

 
     Refresh();
 
 
     Refresh();
 

-    return TRUE;
+    return true;

 }
 
 void wxToolBar::DoEnableTool(wxToolBarToolBase *tool, bool enable)
 {
 }
 
 void wxToolBar::DoEnableTool(wxToolBarToolBase *tool, bool enable)
 {

+#if wxUSE_IMAGE

     // created disabled-state bitmap on demand
     // created disabled-state bitmap on demand

-    if ( !enable && !tool->GetDisabledBitmap().Ok() )
+    if ( !enable && !tool->GetDisabledBitmap().IsOk() )

     {
     {

-        wxImage image( tool->GetNormalBitmap() );
-
-        // TODO: don't hardcode 180
-        unsigned char bg_red = 180;
-        unsigned char bg_green = 180;
-        unsigned char bg_blue = 180;
-
-        unsigned char mask_red = image.GetMaskRed();
-        unsigned char mask_green = image.GetMaskGreen();
-        unsigned char mask_blue = image.GetMaskBlue();
-
-        bool has_mask = image.HasMask();
-
-        int x,y;
-        for (y = 0; y < image.GetHeight(); y++)
-        {
-            for (x = 0; x < image.GetWidth(); x++)
-            {
-                unsigned char red = image.GetRed(x,y);
-                unsigned char green = image.GetGreen(x,y);
-                unsigned char blue = image.GetBlue(x,y);
-                if (!has_mask || red != mask_red || green != mask_green || blue != mask_blue)
-                {
-                    red = (((wxInt32) red  - bg_red) >> 1) + bg_red;
-                    green = (((wxInt32) green  - bg_green) >> 1) + bg_green;
-                    blue = (((wxInt32) blue  - bg_blue) >> 1) + bg_blue;
-                    image.SetRGB( x, y, red, green, blue );
-                }
-            }
-        }
-
-        for (y = 0; y < image.GetHeight(); y++)
-        {
-            for (x = y % 2; x < image.GetWidth(); x += 2)
-            {
-                unsigned char red = image.GetRed(x,y);
-                unsigned char green = image.GetGreen(x,y);
-                unsigned char blue = image.GetBlue(x,y);
-                if (!has_mask || red != mask_red || green != mask_green || blue != mask_blue)
-                {
-                    red = (((wxInt32) red  - bg_red) >> 1) + bg_red;
-                    green = (((wxInt32) green  - bg_green) >> 1) + bg_green;
-                    blue = (((wxInt32) blue  - bg_blue) >> 1) + bg_blue;
-                    image.SetRGB( x, y, red, green, blue );
-                }
-            }
-        }
+        wxImage image(tool->GetNormalBitmap().ConvertToImage());

 
 

-        tool->SetDisabledBitmap( image.ConvertToBitmap() );
+        tool->SetDisabledBitmap(image.ConvertToGreyscale());

     }
     }

+#endif // wxUSE_IMAGE

 
     RefreshTool(tool);
 }
 
     RefreshTool(tool);
 }


@@ -277,22 +316,22 @@ void wxToolBar::DoSetToggle(wxToolBarToolBase *tool, bool WXUNUSED(toggle))
 }
 
 wxToolBarToolBase *wxToolBar::CreateTool(int id,
 }
 
 wxToolBarToolBase *wxToolBar::CreateTool(int id,

-                                         const wxBitmap& bitmap1,
-                                         const wxBitmap& bitmap2,
-                                         bool toggle,
+                                         const wxString& label,
+                                         const wxBitmap& bmpNormal,
+                                         const wxBitmap& bmpDisabled,
+                                         wxItemKind kind,

                                          wxObject *clientData,
                                          wxObject *clientData,

-                                         const wxString& shortHelpString,
-                                         const wxString& longHelpString)
+                                         const wxString& shortHelp,
+                                         const wxString& longHelp)

 {
 {

-    return new wxToolBarTool( this, id, bitmap1, bitmap2, toggle,
-                              clientData, shortHelpString, longHelpString);
+    return new wxToolBarTool(this, id, label, bmpNormal, bmpDisabled, kind,
+                             clientData, shortHelp, longHelp);

 }
 
 }
 

-wxToolBarToolBase *wxToolBar::CreateTool(wxControl *control)
+wxToolBarToolBase *
+wxToolBar::CreateTool(wxControl *control, const wxString& label)

 {
 {

-    wxFAIL_MSG( wxT("Toolbar doesn't support controls yet (TODO)") );
-
-    return NULL;
+    return new wxToolBarTool(this, control, label);

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


@@ -305,7 +344,7 @@ wxRect wxToolBar::GetToolRect(wxToolBarToolBase *toolBase) const
 
     wxRect rect;
 
 
     wxRect rect;
 

-    wxCHECK_MSG( tool, rect, _T("GetToolRect: NULL tool") );
+    wxCHECK_MSG( tool, rect, wxT("GetToolRect: NULL tool") );

 
     // ensure that we always have the valid tool position
     if ( m_needsLayout )
 
     // ensure that we always have the valid tool position
     if ( m_needsLayout )


@@ -318,13 +357,57 @@ wxRect wxToolBar::GetToolRect(wxToolBarToolBase *toolBase) const
 
     if ( IsVertical() )
     {
 
     if ( IsVertical() )
     {

-        rect.width = m_defaultWidth;
-        rect.height = tool->IsSeparator() ? m_widthSeparator : m_defaultHeight;
+        if (tool->IsButton())
+        {
+            if(!HasFlag(wxTB_TEXT))
+            {
+                rect.width = m_defaultWidth;
+                rect.height = m_defaultHeight;
+            }
+            else
+            {
+                rect.width = m_defaultWidth +
+                    GetFont().GetPointSize() * tool->GetLabel().length();
+                rect.height = m_defaultHeight;
+            }
+        }
+        else if (tool->IsSeparator())
+        {
+            rect.width = m_defaultWidth;
+            rect.height = m_widthSeparator;
+        }
+        else // control
+        {
+            rect.width = tool->m_width;
+            rect.height = tool->m_height;
+        }

     }
     else // horizontal
     {
     }
     else // horizontal
     {

-        rect.width = tool->IsSeparator() ? m_widthSeparator : m_defaultWidth;
-        rect.height = m_defaultHeight;
+        if (tool->IsButton())
+        {
+            if(!HasFlag(wxTB_TEXT))
+            {
+                rect.width = m_defaultWidth;
+                rect.height = m_defaultHeight;
+            }
+            else
+            {
+                rect.width = m_defaultWidth +
+                    GetFont().GetPointSize() * tool->GetLabel().length();
+                rect.height = m_defaultHeight;
+            }
+        }
+        else if (tool->IsSeparator())
+        {
+            rect.width = m_widthSeparator;
+            rect.height = m_defaultHeight;
+        }
+        else // control
+        {
+            rect.width = tool->m_width;
+            rect.height = tool->m_height;
+        }

     }
 
     rect.width += 2*m_xMargin;
     }
 
     rect.width += 2*m_xMargin;


@@ -336,31 +419,64 @@ wxRect wxToolBar::GetToolRect(wxToolBarToolBase *toolBase) const
 bool wxToolBar::Realize()
 {
     if ( !wxToolBarBase::Realize() )
 bool wxToolBar::Realize()
 {
     if ( !wxToolBarBase::Realize() )

-        return FALSE;
+        return false;

 
 

-    m_needsLayout = TRUE;
+    m_needsLayout = true;

     DoLayout();
 
     DoLayout();
 

-    SetBestSize(wxDefaultSize);
+    // the first item in the radio group is checked by default to be consistent
+    // with wxGTK and the menu radio items
+    int radioGroupCount = 0;

 
 

-    return TRUE;
+    for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
+          node;
+          node = node->GetNext() )
+    {
+        wxToolBarTool *tool = (wxToolBarTool*) node->GetData();
+
+        if ( !tool->IsButton() || tool->GetKind() != wxITEM_RADIO )
+        {
+            radioGroupCount = 0;
+            continue;
+        }
+
+        bool toggle = !radioGroupCount++;
+        if ( tool->Toggle(toggle) )
+        {
+            DoToggleTool(tool, toggle);
+        }
+    }
+
+    SetInitialSize(wxDefaultSize);
+
+    return true;
+}
+
+void wxToolBar::SetWindowStyleFlag( long style )
+{
+    wxToolBarBase::SetWindowStyleFlag(style);
+
+    m_needsLayout = true;
+
+    Refresh();

 }
 
 void wxToolBar::DoLayout()
 {
 }
 
 void wxToolBar::DoLayout()
 {

-    wxASSERT_MSG( m_needsLayout, _T("why are we called?") );
+    wxASSERT_MSG( m_needsLayout, wxT("why are we called?") );

 
 

-    m_needsLayout = FALSE;
+    m_needsLayout = false;

 
     wxCoord x = m_xMargin,
             y = m_yMargin;
 
 
     wxCoord x = m_xMargin,
             y = m_yMargin;
 

-    const wxCoord widthTool = IsVertical() ? m_defaultHeight : m_defaultWidth;
-    wxCoord margin = IsVertical() ? m_xMargin : m_yMargin,
-           *pCur = IsVertical() ? &y : &x;
+    wxCoord widthTool = 0, maxWidthTool = 0;
+    wxCoord heightTool = 0, maxHeightTool = 0;
+    wxCoord margin = IsVertical() ? m_xMargin : m_yMargin;
+    wxCoord *pCur = IsVertical() ? &y : &x;

 
     // calculate the positions of all elements
 
     // calculate the positions of all elements

-    for ( wxToolBarToolsList::Node *node = m_tools.GetFirst();
+    for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();

           node;
           node = node->GetNext() )
     {
           node;
           node = node->GetNext() )
     {


@@ -369,12 +485,75 @@ void wxToolBar::DoLayout()
         tool->m_x = x;
         tool->m_y = y;
 
         tool->m_x = x;
         tool->m_y = y;
 

-        *pCur += (tool->IsSeparator() ? m_widthSeparator : widthTool) + margin;
+        // TODO ugly number fiddling
+        if (tool->IsButton())
+        {
+            if (IsVertical())
+            {
+                widthTool = m_defaultHeight;
+                heightTool = m_defaultWidth;
+                if(HasFlag(wxTB_TEXT))
+                    heightTool += GetFont().GetPointSize() * tool->GetLabel().length();
+            }
+            else
+            {
+                widthTool = m_defaultWidth;
+                if(HasFlag(wxTB_TEXT))
+                    widthTool += GetFont().GetPointSize() * tool->GetLabel().length();
+
+                heightTool = m_defaultHeight;
+            }
+
+            if(widthTool > maxWidthTool) // Record max width of tool
+            {
+                maxWidthTool = widthTool;
+            }
+
+            if(heightTool > maxHeightTool) // Record max width of tool
+            {
+                maxHeightTool = heightTool;
+            }
+
+            *pCur += widthTool;
+        }
+        else if (tool->IsSeparator())
+        {
+            *pCur += m_widthSeparator;
+        }
+        else if (!IsVertical()) // horizontal control
+        {
+            wxControl *control = tool->GetControl();
+            wxSize size = control->GetSize();
+            tool->m_y += (m_defaultHeight - size.y)/2;
+            tool->m_width = size.x;
+            tool->m_height = size.y;
+
+            *pCur += tool->m_width;
+        }
+        *pCur += margin;

     }
 
     // calculate the total toolbar size
     }
 
     // calculate the total toolbar size

-    wxCoord xMin = m_defaultWidth + 2*m_xMargin,
-            yMin = m_defaultHeight + 2*m_yMargin;
+    wxCoord xMin, yMin;
+
+    if(!HasFlag(wxTB_TEXT))
+    {
+        xMin = m_defaultWidth + 2*m_xMargin;
+        yMin = m_defaultHeight + 2*m_yMargin;
+    }
+    else
+    {
+        if (IsVertical())
+        {
+            xMin = heightTool + 2*m_xMargin;
+            yMin = widthTool + 2*m_xMargin;
+        }
+        else
+        {
+            xMin = maxWidthTool + 2*m_xMargin;
+            yMin = heightTool + 2*m_xMargin;
+        }
+    }

 
     m_maxWidth = x < xMin ? xMin : x;
     m_maxHeight = y < yMin ? yMin : y;
 
     m_maxWidth = x < xMin ? xMin : x;
     m_maxHeight = y < yMin ? yMin : y;


@@ -385,6 +564,33 @@ wxSize wxToolBar::DoGetBestClientSize() const
     return wxSize(m_maxWidth, m_maxHeight);
 }
 
     return wxSize(m_maxWidth, m_maxHeight);
 }
 

+void wxToolBar::DoSetSize(int x, int y, int width, int height, int sizeFlags)
+{
+    int old_width, old_height;
+    GetSize(&old_width, &old_height);
+
+    wxToolBarBase::DoSetSize(x, y, width, height, sizeFlags);
+
+    // Correct width and height if needed.
+    if ( width == wxDefaultCoord || height == wxDefaultCoord )
+    {
+        int tmp_width, tmp_height;
+        GetSize(&tmp_width, &tmp_height);
+
+        if ( width == wxDefaultCoord )
+            width = tmp_width;
+        if ( height == wxDefaultCoord )
+            height = tmp_height;
+    }
+
+    // We must refresh the frame size when the toolbar changes size
+    // otherwise the toolbar can be shown incorrectly
+    if ( old_width != width || old_height != height )
+    {
+        SendSizeEventToParent();
+    }
+}
+

 // ----------------------------------------------------------------------------
 // wxToolBar drawing
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxToolBar drawing
 // ----------------------------------------------------------------------------


@@ -398,7 +604,7 @@ void wxToolBar::GetRectLimits(const wxRect& rect,
                               wxCoord *start,
                               wxCoord *end) const
 {
                               wxCoord *start,
                               wxCoord *end) const
 {

-    wxCHECK_RET( start && end, _T("NULL pointer in GetRectLimits") );
+    wxCHECK_RET( start && end, wxT("NULL pointer in GetRectLimits") );

 
     if ( IsVertical() )
     {
 
     if ( IsVertical() )
     {


@@ -417,7 +623,7 @@ void wxToolBar::DoDraw(wxControlRenderer *renderer)
     // prepare the variables used below
     wxDC& dc = renderer->GetDC();
     wxRenderer *rend = renderer->GetRenderer();
     // prepare the variables used below
     wxDC& dc = renderer->GetDC();
     wxRenderer *rend = renderer->GetRenderer();

-    // dc.SetFont(GetFont()); -- uncomment when we support labels
+    dc.SetFont(GetFont());

 
     // draw the border separating us from the menubar (if there is no menubar
     // we probably shouldn't draw it?)
 
     // draw the border separating us from the menubar (if there is no menubar
     // we probably shouldn't draw it?)


@@ -432,11 +638,11 @@ void wxToolBar::DoDraw(wxControlRenderer *renderer)
     GetRectLimits(rectUpdate, &start, &end);
 
     // and redraw all the tools intersecting it
     GetRectLimits(rectUpdate, &start, &end);
 
     // and redraw all the tools intersecting it

-    for ( wxToolBarToolsList::Node *node = m_tools.GetFirst();
+    for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();

           node;
           node = node->GetNext() )
     {
           node;
           node = node->GetNext() )
     {

-        wxToolBarToolBase *tool = node->GetData();
+        wxToolBarTool *tool = (wxToolBarTool*) node->GetData();

         wxRect rectTool = GetToolRect(tool);
         wxCoord startTool, endTool;
         GetRectLimits(rectTool, &startTool, &endTool);
         wxRect rectTool = GetToolRect(tool);
         wxCoord startTool, endTool;
         GetRectLimits(rectTool, &startTool, &endTool);


@@ -453,13 +659,19 @@ void wxToolBar::DoDraw(wxControlRenderer *renderer)
             break;
         }
 
             break;
         }
 

+        if (tool->IsSeparator() && !HasFlag(wxTB_FLAT))
+        {
+            // Draw separators only in flat mode
+            continue;
+        }
+

         // deal with the flags
         int flags = 0;
 
         if ( tool->IsEnabled() )
         {
         // 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) )
+            // The toolbars without wxTB_FLAT don't react to the mouse hovering
+            if ( !HasFlag(wxTB_FLAT) || tool->IsUnderMouse() )

                 flags |= wxCONTROL_CURRENT;
         }
         else // disabled tool
                 flags |= wxCONTROL_CURRENT;
         }
         else // disabled tool


@@ -467,8 +679,11 @@ void wxToolBar::DoDraw(wxControlRenderer *renderer)
             flags |= wxCONTROL_DISABLED;
         }
 
             flags |= wxCONTROL_DISABLED;
         }
 

-        if ( tool->IsToggled() )
-            flags |= wxCONTROL_PRESSED;
+        //if ( tool == m_toolCaptured )
+        //    flags |= wxCONTROL_FOCUSED;
+
+        if ( tool->IsPressed() )
+            flags = wxCONTROL_PRESSED;

 
         wxString label;
         wxBitmap bitmap;
 
         wxString label;
         wxBitmap bitmap;


@@ -476,10 +691,32 @@ void wxToolBar::DoDraw(wxControlRenderer *renderer)
         {
             label = tool->GetLabel();
             bitmap = tool->GetBitmap();
         {
             label = tool->GetLabel();
             bitmap = tool->GetBitmap();

+
+            if ( !bitmap.IsOk() )
+            {
+                // it's better not to draw anything than to assert inside
+                // drawing code as this results in an almost guaranteed crash
+                // as we're likely to be called by a paint event handler and so
+                // the assert is going to be triggered again and again and ...
+                continue;
+            }

         }
         //else: leave both the label and the bitmap invalid to draw a separator
 
         }
         //else: leave both the label and the bitmap invalid to draw a separator
 

-        rend->DrawToolBarButton(dc, label, bitmap, rectTool, flags);
+        if ( !tool->IsControl() )
+        {
+            int tbStyle = HasFlag(wxTB_VERTICAL) ? wxTB_VERTICAL : wxTB_HORIZONTAL;
+            if ( HasFlag(wxTB_TEXT) )
+                tbStyle |= wxTB_TEXT;
+
+            rend->DrawToolBarButton(dc, label, bitmap, rectTool, flags,
+                                    tool->GetStyle(), tbStyle);
+        }
+        else // control
+        {
+            wxControl *control = tool->GetControl();
+            control->Move(tool->m_x, tool->m_y);
+        }

     }
 }
 
     }
 }
 


@@ -487,111 +724,106 @@ void wxToolBar::DoDraw(wxControlRenderer *renderer)
 // wxToolBar actions
 // ----------------------------------------------------------------------------
 
 // wxToolBar actions
 // ----------------------------------------------------------------------------
 

-void wxToolBar::Press()
+bool wxToolBar::PerformAction(const wxControlAction& action,
+                              long numArg,
+                              const wxString& strArg)

 {
 {

-    wxCHECK_RET( m_toolCurrent, _T("no tool to press?") );
+    wxToolBarTool *tool = (wxToolBarTool*) FindById(numArg);
+    if (!tool)
+        return false;

 
 

-    m_toolPressed = m_toolCurrent;
-    if ( !m_toolPressed->IsToggled() )
+    if ( action == wxACTION_TOOLBAR_TOGGLE )

     {
     {

-        m_toolPressed->Toggle(TRUE);
+        PerformAction( wxACTION_BUTTON_RELEASE, numArg );

 
 

-        RefreshTool(m_toolPressed);
-    }
-}
+        PerformAction( wxACTION_BUTTON_CLICK, numArg );

 
 

-void wxToolBar::Release()
-{
-    wxCHECK_RET( m_toolPressed, _T("no tool to release?") );
-
-    if ( m_toolPressed->IsToggled() )
+        // Set mouse leave toolbar button range (If still in the range,
+        // toolbar button would get focus again
+        PerformAction( wxACTION_TOOLBAR_LEAVE, numArg );
+    }
+    else if ( action == wxACTION_TOOLBAR_PRESS )

     {
     {

-        m_toolPressed->Toggle(FALSE);
+        wxLogTrace(wxT("toolbar"), wxT("Button '%s' pressed."), tool->GetShortHelp().c_str());

 
 

-        RefreshTool(m_toolPressed);
+        tool->Invert();

 
 

-        m_toolPressed = NULL;
+        RefreshTool( tool );

     }
     }

-}
-
-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() )
+    else if ( action == wxACTION_TOOLBAR_RELEASE )

     {
     {

-        m_toolPressed->Toggle();
-    }
-
-    RefreshTool(m_toolPressed);
+        wxLogTrace(wxT("toolbar"), wxT("Button '%s' released."), tool->GetShortHelp().c_str());

 
 

-    m_toolCurrent = m_toolPressed;
-    m_toolPressed = NULL;
+        wxASSERT_MSG( tool->IsInverted(), wxT("release unpressed button?") );

 
 

-    Click();
-}
+        if(tool->IsInverted())
+        {
+            tool->Invert();
+        }

 
 

-void wxToolBar::Click()
-{
-    wxCHECK_RET( m_toolCurrent, _T("no tool to click?") );
+        RefreshTool( tool );
+    }
+    else if ( action == wxACTION_TOOLBAR_CLICK )
+    {
+        bool isToggled;
+        if ( tool->CanBeToggled() )
+        {
+            if ( tool->IsButton() && tool->GetKind() == wxITEM_RADIO )
+            {
+                UnToggleRadioGroup(tool);
+                tool->Toggle(true);
+            }
+            else
+            {
+                tool->Toggle();
+            }

 
 

-    OnLeftClick(m_toolCurrent->GetId(), m_toolCurrent->IsToggled());
-}
+            RefreshTool( tool );

 
 

-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();
+            isToggled = tool->IsToggled();
+        }
+        else // simple non-checkable tool
+        {
+            isToggled = false;
+        }
+        OnLeftClick( tool->GetId(), isToggled );
+    }

     else if ( action == wxACTION_TOOLBAR_ENTER )
     {
     else if ( action == wxACTION_TOOLBAR_ENTER )
     {

-        wxToolBarToolBase *toolCurrentOld = m_toolCurrent;
-        m_toolCurrent = FindById((int)numArg);
+        wxCHECK_MSG( tool, false, wxT("no tool to enter?") );

 
 

-        if ( m_toolCurrent != toolCurrentOld )
+        if ( HasFlag(wxTB_FLAT) && tool->IsEnabled() )

         {
         {

-            // the appearance of the current tool only changes for the flat
-            // toolbars
-            if ( HasFlag(wxTB_FLAT) )
-            {
-                // and only if the tool was/is enabled
-                if ( toolCurrentOld && toolCurrentOld->IsEnabled() )
-                    RefreshTool(toolCurrentOld);
-
-                if ( m_toolCurrent )
-                {
-                    if ( m_toolCurrent->IsEnabled() )
-                        RefreshTool(m_toolCurrent);
-                }
-                else
-                {
-                    wxFAIL_MSG( _T("no current tool in wxACTION_TOOLBAR_ENTER?") );
-                }
-            }
+            tool->SetUnderMouse( true );
+
+            if ( !tool->IsToggled() )
+                RefreshTool( tool );

         }
     }
     else if ( action == wxACTION_TOOLBAR_LEAVE )
     {
         }
     }
     else if ( action == wxACTION_TOOLBAR_LEAVE )
     {

-        if ( m_toolCurrent )
+        wxCHECK_MSG( tool, false, wxT("no tool to leave?") );
+
+        if ( HasFlag(wxTB_FLAT) && tool->IsEnabled() )

         {
         {

-            wxToolBarToolBase *toolCurrentOld = m_toolCurrent;
-            m_toolCurrent = NULL;
+            tool->SetUnderMouse( false );

 
 

-            RefreshTool(toolCurrentOld);
+            if ( !tool->IsToggled() )
+                RefreshTool( tool );

         }
     }
     else
         return wxControl::PerformAction(action, numArg, strArg);
 
         }
     }
     else
         return wxControl::PerformAction(action, numArg, strArg);
 

-    return TRUE;
+    return true;
+}
+
+/* static */
+wxInputHandler *wxToolBar::GetStdInputHandler(wxInputHandler *handlerDef)
+{
+    static wxStdToolbarInputHandler s_handler(handlerDef);
+
+    return &s_handler;

 }
 
 // ============================================================================
 }
 
 // ============================================================================


@@ -599,8 +831,11 @@ bool wxToolBar::PerformAction(const wxControlAction& action,
 // ============================================================================
 
 wxStdToolbarInputHandler::wxStdToolbarInputHandler(wxInputHandler *handler)
 // ============================================================================
 
 wxStdToolbarInputHandler::wxStdToolbarInputHandler(wxInputHandler *handler)

-                        : wxStdButtonInputHandler(handler)
+                        : wxStdInputHandler(handler)

 {
 {

+    m_winCapture = NULL;
+    m_toolCapture = NULL;
+    m_toolLast = NULL;

 }
 
 bool wxStdToolbarInputHandler::HandleKey(wxInputConsumer *consumer,
 }
 
 bool wxStdToolbarInputHandler::HandleKey(wxInputConsumer *consumer,


@@ -612,50 +847,138 @@ bool wxStdToolbarInputHandler::HandleKey(wxInputConsumer *consumer,
     return wxStdInputHandler::HandleKey(consumer, event, pressed);
 }
 
     return wxStdInputHandler::HandleKey(consumer, event, pressed);
 }
 

+bool wxStdToolbarInputHandler::HandleMouse(wxInputConsumer *consumer,
+                                           const wxMouseEvent& event)
+{
+    wxToolBar *tbar = wxStaticCast(consumer->GetInputWindow(), wxToolBar);
+    wxToolBarToolBase *tool = tbar->FindToolForPosition(event.GetX(), event.GetY());
+
+    if ( event.Button(1) )
+    {
+
+        if ( event.LeftDown() || event.LeftDClick() )
+        {
+            if ( !tool || !tool->IsEnabled() )
+                return true;
+
+            m_winCapture = tbar;
+            m_winCapture->CaptureMouse();
+
+            m_toolCapture = tool;
+
+            consumer->PerformAction( wxACTION_BUTTON_PRESS, tool->GetId() );
+
+            return true;
+        }
+        else if ( event.LeftUp() )
+        {
+            if ( m_winCapture )
+            {
+                m_winCapture->ReleaseMouse();
+                m_winCapture = NULL;
+            }
+
+            if (m_toolCapture)
+            {
+                if ( tool == m_toolCapture )
+                    consumer->PerformAction( wxACTION_BUTTON_TOGGLE, m_toolCapture->GetId() );
+                else
+                    consumer->PerformAction( wxACTION_TOOLBAR_LEAVE, m_toolCapture->GetId() );
+            }
+
+            m_toolCapture = NULL;
+
+            return true;
+        }
+        //else: don't do anything special about the double click
+    }
+
+    return wxStdInputHandler::HandleMouse(consumer, event);
+}
+

 bool wxStdToolbarInputHandler::HandleMouseMove(wxInputConsumer *consumer,
                                                const wxMouseEvent& event)
 {
 bool wxStdToolbarInputHandler::HandleMouseMove(wxInputConsumer *consumer,
                                                const wxMouseEvent& event)
 {

-    if ( !wxStdButtonInputHandler::HandleMouseMove(consumer, event) )
+    if ( !wxStdInputHandler::HandleMouseMove(consumer, event) )

     {
     {

-        wxToolBarToolBase *tool;
+        wxToolBar *tbar = wxStaticCast(consumer->GetInputWindow(), wxToolBar);

 
 

+        wxToolBarTool *tool;

         if ( event.Leaving() )
         {
         if ( event.Leaving() )
         {

+            // We cannot possibly be over a tool when
+            // leaving the toolbar

             tool = NULL;
         }
         else
         {
             tool = NULL;
         }
         else
         {

-            wxToolBar *tbar = wxStaticCast(consumer->GetInputWindow(), wxToolBar);
-            tool = tbar->FindToolForPosition(event.GetX(), event.GetY());
+            tool = (wxToolBarTool*) tbar->FindToolForPosition( event.GetX(), event.GetY() );

         }
 
         }
 

-        if ( tool )
-            consumer->PerformAction(wxACTION_TOOLBAR_ENTER, tool->GetId());
+        if (m_toolCapture)
+        {
+            // During capture we only care of the captured tool
+            if (tool && (tool != m_toolCapture))
+                tool = NULL;
+
+            if (tool == m_toolLast)
+                return true;
+
+            if (tool)
+                consumer->PerformAction( wxACTION_BUTTON_PRESS, m_toolCapture->GetId() );
+            else
+                consumer->PerformAction( wxACTION_BUTTON_RELEASE, m_toolCapture->GetId() );
+
+            m_toolLast = tool;
+        }

         else
         else

-            consumer->PerformAction(wxACTION_TOOLBAR_LEAVE);
+        {
+            if (tool == m_toolLast)
+               return true;
+
+            if (m_toolLast)
+            {
+                // Leave old tool if any
+                consumer->PerformAction( wxACTION_TOOLBAR_LEAVE, m_toolLast->GetId() );
+            }
+
+            if (tool)
+            {
+                // Enter new tool if any
+                consumer->PerformAction( wxACTION_TOOLBAR_ENTER, tool->GetId() );
+            }

 
 

-        return TRUE;
+            m_toolLast = tool;
+        }
+
+        return true;

     }
 
     }
 

-    return FALSE;
+    return false;

 }
 
 bool wxStdToolbarInputHandler::HandleFocus(wxInputConsumer *consumer,
 }
 
 bool wxStdToolbarInputHandler::HandleFocus(wxInputConsumer *consumer,

-                                           const wxFocusEvent& event)
+                                           const wxFocusEvent& WXUNUSED(event))

 {
 {

-    // we shouldn't be left with a highlighted button
-    consumer->PerformAction(wxACTION_TOOLBAR_LEAVE);
+    if ( m_toolCapture )
+    {
+        // We shouldn't be left with a highlighted button
+        consumer->PerformAction( wxACTION_TOOLBAR_LEAVE, m_toolCapture->GetId() );
+    }

 
 

-    return TRUE;
+    return true;

 }
 
 bool wxStdToolbarInputHandler::HandleActivation(wxInputConsumer *consumer,
                                                 bool activated)
 {
 }
 
 bool wxStdToolbarInputHandler::HandleActivation(wxInputConsumer *consumer,
                                                 bool activated)
 {

-    // as above
-    if ( !activated )
-        consumer->PerformAction(wxACTION_TOOLBAR_LEAVE);
+    if (m_toolCapture && !activated)
+    {
+        // We shouldn't be left with a highlighted button
+        consumer->PerformAction( wxACTION_TOOLBAR_LEAVE, m_toolCapture->GetId() );
+    }

 
 

-    return TRUE;
+    return true;

 }
 
 }
 

+#endif // wxUSE_TOOLBAR