Rework the wxCusor ctor taking wx stock number to provide as many cursors as

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

diff --git a/src/univ/toolbar.cpp b/src/univ/toolbar.cpp
index 45879f6613bb304605c33a8bde40e15c8c57494d..41dc5d22813557a9012a4c98c65da2cc82e2aa72 100644 (file)
--- a/src/univ/toolbar.cpp
+++ b/src/univ/toolbar.cpp
@@ -18,10 +18,6 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-    #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"
 


@@ -31,24 +27,50 @@
 
 #if wxUSE_TOOLBAR
 
 
 #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/log.h"
+    #include "wx/frame.h"
+    #include "wx/dc.h"
+    #include "wx/image.h"

 #endif
 
 #include "wx/univ/renderer.h"
 
 #endif
 
 #include "wx/univ/renderer.h"
 

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


@@ -71,31 +93,31 @@ public:
     {
         // 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_width =
         m_height = 0;
 
         // not pressed yet

-        m_isInverted = FALSE;
-        
+        m_isInverted = false;
+

         // mouse not here yet
         // mouse not here yet

-        m_underMouse = FALSE;
+        m_underMouse = false;

     }
 
     }
 

-    wxToolBarTool(wxToolBar *tbar, wxControl *control)
-        : wxToolBarToolBase(tbar, control)
+    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_width =
         m_height = 0;
 
         // not pressed yet

-        m_isInverted = FALSE;
-        
+        m_isInverted = false;
+

         // mouse not here yet
         // mouse not here yet

-        m_underMouse = FALSE;
+        m_underMouse = false;

     }
 
     // is this tool pressed, even temporarily? (this is different from being
     }
 
     // is this tool pressed, even temporarily? (this is different from being


@@ -108,9 +130,9 @@ public:
 
     // press the tool temporarily by inverting its toggle state
     void Invert() { m_isInverted = !m_isInverted; }
 
     // press the tool temporarily by inverting its toggle state
     void Invert() { m_isInverted = !m_isInverted; }

-    
+

     // Set underMouse
     // Set underMouse

-    void SetUnderMouse( bool under = TRUE ) { m_underMouse = under; }
+    void SetUnderMouse( bool under = true ) { m_underMouse = under; }

     bool IsUnderMouse() { return m_underMouse; }
 
 public:
     bool IsUnderMouse() { return m_underMouse; }
 
 public:


@@ -121,10 +143,10 @@ public:
     wxCoord m_height;
 
 private:
     wxCoord m_height;
 
 private:

-    // TRUE if the tool is pressed
+    // true if the tool is pressed

     bool m_isInverted;
     bool m_isInverted;

-    
-    // TRUE if the tool is under the mouse
+
+    // true if the tool is under the mouse

     bool m_underMouse;
 };
 
     bool m_underMouse;
 };
 


@@ -132,33 +154,16 @@ private:
 // wxToolBar implementation
 // ============================================================================
 
 // wxToolBar implementation
 // ============================================================================
 

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

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

-wxToolBar::wxToolBar()
-{
-    Init();
-}
-
-wxToolBar::wxToolBar(wxWindow *parent,
-                     wxWindowID id,
-                     const wxPoint& pos,
-                     const wxSize& size,
-                     long style,
-                     const wxString& name)
-{
-    Init();
-
-    Create(parent, id, pos, size, style, name);
-}
-

 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;


@@ -182,14 +187,16 @@ 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()


@@ -262,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
     if ( !enable && !tool->GetDisabledBitmap().Ok() )
     {
     // created disabled-state bitmap on demand
     if ( !enable && !tool->GetDisabledBitmap().Ok() )
     {

-        wxImage image( tool->GetNormalBitmap().ConvertToImage() );
-
-        // 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();
+        wxImage image(tool->GetNormalBitmap().ConvertToImage());

 
 

-        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 );
-                }
-            }
-        }
-
-        tool->SetDisabledBitmap(image);
+        tool->SetDisabledBitmap(image.ConvertToGreyscale());

     }
     }

