]> git.saurik.com Git - wxWidgets.git/blobdiff - src/univ/toolbar.cpp
use MoreFilesX instead of MoreFiles when building with Apple Developer Tools
[wxWidgets.git] / src / univ / toolbar.cpp
index 6692e1fbff018f62c30bbdcf44c9b8d3cc63e0b0..8f77a0470eb8d0c07c20211c6efa4fda4b08220e 100644 (file)
     #pragma hdrstop
 #endif
 
+#if wxUSE_TOOLBAR
+
 #ifndef WX_PRECOMP
     #include "wx/utils.h"
     #include "wx/app.h"
-
-    #include "wx/univ/renderer.h"
 #endif
 
+#include "wx/univ/renderer.h"
+
 #include "wx/toolbar.h"
 #include "wx/image.h"
+#include "wx/log.h"
 
 // ----------------------------------------------------------------------------
 // constants
@@ -53,26 +56,55 @@ static const wxCoord INVALID_WIDTH = -1;
 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 = -1;
+
+        // 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:
     // the tool position (the size is known by the toolbar itself)
     int m_x,
         m_y;
+
+private:
+    // TRUE if the tool is pressed
+    bool m_isInverted;
+    
+    // TRUE if the tool is under the mouse
+    bool m_underMouse;
 };
 
 // ============================================================================
@@ -96,9 +128,6 @@ void wxToolBar::Init()
     m_maxWidth =
     m_maxHeight = 0;
 
-    m_toolPressed =
-    m_toolCurrent = NULL;
-
     wxRenderer *renderer = GetRenderer();
 
     SetToolBitmapSize(renderer->GetToolBarButtonSize(&m_widthSeparator));
@@ -127,6 +156,15 @@ bool wxToolBar::Create(wxWindow *parent,
 
 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 );
 }
 
 // ----------------------------------------------------------------------------
@@ -210,7 +248,7 @@ void wxToolBar::DoEnableTool(wxToolBarToolBase *tool, bool enable)
     // created disabled-state bitmap on demand
     if ( !enable && !tool->GetDisabledBitmap().Ok() )
     {
-        wxImage image( tool->GetNormalBitmap() );
+        wxImage image( tool->GetNormalBitmap().ConvertToImage() );
 
         // TODO: don't hardcode 180
         unsigned char bg_red = 180;
@@ -258,7 +296,7 @@ void wxToolBar::DoEnableTool(wxToolBarToolBase *tool, bool enable)
             }
         }
 
-        tool->SetDisabledBitmap( image.ConvertToBitmap() );
+        tool->SetDisabledBitmap(image);
     }
 
     RefreshTool(tool);
@@ -277,15 +315,16 @@ void wxToolBar::DoSetToggle(wxToolBarToolBase *tool, bool WXUNUSED(toggle))
 }
 
 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,
-                                         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)
@@ -369,7 +408,8 @@ void wxToolBar::DoLayout()
         tool->m_x = x;
         tool->m_y = y;
 
-        *pCur += (tool->IsSeparator() ? m_widthSeparator : widthTool) + margin;
+        // TODO ugly number fiddling
+        *pCur += ( tool->IsSeparator() ? m_widthSeparator : (widthTool+2) ) + margin;
     }
 
     // calculate the total toolbar size
@@ -385,6 +425,39 @@ wxSize wxToolBar::DoGetBestClientSize() const
     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 == -1 || height == -1 )
+    {
+        int tmp_width, tmp_height;
+        GetSize(&tmp_width, &tmp_height);
+
+        if ( width == -1 )
+            width = tmp_width;
+        if ( height == -1 )
+            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 )
+    {
+        // 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() )
+        {
+            frame->SendSizeEvent();
+        }
+    }
+}
+
 // ----------------------------------------------------------------------------
 // wxToolBar drawing
 // ----------------------------------------------------------------------------
@@ -436,7 +509,7 @@ void wxToolBar::DoDraw(wxControlRenderer *renderer)
           node;
           node = node->GetNext() )
     {
-        wxToolBarToolBase *tool = node->GetData();
+        wxToolBarTool *tool = (wxToolBarTool*) node->GetData();
         wxRect rectTool = GetToolRect(tool);
         wxCoord startTool, endTool;
         GetRectLimits(rectTool, &startTool, &endTool);
@@ -452,14 +525,20 @@ void wxToolBar::DoDraw(wxControlRenderer *renderer)
             // we're beyond the area to redraw, nothing left to do
             break;
         }
