X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/5e885a580a735716af33b47b0743b5fa04a0cb9f..eea4d01c65f9b29baa1193db762b4c6b8144af24:/src/univ/toolbar.cpp diff --git a/src/univ/toolbar.cpp b/src/univ/toolbar.cpp index 83d4ad199a..da03781e9c 100644 --- a/src/univ/toolbar.cpp +++ b/src/univ/toolbar.cpp @@ -1,8 +1,12 @@ ///////////////////////////////////////////////////////////////////////////// // Name: src/univ/toolbar.cpp -// Author: Robert Roebling +// Purpose: implementation of wxToolBar for wxUniversal +// Author: Robert Roebling, Vadim Zeitlin (universalization) +// Modified by: +// Created: 20.02.02 // Id: $Id$ -// Copyright: (c) 2001 Robert Roebling +// Copyright: (c) 2001 Robert Roebling, +// (c) 2002 SciTech Software, Inc. (www.scitechsoft.com) // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// @@ -14,10 +18,6 @@ // headers // ---------------------------------------------------------------------------- -#ifdef __GNUG__ - #pragma implementation "univtoolbar.h" -#endif - // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" @@ -25,314 +25,960 @@ #pragma hdrstop #endif +#if wxUSE_TOOLBAR + +#include "wx/toolbar.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/toolbar.h" -#include "wx/validate.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; +}; -//----------------------------------------------------------------------------- -// wxToolBar -//----------------------------------------------------------------------------- +// ---------------------------------------------------------------------------- +// constants +// ---------------------------------------------------------------------------- + +// value meaning that m_widthSeparator is not initialized +static const wxCoord INVALID_WIDTH = wxDefaultCoord; -BEGIN_EVENT_TABLE(wxToolBar,wxToolBarBase) - EVT_MOUSE_EVENTS( wxToolBar::OnMouse ) - EVT_PAINT( wxToolBar::OnPaint ) - EVT_SIZE( wxToolBar::OnSize ) -END_EVENT_TABLE() +// ---------------------------------------------------------------------------- +// wxToolBarTool: our implementation of wxToolBarToolBase +// ---------------------------------------------------------------------------- -bool wxToolBar::Create( wxWindow *parent, wxWindowID id, - const wxPoint& pos, const wxSize& size, - long style, const wxString& name ) +class WXDLLEXPORT wxToolBarTool : public wxToolBarToolBase { - bool ret = wxToolBarBase::Create( parent, id, pos, size, style, wxDefaultValidator, name ); - - return ret; -} +public: + 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 = + 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: + // 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 +// ============================================================================ + +IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxControl) + +// ---------------------------------------------------------------------------- +// wxToolBar creation +// ---------------------------------------------------------------------------- void wxToolBar::Init() { - // TODO: this is from tbarbase.cpp, but should be in - // wxToolbarBase::Init - // the list owns the pointers - m_tools.DeleteContents(TRUE); - m_xMargin = m_yMargin = 0; - m_maxRows = m_maxCols = 0; - // End TODO + // no tools yet + m_needsLayout = false; + + // unknown widths for the tools and separators + m_widthSeparator = INVALID_WIDTH; - m_maxWidth = 0; + m_maxWidth = m_maxHeight = 0; - m_captured = NULL; - SetToolBitmapSize( wxSize(16,15) ); + wxRenderer *renderer = GetRenderer(); + + SetToolBitmapSize(renderer->GetToolBarButtonSize(&m_widthSeparator)); + SetMargins(renderer->GetToolBarMargin()); } +bool wxToolBar::Create(wxWindow *parent, + wxWindowID id, + const wxPoint& pos, + const wxSize& size, + long style, + const wxString& name) +{ + if ( !wxToolBarBase::Create(parent, id, pos, size, style, + wxDefaultValidator, name) ) + { + return false; + } + + FixupStyle(); + + CreateInputHandler(wxINP_HANDLER_TOOLBAR); + + SetInitialSize(size); + + 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 ); +} + +// ---------------------------------------------------------------------------- +// wxToolBar tool-related methods +// ---------------------------------------------------------------------------- + wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord x, wxCoord y) const { + // check the "other" direction first: it must be inside the toolbar or we + // don't risk finding anything + if ( IsVertical() ) + { + if ( x < 0 || x > m_maxWidth ) + return NULL; + + // we always use x, even for a vertical toolbar, this makes the code + // below simpler + x = y; + } + else // horizontal + { + if ( y < 0 || y > m_maxHeight ) + return NULL; + } + + for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst(); + node; + node = node->GetNext() ) + { + wxToolBarToolBase *tool = node->GetData(); + wxRect rectTool = GetToolRect(tool); + + wxCoord startTool, endTool; + GetRectLimits(rectTool, &startTool, &endTool); + + if ( x >= startTool && x <= endTool ) + { + // don't return the separators from here, they don't accept any + // input anyhow + return tool->IsSeparator() ? NULL : tool; + } + } + return NULL; } -void wxToolBar::SetToolShortHelp(int id, const wxString& helpString) +void wxToolBar::SetToolShortHelp(int id, const wxString& help) { + wxToolBarToolBase *tool = FindById(id); + + wxCHECK_RET( tool, wxT("SetToolShortHelp: no such tool") ); + + tool->SetShortHelp(help); } -bool wxToolBar::DoInsertTool(size_t pos, wxToolBarToolBase *tool) +bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), + wxToolBarToolBase * WXUNUSED(tool)) { - return TRUE; + // recalculate the toolbar geometry before redrawing it the next time + m_needsLayout = true; + + // and ensure that we indeed are going to redraw + Refresh(); + + return true; } -bool wxToolBar::DoDeleteTool(size_t pos, wxToolBarToolBase *tool) +bool wxToolBar::DoDeleteTool(size_t WXUNUSED(pos), + wxToolBarToolBase * WXUNUSED(tool)) { - return TRUE; + // as above + m_needsLayout = true; + + Refresh(); + + return true; } void wxToolBar::DoEnableTool(wxToolBarToolBase *tool, bool enable) { +#if wxUSE_IMAGE + // created disabled-state bitmap on demand + if ( !enable && !tool->GetDisabledBitmap().IsOk() ) + { + wxImage image(tool->GetNormalBitmap().ConvertToImage()); + + tool->SetDisabledBitmap(image.ConvertToGreyscale()); + } +#endif // wxUSE_IMAGE + + RefreshTool(tool); } -void wxToolBar::DoToggleTool(wxToolBarToolBase *tool, bool toggle) +void wxToolBar::DoToggleTool(wxToolBarToolBase *tool, bool WXUNUSED(toggle)) { - wxToolBarTool *my_tool = (wxToolBarTool*) tool; - - bool refresh = (my_tool->IsToggled() != toggle); - - my_tool->m_isDown = toggle; - - if (refresh) - RefreshTool( my_tool ); + // note that if we're called the tool did change state (the base class + // checks for it), so it's not necessary to check for this again here + RefreshTool(tool); } -void wxToolBar::DoSetToggle(wxToolBarToolBase *tool, bool toggle) +void wxToolBar::DoSetToggle(wxToolBarToolBase *tool, bool WXUNUSED(toggle)) { + RefreshTool(tool); } wxToolBarToolBase *wxToolBar::CreateTool(int id, - const wxBitmap& bitmap1, - const wxBitmap& bitmap2, - bool toggle, - wxObject *clientData, - const wxString& shortHelpString, - const wxString& longHelpString) -{ - return new wxToolBarTool( this, id, bitmap1, bitmap2, toggle, - clientData, shortHelpString, longHelpString); -} - -wxToolBarToolBase *wxToolBar::CreateTool(wxControl *control) + const wxString& label, + const wxBitmap& bmpNormal, + const wxBitmap& bmpDisabled, + wxItemKind kind, + wxObject *clientData, + const wxString& shortHelp, + const wxString& longHelp) { - wxFAIL_MSG( wxT("Toolbar doesn't support controls yet.") ); - - return NULL; + return new wxToolBarTool(this, id, label, bmpNormal, bmpDisabled, kind, + clientData, shortHelp, longHelp); } -void wxToolBar::RefreshTool( wxToolBarTool *tool ) +wxToolBarToolBase * +wxToolBar::CreateTool(wxControl *control, const wxString& label) { - wxRect rect( tool->m_x, tool->m_y, m_defaultWidth+6, m_defaultHeight+6 ); - Refresh( TRUE, &rect ); + return new wxToolBarTool(this, control, label); } -void wxToolBar::DrawToolBarTool( wxToolBarTool *tool, wxDC &dc, bool down ) +// ---------------------------------------------------------------------------- +// wxToolBar geometry +// ---------------------------------------------------------------------------- + +wxRect wxToolBar::GetToolRect(wxToolBarToolBase *toolBase) const { - if (down) + const wxToolBarTool *tool = (wxToolBarTool *)toolBase; + + wxRect rect; + + wxCHECK_MSG( tool, rect, wxT("GetToolRect: NULL tool") ); + + // ensure that we always have the valid tool position + if ( m_needsLayout ) { - dc.DrawBitmap( tool->GetBitmap1(), tool->m_x+4, tool->m_y+4, TRUE ); - - dc.SetPen( *wxGREY_PEN ); - dc.DrawLine( tool->m_x, tool->m_y, tool->m_x+m_defaultWidth+5, tool->m_y ); - dc.DrawLine( tool->m_x, tool->m_y, tool->m_x, tool->m_y+m_defaultHeight+5 ); - - dc.SetPen( *wxBLACK_PEN ); - dc.DrawLine( tool->m_x+1, tool->m_y+1, tool->m_x+m_defaultWidth+4, tool->m_y+1 ); - dc.DrawLine( tool->m_x+1, tool->m_y+1, tool->m_x+1, tool->m_y+m_defaultHeight+4 ); - - dc.SetPen( *wxWHITE_PEN ); - dc.DrawLine( tool->m_x, tool->m_y+m_defaultHeight+5, tool->m_x+m_defaultWidth+6, tool->m_y+m_defaultHeight+5 ); - dc.DrawLine( tool->m_x+m_defaultWidth+5, tool->m_y, tool->m_x+m_defaultWidth+5, tool->m_y+m_defaultHeight+6 ); + wxConstCast(this, wxToolBar)->DoLayout(); } - else + + rect.x = tool->m_x - m_xMargin; + rect.y = tool->m_y - m_yMargin; + + if ( IsVertical() ) { - dc.DrawBitmap( tool->GetBitmap1(), tool->m_x+3, tool->m_y+3, TRUE ); - - dc.SetPen( *wxWHITE_PEN ); - dc.DrawLine( tool->m_x, tool->m_y, tool->m_x+m_defaultWidth+5, tool->m_y ); - dc.DrawLine( tool->m_x, tool->m_y, tool->m_x, tool->m_y+m_defaultHeight+5 ); - dc.DrawLine( tool->m_x+m_defaultWidth+4, tool->m_y, tool->m_x+m_defaultWidth+4, tool->m_y+2 ); - dc.DrawLine( tool->m_x, tool->m_y+m_defaultHeight+4, tool->m_x+2, tool->m_y+m_defaultHeight+4 ); - - dc.SetPen( *wxBLACK_PEN ); - dc.DrawLine( tool->m_x, tool->m_y+m_defaultHeight+5, tool->m_x+m_defaultWidth+6, tool->m_y+m_defaultHeight+5 ); - dc.DrawLine( tool->m_x+m_defaultWidth+5, tool->m_y, tool->m_x+m_defaultWidth+5, tool->m_y+m_defaultHeight+6 ); - - dc.SetPen( *wxGREY_PEN ); - dc.DrawLine( tool->m_x+1, tool->m_y+m_defaultHeight+4, tool->m_x+m_defaultWidth+5, tool->m_y+m_defaultHeight+4 ); - dc.DrawLine( tool->m_x+m_defaultWidth+4, tool->m_y+1, tool->m_x+m_defaultWidth+4, tool->m_y+m_defaultHeight+5 ); + 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 + { + 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.height += 2*m_yMargin; + + return rect; } -void wxToolBar::OnPaint(wxPaintEvent &event) +bool wxToolBar::Realize() { - wxPaintDC dc(this); - - wxSize clientSize = GetClientSize(); - dc.SetPen( *wxBLACK_PEN ); - dc.DrawLine( 0,0, clientSize.x,0 ); - - for ( wxToolBarToolsList::Node *node = m_tools.GetFirst(); + if ( !wxToolBarBase::Realize() ) + return false; + + m_needsLayout = true; + DoLayout(); + + // 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->Data(); - - if (tool->GetId() == -1) continue; - - DrawToolBarTool( tool, dc, tool->m_isDown ); + 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; } -bool wxToolBar::Realize() +void wxToolBar::SetWindowStyleFlag( long style ) { - if (!wxToolBarBase::Realize()) - return FALSE; + wxToolBarBase::SetWindowStyleFlag(style); - int x; - int y; + m_needsLayout = true; - if (GetWindowStyleFlag() & wxTB_VERTICAL) + Refresh(); +} + +void wxToolBar::DoLayout() +{ + wxASSERT_MSG( m_needsLayout, wxT("why are we called?") ); + + m_needsLayout = false; + + wxCoord x = m_xMargin, + y = m_yMargin; + + 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(); + node; + node = node->GetNext() ) { - x = m_xMargin; - y = 5; + wxToolBarTool *tool = (wxToolBarTool *) node->GetData(); + + tool->m_x = x; + tool->m_y = y; + + // 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, yMin; + + if(!HasFlag(wxTB_TEXT)) + { + xMin = m_defaultWidth + 2*m_xMargin; + yMin = m_defaultHeight + 2*m_yMargin; } else { - y = m_yMargin; - x = 5; + if (IsVertical()) + { + xMin = heightTool + 2*m_xMargin; + yMin = widthTool + 2*m_xMargin; + } + else + { + xMin = maxWidthTool + 2*m_xMargin; + yMin = heightTool + 2*m_xMargin; + } } - for ( wxToolBarToolsList::Node *node = m_tools.GetFirst(); + m_maxWidth = x < xMin ? xMin : x; + m_maxHeight = y < yMin ? yMin : y; +} + +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 +// ---------------------------------------------------------------------------- + +void wxToolBar::RefreshTool(wxToolBarToolBase *tool) +{ + RefreshRect(GetToolRect(tool)); +} + +void wxToolBar::GetRectLimits(const wxRect& rect, + wxCoord *start, + wxCoord *end) const +{ + wxCHECK_RET( start && end, wxT("NULL pointer in GetRectLimits") ); + + if ( IsVertical() ) + { + *start = rect.GetTop(); + *end = rect.GetBottom(); + } + else // horizontal + { + *start = rect.GetLeft(); + *end = rect.GetRight(); + } +} + +void wxToolBar::DoDraw(wxControlRenderer *renderer) +{ + // prepare the variables used below + wxDC& dc = renderer->GetDC(); + wxRenderer *rend = renderer->GetRenderer(); + dc.SetFont(GetFont()); + + // draw the border separating us from the menubar (if there is no menubar + // we probably shouldn't draw it?) + if ( !IsVertical() ) + { + rend->DrawHorizontalLine(dc, 0, 0, GetClientSize().x); + } + + // get the update rect and its limits depending on the orientation + wxRect rectUpdate = GetUpdateClientRect(); + wxCoord start, end; + GetRectLimits(rectUpdate, &start, &end); + + // and redraw all the tools intersecting it + for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst(); node; node = node->GetNext() ) { - wxToolBarTool *tool = (wxToolBarTool*) node->Data(); - - if (GetWindowStyleFlag() & wxTB_VERTICAL) + wxToolBarTool *tool = (wxToolBarTool*) node->GetData(); + wxRect rectTool = GetToolRect(tool); + wxCoord startTool, endTool; + GetRectLimits(rectTool, &startTool, &endTool); + + if ( endTool < start ) + { + // we're still to the left of the area to redraw + continue; + } + + if ( startTool > end ) + { + // we're beyond the area to redraw, nothing left to do + break; + } + + if (tool->IsSeparator() && !HasFlag(wxTB_FLAT)) + { + // Draw separators only in flat mode + continue; + } + + // deal with the flags + int flags = 0; + + if ( tool->IsEnabled() ) { - if (tool->GetId() == -1) + // 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_DISABLED; + } + + //if ( tool == m_toolCaptured ) + // flags |= wxCONTROL_FOCUSED; + + if ( tool->IsPressed() ) + flags = wxCONTROL_PRESSED; + + wxString label; + wxBitmap bitmap; + if ( !tool->IsSeparator() ) + { + label = tool->GetLabel(); + bitmap = tool->GetBitmap(); + + if ( !bitmap.IsOk() ) { - y += 6; + // 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; } - tool->m_x = m_xMargin; - tool->m_y = y; - y += m_defaultHeight + 6; + } + //else: leave both the label and the bitmap invalid to draw a separator + + if ( !tool->IsControl() ) + { + int tbStyle = HasFlag(wxTB_VERTICAL) ? wxTB_VERTICAL : wxTB_HORIZONTAL; + if ( HasFlag(wxTB_TEXT) ) + tbStyle |= wxTB_TEXT; - // Calculate the maximum height or width (depending on style) - // so we know how to size the toolbar in Realize. - // We could get the size of the tool instead of the - // default bitmap size - if (m_maxWidth < (m_defaultWidth + 2*(m_xMargin + 2))) - m_maxWidth = (m_defaultWidth + 2*(m_xMargin + 2)) ; + rend->DrawToolBarButton(dc, label, bitmap, rectTool, flags, + tool->GetStyle(), tbStyle); } - else + else // control { - if (tool->GetId() == -1) + wxControl *control = tool->GetControl(); + control->Move(tool->m_x, tool->m_y); + } + } +} + +// ---------------------------------------------------------------------------- +// wxToolBar actions +// ---------------------------------------------------------------------------- + +bool wxToolBar::PerformAction(const wxControlAction& action, + long 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 ); + + // 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()); + + tool->Invert(); + + RefreshTool( tool ); + } + else if ( action == wxACTION_TOOLBAR_RELEASE ) + { + wxLogTrace(wxT("toolbar"), wxT("Button '%s' released."), tool->GetShortHelp().c_str()); + + wxASSERT_MSG( tool->IsInverted(), wxT("release unpressed button?") ); + + if(tool->IsInverted()) + { + tool->Invert(); + } + + RefreshTool( tool ); + } + else if ( action == wxACTION_TOOLBAR_CLICK ) + { + bool isToggled; + if ( tool->CanBeToggled() ) + { + if ( tool->IsButton() && tool->GetKind() == wxITEM_RADIO ) { - x += 6; - continue; + UnToggleRadioGroup(tool); + tool->Toggle(true); } - tool->m_x = x; - tool->m_y = m_yMargin; - x += m_defaultWidth + 6; - - // Calculate the maximum height or width (depending on style) - // so we know how to size the toolbar in Realize. - // We could get the size of the tool instead of the - // default bitmap size - if (m_maxHeight < (m_defaultHeight + 2*(m_yMargin + 2))) - m_maxHeight = (m_defaultHeight + 2*(m_yMargin + 2)) ; - } - - } + else + { + tool->Toggle(); + } + + RefreshTool( tool ); - wxSize sz = GetSize(); - if (GetWindowStyleFlag() & wxTB_VERTICAL) + isToggled = tool->IsToggled(); + } + else // simple non-checkable tool + { + isToggled = false; + } + OnLeftClick( tool->GetId(), isToggled ); + } + else if ( action == wxACTION_TOOLBAR_ENTER ) { - SetSize(m_maxWidth, sz.y); + wxCHECK_MSG( tool, false, wxT("no tool to enter?") ); + + if ( HasFlag(wxTB_FLAT) && tool->IsEnabled() ) + { + tool->SetUnderMouse( true ); + + if ( !tool->IsToggled() ) + RefreshTool( tool ); + } } - else + else if ( action == wxACTION_TOOLBAR_LEAVE ) { - SetSize(sz.x, m_maxHeight); + wxCHECK_MSG( tool, false, wxT("no tool to leave?") ); + + if ( HasFlag(wxTB_FLAT) && tool->IsEnabled() ) + { + tool->SetUnderMouse( false ); + + if ( !tool->IsToggled() ) + RefreshTool( tool ); + } } + else + return wxControl::PerformAction(action, numArg, strArg); - // Commenting out Robert's fix since the above should be - // more general - // SetSize( x+16, m_defaultHeight + 14 ); - - return TRUE; + return true; } -void wxToolBar::OnMouse(wxMouseEvent &event) +/* static */ +wxInputHandler *wxToolBar::GetStdInputHandler(wxInputHandler *handlerDef) { - wxToolBarTool *hit = NULL; - int x = event.GetX(); - int y = event.GetY(); - - for ( wxToolBarToolsList::Node *node = m_tools.GetFirst(); - node; - node = node->GetNext() ) + static wxStdToolbarInputHandler s_handler(handlerDef); + + return &s_handler; +} + +// ============================================================================ +// wxStdToolbarInputHandler implementation +// ============================================================================ + +wxStdToolbarInputHandler::wxStdToolbarInputHandler(wxInputHandler *handler) + : wxStdInputHandler(handler) +{ + m_winCapture = NULL; + m_toolCapture = NULL; + m_toolLast = NULL; +} + +bool wxStdToolbarInputHandler::HandleKey(wxInputConsumer *consumer, + const wxKeyEvent& event, + bool pressed) +{ + // TODO: when we have a current button we should allow the arrow + // keys to move it + 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) ) { - wxToolBarTool *tool = (wxToolBarTool*) node->Data(); - - if ((x > tool->m_x) && (x < tool->m_x+m_defaultWidth+5) && - (y > tool->m_y) && (y < tool->m_y+m_defaultHeight+5)) + + if ( event.LeftDown() || event.LeftDClick() ) { - hit = tool; - break; + 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 } - - if (event.LeftDown() && (hit)) - { - CaptureMouse(); - m_captured = hit; - - m_captured->m_isDown = TRUE; - RefreshTool( m_captured ); - - return; - } - - if (event.Dragging() && (m_captured)) + + return wxStdInputHandler::HandleMouse(consumer, event); +} + +bool wxStdToolbarInputHandler::HandleMouseMove(wxInputConsumer *consumer, + const wxMouseEvent& event) +{ + if ( !wxStdInputHandler::HandleMouseMove(consumer, event) ) { - bool is_down = (hit == m_captured); - if (is_down != m_captured->m_isDown) + 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 { - m_captured->m_isDown = is_down; - RefreshTool( m_captured ); + tool = (wxToolBarTool*) tbar->FindToolForPosition( event.GetX(), event.GetY() ); } - - return; + + 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 + { + 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; } - - if (event.LeftUp() && (m_captured)) + + return false; +} + +bool wxStdToolbarInputHandler::HandleFocus(wxInputConsumer *consumer, + const wxFocusEvent& WXUNUSED(event)) +{ + if ( m_toolCapture ) + { + // We shouldn't be left with a highlighted button + consumer->PerformAction( wxACTION_TOOLBAR_LEAVE, m_toolCapture->GetId() ); + } + + return true; +} + +bool wxStdToolbarInputHandler::HandleActivation(wxInputConsumer *consumer, + bool activated) +{ + if (m_toolCapture && !activated) { - ReleaseMouse(); - - m_captured->m_isDown = FALSE; - RefreshTool( m_captured ); - - if (hit == m_captured) - { - wxCommandEvent cevent( wxEVT_COMMAND_TOOL_CLICKED, m_captured->GetId() ); - cevent.SetEventObject( this ); - // cevent.SetExtraLong((long) toggleDown); - GetEventHandler()->ProcessEvent( cevent ); - } - - m_captured = NULL; - - return; + // We shouldn't be left with a highlighted button + consumer->PerformAction( wxACTION_TOOLBAR_LEAVE, m_toolCapture->GetId() ); } + + return true; } +#endif // wxUSE_TOOLBAR