+#endif // wxUSE_IMAGE

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


@@ -365,9 +328,10 @@ wxToolBarToolBase *wxToolBar::CreateTool(int id,
                              clientData, shortHelp, longHelp);
 }
 
                              clientData, shortHelp, longHelp);
 }
 

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

 {
 {

-    return new wxToolBarTool(this, control);
+    return new wxToolBarTool(this, control, label);

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


@@ -393,10 +357,19 @@ wxRect wxToolBar::GetToolRect(wxToolBarToolBase *toolBase) const
 
     if ( IsVertical() )
     {
 
     if ( IsVertical() )
     {

-               if (tool->IsButton())
+        if (tool->IsButton())

         {
         {

-            rect.width = m_defaultWidth;
-            rect.height = m_defaultHeight;
+            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())
         {
         }
         else if (tool->IsSeparator())
         {


@@ -413,8 +386,17 @@ wxRect wxToolBar::GetToolRect(wxToolBarToolBase *toolBase) const
     {
         if (tool->IsButton())
         {
     {
         if (tool->IsButton())
         {

-            rect.width = m_defaultWidth;
-            rect.height = m_defaultHeight;
+            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())
         {
         }
         else if (tool->IsSeparator())
         {


@@ -437,28 +419,61 @@ 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;
+
+    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;
+        }

 
 

-    return TRUE;
+        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()
 {
     wxASSERT_MSG( m_needsLayout, _T("why are we called?") );
 
 }
 
 void wxToolBar::DoLayout()
 {
     wxASSERT_MSG( m_needsLayout, _T("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
     for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
 
     // calculate the positions of all elements
     for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();


@@ -473,6 +488,32 @@ void wxToolBar::DoLayout()
         // TODO ugly number fiddling
         if (tool->IsButton())
         {
         // 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 += widthTool;
         }
         else if (tool->IsSeparator())


@@ -493,8 +534,26 @@ void wxToolBar::DoLayout()
     }
 
     // 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;


@@ -511,24 +570,24 @@ void wxToolBar::DoSetSize(int x, int y, int width, int height, int sizeFlags)
     GetSize(&old_width, &old_height);
 
     wxToolBarBase::DoSetSize(x, y, width, height, sizeFlags);
     GetSize(&old_width, &old_height);
 
     wxToolBarBase::DoSetSize(x, y, width, height, sizeFlags);

-    
+

     // Correct width and height if needed.
     // Correct width and height if needed.

-    if ( width == -1 || height == -1 )
+    if ( width == wxDefaultCoord || height == wxDefaultCoord )

     {
         int tmp_width, tmp_height;
         GetSize(&tmp_width, &tmp_height);
 
     {
         int tmp_width, tmp_height;
         GetSize(&tmp_width, &tmp_height);
 

-        if ( width == -1 )
+        if ( width == wxDefaultCoord )

             width = tmp_width;
             width = tmp_width;

-        if ( height == -1 )
+        if ( height == wxDefaultCoord )

             height = tmp_height;
     }
             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 )
     {
     // 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 )
     {

-        // But before we send the size event check it 
+        // But before we send the size event check it

         // we have a frame that is not being deleted.
         wxFrame *frame = wxDynamicCast(GetParent(), wxFrame);
         if ( frame && !frame->IsBeingDeleted() )
         // we have a frame that is not being deleted.
         wxFrame *frame = wxDynamicCast(GetParent(), wxFrame);
         if ( frame && !frame->IsBeingDeleted() )


@@ -570,7 +629,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?)


@@ -605,13 +664,13 @@ void wxToolBar::DoDraw(wxControlRenderer *renderer)
             // we're beyond the area to redraw, nothing left to do
             break;
         }
             // we're beyond the area to redraw, nothing left to do
             break;
         }

-        
+

         if (tool->IsSeparator() && !HasFlag(wxTB_FLAT))
         {
         if (tool->IsSeparator() && !HasFlag(wxTB_FLAT))
         {

-            // Draw seperators only in flat mode
+            // Draw separators only in flat mode

             continue;
         }
             continue;
         }

-        
+

         // deal with the flags
         int flags = 0;
 
         // deal with the flags
         int flags = 0;
 


@@ -636,14 +695,28 @@ void wxToolBar::DoDraw(wxControlRenderer *renderer)
         wxBitmap bitmap;
         if ( !tool->IsSeparator() )
         {
         wxBitmap bitmap;
         if ( !tool->IsSeparator() )
         {

-            // label = tool->GetLabel();
+            label = tool->GetLabel();

             bitmap = tool->GetBitmap();
         }
         //else: leave both the label and the bitmap invalid to draw a separator
 
         if ( !tool->IsControl() )
         {
             bitmap = tool->GetBitmap();
         }
         //else: leave both the label and the bitmap invalid to draw a separator
 
         if ( !tool->IsControl() )
         {

-            rend->DrawToolBarButton(dc, label, bitmap, rectTool, flags, tool->GetStyle());
+            int tbStyle = 0;
+            if(HasFlag(wxTB_TEXT))
+            {
+                tbStyle |= wxTB_TEXT;
+            }
+
+            if(HasFlag(wxTB_VERTICAL))
+            {
+                tbStyle |= wxTB_VERTICAL;
+            }
+            else
+            {
+                tbStyle |= wxTB_HORIZONTAL;
+            }
+            rend->DrawToolBarButton(dc, label, bitmap, rectTool, flags, tool->GetStyle(), tbStyle);

         }
         else // control
         {
         }
         else // control
         {


@@ -662,17 +735,23 @@ bool wxToolBar::PerformAction(const wxControlAction& action,
                               const wxString& strArg)
 {
     wxToolBarTool *tool = (wxToolBarTool*) FindById(numArg);
                               const wxString& strArg)
 {
     wxToolBarTool *tool = (wxToolBarTool*) FindById(numArg);

-    
+    if (!tool)
+        return false;
+

     if ( action == wxACTION_TOOLBAR_TOGGLE )
     {
         PerformAction( wxACTION_BUTTON_RELEASE, numArg );
 
         PerformAction( wxACTION_BUTTON_CLICK, numArg );
     if ( action == wxACTION_TOOLBAR_TOGGLE )
     {
         PerformAction( wxACTION_BUTTON_RELEASE, numArg );
 
         PerformAction( wxACTION_BUTTON_CLICK, numArg );

+
+        // 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 )
     {
         wxLogTrace(_T("toolbar"), _T("Button '%s' pressed."), tool->GetShortHelp().c_str());
     }
     else if ( action == wxACTION_TOOLBAR_PRESS )
     {
         wxLogTrace(_T("toolbar"), _T("Button '%s' pressed."), tool->GetShortHelp().c_str());

-        
+

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


@@ -682,8 +761,11 @@ bool wxToolBar::PerformAction(const wxControlAction& action,
         wxLogTrace(_T("toolbar"), _T("Button '%s' released."), tool->GetShortHelp().c_str());
 
         wxASSERT_MSG( tool->IsInverted(), _T("release unpressed button?") );
         wxLogTrace(_T("toolbar"), _T("Button '%s' released."), tool->GetShortHelp().c_str());
 
         wxASSERT_MSG( tool->IsInverted(), _T("release unpressed button?") );

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

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


@@ -692,7 +774,15 @@ bool wxToolBar::PerformAction(const wxControlAction& action,
         bool isToggled;
         if ( tool->CanBeToggled() )
         {
         bool isToggled;
         if ( tool->CanBeToggled() )
         {

-            tool->Toggle();
+            if ( tool->IsButton() && tool->GetKind() == wxITEM_RADIO )
+            {
+                UnToggleRadioGroup(tool);
+                tool->Toggle(true);
+            }
+            else
+            {
+                tool->Toggle();
+            }

 
             RefreshTool( tool );
 
 
             RefreshTool( tool );
 


@@ -700,30 +790,30 @@ bool wxToolBar::PerformAction(const wxControlAction& action,
         }
         else // simple non-checkable tool
         {
         }
         else // simple non-checkable tool
         {

-            isToggled = FALSE;
+            isToggled = false;

         }
         OnLeftClick( tool->GetId(), isToggled );
     }
     else if ( action == wxACTION_TOOLBAR_ENTER )
     {
         }
         OnLeftClick( tool->GetId(), isToggled );
     }
     else if ( action == wxACTION_TOOLBAR_ENTER )
     {

-        wxCHECK_MSG( tool, FALSE, _T("no tool to enter?") );
-        
+        wxCHECK_MSG( tool, false, _T("no tool to enter?") );
+

         if ( HasFlag(wxTB_FLAT) && tool->IsEnabled() )
         {
         if ( HasFlag(wxTB_FLAT) && tool->IsEnabled() )
         {

-            tool->SetUnderMouse( TRUE );
-            
+            tool->SetUnderMouse( true );
+

             if ( !tool->IsToggled() )
                 RefreshTool( tool );
         }
     }
     else if ( action == wxACTION_TOOLBAR_LEAVE )
     {
             if ( !tool->IsToggled() )
                 RefreshTool( tool );
         }
     }
     else if ( action == wxACTION_TOOLBAR_LEAVE )
     {

-        wxCHECK_MSG( tool, FALSE, _T("no tool to leave?") );
-        
+        wxCHECK_MSG( tool, false, _T("no tool to leave?") );
+

         if ( HasFlag(wxTB_FLAT) && tool->IsEnabled() )
         {
         if ( HasFlag(wxTB_FLAT) && tool->IsEnabled() )
         {

-            tool->SetUnderMouse( FALSE );
-            
+            tool->SetUnderMouse( false );
+

             if ( !tool->IsToggled() )
                 RefreshTool( tool );
         }
             if ( !tool->IsToggled() )
                 RefreshTool( tool );
         }


@@ -731,7 +821,15 @@ bool wxToolBar::PerformAction(const wxControlAction& action,
     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;

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


@@ -767,16 +865,16 @@ bool wxStdToolbarInputHandler::HandleMouse(wxInputConsumer *consumer,
         if ( event.LeftDown() || event.LeftDClick() )
         {
             if ( !tool || !tool->IsEnabled() )
         if ( event.LeftDown() || event.LeftDClick() )
         {
             if ( !tool || !tool->IsEnabled() )

-                return TRUE;
-                
+                return true;
+

             m_winCapture = tbar;
             m_winCapture->CaptureMouse();
             m_winCapture = tbar;
             m_winCapture->CaptureMouse();

-            
+

             m_toolCapture = tool;
 
             consumer->PerformAction( wxACTION_BUTTON_PRESS, tool->GetId() );
 
             m_toolCapture = tool;
 
             consumer->PerformAction( wxACTION_BUTTON_PRESS, tool->GetId() );
 

-            return TRUE;
+            return true;

         }
         else if ( event.LeftUp() )
         {
         }
         else if ( event.LeftUp() )
         {


@@ -793,10 +891,10 @@ bool wxStdToolbarInputHandler::HandleMouse(wxInputConsumer *consumer,
                 else
                     consumer->PerformAction( wxACTION_TOOLBAR_LEAVE, m_toolCapture->GetId() );
             }
                 else
                     consumer->PerformAction( wxACTION_TOOLBAR_LEAVE, m_toolCapture->GetId() );
             }

-            
+

             m_toolCapture = NULL;
             m_toolCapture = NULL;

-                
-            return TRUE;
+
+            return true;

         }
         //else: don't do anything special about the double click
     }
         }
         //else: don't do anything special about the double click
     }


@@ -810,7 +908,7 @@ bool wxStdToolbarInputHandler::HandleMouseMove(wxInputConsumer *consumer,
     if ( !wxStdInputHandler::HandleMouseMove(consumer, event) )
     {
         wxToolBar *tbar = wxStaticCast(consumer->GetInputWindow(), wxToolBar);
     if ( !wxStdInputHandler::HandleMouseMove(consumer, event) )
     {
         wxToolBar *tbar = wxStaticCast(consumer->GetInputWindow(), wxToolBar);

-        
+

         wxToolBarTool *tool;
         if ( event.Leaving() )
         {
         wxToolBarTool *tool;
         if ( event.Leaving() )
         {


@@ -822,59 +920,59 @@ bool wxStdToolbarInputHandler::HandleMouseMove(wxInputConsumer *consumer,
         {
             tool = (wxToolBarTool*) tbar->FindToolForPosition( event.GetX(), event.GetY() );
         }
         {
             tool = (wxToolBarTool*) tbar->FindToolForPosition( event.GetX(), event.GetY() );
         }

-        
+

         if (m_toolCapture)
         {
             // During capture we only care of the captured tool
             if (tool && (tool != m_toolCapture))
                 tool = NULL;
         if (m_toolCapture)
         {
             // During capture we only care of the captured tool
             if (tool && (tool != m_toolCapture))
                 tool = NULL;

-                
+

             if (tool == m_toolLast)
             if (tool == m_toolLast)

-                return TRUE;
-                
+                return true;
+

             if (tool)
                 consumer->PerformAction( wxACTION_BUTTON_PRESS, m_toolCapture->GetId() );
             else
                 consumer->PerformAction( wxACTION_BUTTON_RELEASE, m_toolCapture->GetId() );
             if (tool)
                 consumer->PerformAction( wxACTION_BUTTON_PRESS, m_toolCapture->GetId() );
             else
                 consumer->PerformAction( wxACTION_BUTTON_RELEASE, m_toolCapture->GetId() );

-                
+

             m_toolLast = tool;
         }
         else
         {
             if (tool == m_toolLast)
             m_toolLast = tool;
         }
         else
         {
             if (tool == m_toolLast)

-               return TRUE;
-               
+               return true;
+

             if (m_toolLast)
             {
                 // Leave old tool if any
                 consumer->PerformAction( wxACTION_TOOLBAR_LEAVE, m_toolLast->GetId() );
             }
             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() );
             }
             if (tool)
             {
                 // Enter new tool if any
                 consumer->PerformAction( wxACTION_TOOLBAR_ENTER, tool->GetId() );
             }

-        
+

             m_toolLast = tool;
         }
             m_toolLast = tool;
         }

-        
-        return TRUE;
+
+        return true;

     }
 
     }
 

-    return FALSE;
+    return false;

 }
 
 bool wxStdToolbarInputHandler::HandleFocus(wxInputConsumer *consumer,
                                            const wxFocusEvent& WXUNUSED(event))
 {
 }
 
 bool wxStdToolbarInputHandler::HandleFocus(wxInputConsumer *consumer,
                                            const wxFocusEvent& WXUNUSED(event))
 {

-    if ( m_toolCapture ) 
+    if ( m_toolCapture )

     {
         // We shouldn't be left with a highlighted button
         consumer->PerformAction( wxACTION_TOOLBAR_LEAVE, m_toolCapture->GetId() );
     }
 
     {
         // 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 wxStdToolbarInputHandler::HandleActivation(wxInputConsumer *consumer,


@@ -886,8 +984,7 @@ bool wxStdToolbarInputHandler::HandleActivation(wxInputConsumer *consumer,
         consumer->PerformAction( wxACTION_TOOLBAR_LEAVE, m_toolCapture->GetId() );
     }
 
         consumer->PerformAction( wxACTION_TOOLBAR_LEAVE, m_toolCapture->GetId() );
     }
 

-    return TRUE;
+    return true;

 }
 
 #endif // wxUSE_TOOLBAR
 }
 
 #endif // wxUSE_TOOLBAR

-