/////////////////////////////////////////////////////////////////////////////
// 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
/////////////////////////////////////////////////////////////////////////////
// headers
// ----------------------------------------------------------------------------
-#ifdef __GNUG__
- #pragma implementation "univtoolbar.h"
-#endif
-
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#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
projects / wxWidgets.git / blobdiff