X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/6a317e61887db770025fc6c642c2105f1cefe3ac..2028c33ab5a39a12bd410ac953731a56ad6377ba:/src/univ/toolbar.cpp?ds=sidebyside diff --git a/src/univ/toolbar.cpp b/src/univ/toolbar.cpp index e17794b8ce..44c188fba3 100644 --- a/src/univ/toolbar.cpp +++ b/src/univ/toolbar.cpp @@ -18,10 +18,6 @@ // headers // ---------------------------------------------------------------------------- -#ifdef __GNUG__ - #pragma implementation "univtoolbar.h" -#endif - // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" @@ -31,22 +27,50 @@ #if wxUSE_TOOLBAR +#include "wx/toolbar.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 -#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 -static const wxCoord INVALID_WIDTH = -1; +static const wxCoord INVALID_WIDTH = wxDefaultCoord; // ---------------------------------------------------------------------------- // wxToolBarTool: our implementation of wxToolBarToolBase @@ -55,23 +79,45 @@ 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; + m_y = wxDefaultCoord; + m_width = + m_height = 0; // not pressed yet - m_isInverted = FALSE; + 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 = + 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 @@ -85,21 +131,30 @@ public: // 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; + // the tool position (for controls) + wxCoord m_x; + wxCoord m_y; + wxCoord m_width; + wxCoord m_height; private: - // TRUE if the tool is pressed + // true if the tool is pressed bool m_isInverted; + + // true if the tool is under the mouse + bool m_underMouse; }; // ============================================================================ // wxToolBar implementation // ============================================================================ -IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxControl); +IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxControl) // ---------------------------------------------------------------------------- // wxToolBar creation @@ -108,7 +163,7 @@ IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxControl); void wxToolBar::Init() { // no tools yet - m_needsLayout = FALSE; + m_needsLayout = false; // unknown widths for the tools and separators m_widthSeparator = INVALID_WIDTH; @@ -116,9 +171,6 @@ void wxToolBar::Init() m_maxWidth = m_maxHeight = 0; - m_toolPressed = NULL; - m_toolCurrent = NULL; - wxRenderer *renderer = GetRenderer(); SetToolBitmapSize(renderer->GetToolBarButtonSize(&m_widthSeparator)); @@ -135,18 +187,29 @@ bool wxToolBar::Create(wxWindow *parent, if ( !wxToolBarBase::Create(parent, id, pos, size, style, wxDefaultValidator, name) ) { - return FALSE; + return false; } + FixupStyle(); + CreateInputHandler(wxINP_HANDLER_TOOLBAR); - SetBestSize(size); + SetInitialSize(size); - return TRUE; + return true; } 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 ); } // ---------------------------------------------------------------------------- @@ -172,7 +235,7 @@ wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord x, wxCoord y) const return NULL; } - for ( wxToolBarToolsList::Node *node = m_tools.GetFirst(); + for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst(); node; node = node->GetNext() ) { @@ -197,7 +260,7 @@ void wxToolBar::SetToolShortHelp(int id, const wxString& help) { wxToolBarToolBase *tool = FindById(id); - wxCHECK_RET( tool, _T("SetToolShortHelp: no such tool") ); + wxCHECK_RET( tool, wxT("SetToolShortHelp: no such tool") ); tool->SetShortHelp(help); } @@ -206,80 +269,36 @@ bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), 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(); - return TRUE; + return true; } bool wxToolBar::DoDeleteTool(size_t WXUNUSED(pos), wxToolBarToolBase * WXUNUSED(tool)) { // as above - m_needsLayout = TRUE; + m_needsLayout = true; Refresh(); - return TRUE; + return true; } void wxToolBar::DoEnableTool(wxToolBarToolBase *tool, bool enable) { +#if wxUSE_IMAGE // created disabled-state bitmap on demand if ( !enable && !tool->GetDisabledBitmap().Ok() ) { - 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); } @@ -297,22 +316,22 @@ 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) +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); } // ---------------------------------------------------------------------------- @@ -325,7 +344,7 @@ wxRect wxToolBar::GetToolRect(wxToolBarToolBase *toolBase) const 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 ) @@ -338,13 +357,57 @@ wxRect wxToolBar::GetToolRect(wxToolBarToolBase *toolBase) const 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 { - 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; @@ -356,31 +419,64 @@ wxRect wxToolBar::GetToolRect(wxToolBarToolBase *toolBase) const bool wxToolBar::Realize() { if ( !wxToolBarBase::Realize() ) - return FALSE; + return false; - m_needsLayout = TRUE; + m_needsLayout = true; 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; + } + + bool toggle = !radioGroupCount++; + if ( tool->Toggle(toggle) ) + { + DoToggleTool(tool, toggle); + } + } + + SetInitialSize(wxDefaultSize); - return TRUE; + 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?") ); + wxASSERT_MSG( m_needsLayout, wxT("why are we called?") ); - m_needsLayout = FALSE; + m_needsLayout = false; 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::Node *node = m_tools.GetFirst(); + for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst(); node; node = node->GetNext() ) { @@ -389,12 +485,75 @@ void wxToolBar::DoLayout() 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 - 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; @@ -405,6 +564,33 @@ 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 == 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 // ---------------------------------------------------------------------------- @@ -418,7 +604,7 @@ void wxToolBar::GetRectLimits(const wxRect& rect, 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() ) { @@ -437,7 +623,7 @@ void wxToolBar::DoDraw(wxControlRenderer *renderer) // prepare the variables used below wxDC& dc = renderer->GetDC(); wxRenderer *rend = renderer->GetRenderer(); - // dc.SetFont(GetFont()); -- uncomment when we support labels + dc.SetFont(GetFont()); // draw the border separating us from the menubar (if there is no menubar // we probably shouldn't draw it?) @@ -452,11 +638,11 @@ void wxToolBar::DoDraw(wxControlRenderer *renderer) 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() ) { - wxToolBarToolBase *tool = node->GetData(); + wxToolBarTool *tool = (wxToolBarTool*) node->GetData(); wxRect rectTool = GetToolRect(tool); wxCoord startTool, endTool; GetRectLimits(rectTool, &startTool, &endTool); @@ -473,13 +659,19 @@ void wxToolBar::DoDraw(wxControlRenderer *renderer) break; } + if (tool->IsSeparator() && !HasFlag(wxTB_FLAT)) + { + // Draw separators 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 @@ -487,11 +679,11 @@ void wxToolBar::DoDraw(wxControlRenderer *renderer) flags |= wxCONTROL_DISABLED; } - if ( tool == m_toolPressed ) - flags |= wxCONTROL_FOCUSED; + //if ( tool == m_toolCaptured ) + // flags |= wxCONTROL_FOCUSED; - if ( ((wxToolBarTool *)tool)->IsPressed() ) - flags |= wxCONTROL_PRESSED; + if ( tool->IsPressed() ) + flags = wxCONTROL_PRESSED; wxString label; wxBitmap bitmap; @@ -499,10 +691,32 @@ void wxToolBar::DoDraw(wxControlRenderer *renderer) { 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 - 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); + } } } @@ -510,122 +724,106 @@ void wxToolBar::DoDraw(wxControlRenderer *renderer) // wxToolBar actions // ---------------------------------------------------------------------------- -void wxToolBar::Press() -{ - wxCHECK_RET( m_toolCurrent, _T("no tool to press?") ); - - wxLogTrace(_T("toolbar"), - _T("Button '%s' pressed."), - m_toolCurrent->GetShortHelp().c_str()); - - // this is the tool whose state is going to change - m_toolPressed = (wxToolBarTool *)m_toolCurrent; - - // we must toggle it regardless of whether it is a checkable tool or not, - // so use Invert() and not Toggle() here - m_toolPressed->Invert(); - - RefreshTool(m_toolPressed); -} - -void wxToolBar::Release() +bool wxToolBar::PerformAction(const wxControlAction& action, + long numArg, + const wxString& strArg) { - wxCHECK_RET( m_toolPressed, _T("no tool to release?") ); - - wxLogTrace(_T("toolbar"), - _T("Button '%s' released."), - m_toolCurrent->GetShortHelp().c_str()); - - wxASSERT_MSG( m_toolPressed->IsInverted(), _T("release unpressed button?") ); - - m_toolPressed->Invert(); + wxToolBarTool *tool = (wxToolBarTool*) FindById(numArg); + if (!tool) + return false; - RefreshTool(m_toolPressed); -} - -void wxToolBar::Toggle() -{ - m_toolCurrent = m_toolPressed; + if ( action == wxACTION_TOOLBAR_TOGGLE ) + { + PerformAction( wxACTION_BUTTON_RELEASE, numArg ); - Release(); + PerformAction( wxACTION_BUTTON_CLICK, numArg ); - Click(); -} + // 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(wxT("toolbar"), wxT("Button '%s' pressed."), tool->GetShortHelp().c_str()); -void wxToolBar::Click() -{ - wxCHECK_RET( m_toolCurrent, _T("no tool to click?") ); + tool->Invert(); - bool isToggled; - if ( m_toolCurrent->CanBeToggled() ) + RefreshTool( tool ); + } + else if ( action == wxACTION_TOOLBAR_RELEASE ) { - m_toolCurrent->Toggle(); + wxLogTrace(wxT("toolbar"), wxT("Button '%s' released."), tool->GetShortHelp().c_str()); + + wxASSERT_MSG( tool->IsInverted(), wxT("release unpressed button?") ); - RefreshTool(m_toolCurrent); + if(tool->IsInverted()) + { + tool->Invert(); + } - isToggled = m_toolCurrent->IsToggled(); + RefreshTool( tool ); } - else // simple non-checkable tool + else if ( action == wxACTION_TOOLBAR_CLICK ) { - isToggled = FALSE; - } + bool isToggled; + if ( tool->CanBeToggled() ) + { + if ( tool->IsButton() && tool->GetKind() == wxITEM_RADIO ) + { + UnToggleRadioGroup(tool); + tool->Toggle(true); + } + else + { + tool->Toggle(); + } - OnLeftClick(m_toolCurrent->GetId(), 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); + 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 ) { - 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); - return TRUE; + return true; +} + +/* static */ +wxInputHandler *wxToolBar::GetStdInputHandler(wxInputHandler *handlerDef) +{ + static wxStdToolbarInputHandler s_handler(handlerDef); + + return &s_handler; } // ============================================================================ @@ -633,8 +831,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, @@ -649,63 +850,135 @@ bool wxStdToolbarInputHandler::HandleKey(wxInputConsumer *consumer, bool wxStdToolbarInputHandler::HandleMouse(wxInputConsumer *consumer, const wxMouseEvent& event) { - // don't let the base class press the disabled buttons but simply ignore - // all events on them wxToolBar *tbar = wxStaticCast(consumer->GetInputWindow(), wxToolBar); wxToolBarToolBase *tool = tbar->FindToolForPosition(event.GetX(), event.GetY()); - if ( !tool || !tool->IsEnabled() ) - return TRUE; + 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 wxStdButtonInputHandler::HandleMouse(consumer, event); + 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 ( 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 - consumer->PerformAction(wxACTION_TOOLBAR_LEAVE); + { + 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 (tool) + { + // Enter new tool if any + consumer->PerformAction( wxACTION_TOOLBAR_ENTER, tool->GetId() ); + } + + m_toolLast = tool; + } + + return true; } - return FALSE; + return false; } 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) { - // 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 -