// headers
// ----------------------------------------------------------------------------
-#ifdef __GNUG__
- #pragma implementation "univtoolbar.h"
-#endif
-
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#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
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
// 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
void wxToolBar::Init()
{
// no tools yet
- m_needsLayout = FALSE;
+ m_needsLayout = false;
// unknown widths for the tools and separators
m_widthSeparator = INVALID_WIDTH;
m_maxWidth =
m_maxHeight = 0;
- m_toolPressed = NULL;
- m_toolCurrent = NULL;
-
wxRenderer *renderer = GetRenderer();
SetToolBitmapSize(renderer->GetToolBarButtonSize(&m_widthSeparator));
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 );
}
// ----------------------------------------------------------------------------
return NULL;
}
- for ( wxToolBarToolsList::Node *node = m_tools.GetFirst();
+ for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
node;
node = node->GetNext() )
{
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);
}
}
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);
}
// ----------------------------------------------------------------------------
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;
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?") );
- 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() )
{
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;
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
// ----------------------------------------------------------------------------
// 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?)
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);
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
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;
{
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);
+ }
}
}
// 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(_T("toolbar"), _T("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(_T("toolbar"), _T("Button '%s' released."), tool->GetShortHelp().c_str());
+
+ wxASSERT_MSG( tool->IsInverted(), _T("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, _T("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, _T("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;
}
// ============================================================================
// ============================================================================
wxStdToolbarInputHandler::wxStdToolbarInputHandler(wxInputHandler *handler)
- : wxStdButtonInputHandler(handler)
+ : wxStdInputHandler(handler)
{
+ m_winCapture = NULL;
+ m_toolCapture = NULL;
+ m_toolLast = NULL;
}
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
-
projects / wxWidgets.git / blobdiff