-
+        
+        if (tool->IsSeparator() && !HasFlag(wxTB_FLAT))
+        {
+            // Draw seperators only in flat mode
+            continue;
+        }
+        
         // 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
@@ -467,14 +546,17 @@ void wxToolBar::DoDraw(wxControlRenderer *renderer)
             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;
         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
@@ -487,105 +569,75 @@ void wxToolBar::DoDraw(wxControlRenderer *renderer)
 // 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?") );
-
-    m_toolPressed = m_toolCurrent;
-    if ( !m_toolPressed->IsToggled() )
+    wxToolBarTool *tool = (wxToolBarTool*) FindById(numArg);
+    
+    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() )
+    else if ( action == wxACTION_TOOLBAR_PRESS )
     {
-        m_toolPressed->Toggle(FALSE);
+        wxLogTrace(_T("toolbar"), _T("Button '%s' pressed."), tool->GetShortHelp().c_str());
+        
+        tool->Invert();
 
-        RefreshTool(m_toolPressed);
-
-        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();
-    }
+        wxLogTrace(_T("toolbar"), _T("Button '%s' released."), tool->GetShortHelp().c_str());
 
-    RefreshTool(m_toolPressed);
+        wxASSERT_MSG( tool->IsInverted(), _T("release unpressed button?") );
+    
+        tool->Invert();
 
-    m_toolCurrent = m_toolPressed;
-    m_toolPressed = NULL;
-
-    Click();
-}
-
-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() )
+        {
+            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 )
     {
-        wxToolBarToolBase *toolCurrentOld = m_toolCurrent;
-        m_toolCurrent = FindById((int)numArg);
-
-        if ( m_toolCurrent != toolCurrentOld )
+        wxCHECK_MSG( tool, FALSE, _T("no tool to enter?") );
+        
+        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 )
     {
-        if ( m_toolCurrent )
+        wxCHECK_MSG( tool, FALSE, _T("no tool to leave?") );
+        
+        if ( HasFlag(wxTB_FLAT) && tool->IsEnabled() )
         {
-            wxToolBarToolBase *toolCurrentOld = m_toolCurrent;
-            m_toolCurrent = NULL;
-
-            RefreshTool(toolCurrentOld);
+            tool->SetUnderMouse( FALSE );
+            
+            if ( !tool->IsToggled() )
+                RefreshTool( tool );
         }
     }
     else
@@ -599,8 +651,11 @@ bool wxToolBar::PerformAction(const wxControlAction& action,
 // ============================================================================
 
 wxStdToolbarInputHandler::wxStdToolbarInputHandler(wxInputHandler *handler)
-                        : wxStdButtonInputHandler(handler)
+                        : wxStdInputHandler(handler)
 {
+    m_winCapture = NULL;
+    m_toolCapture = NULL;
+    m_toolLast = NULL;
 }
 
 bool wxStdToolbarInputHandler::HandleKey(wxInputConsumer *consumer,
@@ -612,28 +667,110 @@ bool wxStdToolbarInputHandler::HandleKey(wxInputConsumer *consumer,
     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)
 {
-    if ( !wxStdButtonInputHandler::HandleMouseMove(consumer, event) )
+    if ( !wxStdInputHandler::HandleMouseMove(consumer, event) )
     {
-        wxToolBarToolBase *tool;
-
+        wxToolBar *tbar = wxStaticCast(consumer->GetInputWindow(), wxToolBar);
+        
+        wxToolBarTool *tool;
         if ( event.Leaving() )
         {
+            // We cannot possibly be over a tool when
+            // leaving the toolbar
             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 (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;
         }
-
-        if ( tool )
-            consumer->PerformAction(wxACTION_TOOLBAR_ENTER, tool->GetId());
         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() );
+            }
+        
+            m_toolLast = tool;
+        }
+        
         return TRUE;
     }
 
@@ -643,8 +780,11 @@ bool wxStdToolbarInputHandler::HandleMouseMove(wxInputConsumer *consumer,
 bool wxStdToolbarInputHandler::HandleFocus(wxInputConsumer *consumer,
                                            const wxFocusEvent& 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;
 }
@@ -652,10 +792,14 @@ bool wxStdToolbarInputHandler::HandleFocus(wxInputConsumer *consumer,
 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;
 }
 
+#endif // wxUSE_TOOLBAR
+