// headers
// ----------------------------------------------------------------------------
-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
#pragma implementation "univtoolbar.h"
#endif
#include "wx/univ/renderer.h"
+#include "wx/frame.h"
#include "wx/toolbar.h"
#include "wx/image.h"
+#include "wx/log.h"
// ----------------------------------------------------------------------------
// 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
{
// 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;
+ m_underMouse = false;
+ }
+
+ wxToolBarTool(wxToolBar *tbar, wxControl *control)
+ : wxToolBarToolBase(tbar, control)
+ {
+ // 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; }
+ 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
+
+ // true if the tool is under the mouse
bool m_underMouse;
};
void wxToolBar::Init()
{
// no tools yet
- m_needsLayout = FALSE;
+ m_needsLayout = false;
// unknown widths for the tools and separators
m_widthSeparator = INVALID_WIDTH;
if ( !wxToolBarBase::Create(parent, id, pos, size, style,
wxDefaultValidator, name) )
{
- return FALSE;
+ return false;
}
CreateInputHandler(wxINP_HANDLER_TOOLBAR);
SetBestSize(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 + 2, y + 2 );
+ 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)
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;
+ red = (unsigned char)((((wxInt32) red - bg_red) >> 1) + bg_red);
+ green = (unsigned char)((((wxInt32) green - bg_green) >> 1) + bg_green);
+ blue = (unsigned char)((((wxInt32) blue - bg_blue) >> 1) + bg_blue);
image.SetRGB( x, y, red, green, blue );
}
}
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;
+ red = (unsigned char)((((wxInt32) red - bg_red) >> 1) + bg_red);
+ green = (unsigned char)((((wxInt32) green - bg_green) >> 1) + bg_green);
+ blue = (unsigned char)((((wxInt32) blue - bg_blue) >> 1) + bg_blue);
image.SetRGB( x, y, red, green, blue );
}
}
wxToolBarToolBase *wxToolBar::CreateTool(wxControl *control)
{
- wxFAIL_MSG( wxT("Toolbar doesn't support controls yet (TODO)") );
-
- return NULL;
+ return new wxToolBarTool(this, control);
}
// ----------------------------------------------------------------------------
if ( IsVertical() )
{
- rect.width = m_defaultWidth;
- rect.height = tool->IsSeparator() ? m_widthSeparator : m_defaultHeight;
+ if (tool->IsButton())
+ {
+ rect.width = m_defaultWidth;
+ 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())
+ {
+ rect.width = m_defaultWidth;
+ 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);
- return TRUE;
+ return true;
}
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 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())
+ {
+ *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
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 )
+ {
+ // But before we send the size event check it
+ // we have a frame that is not being deleted.
+ wxFrame *frame = wxDynamicCast(GetParent(), wxFrame);
+ if ( frame && !frame->IsBeingDeleted() )
+ {
+ frame->SendSizeEvent();
+ }
+ }
+}
+
// ----------------------------------------------------------------------------
// wxToolBar drawing
// ----------------------------------------------------------------------------
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() )
{
// we're beyond the area to redraw, nothing left to do
break;
}
-
+
+ if (tool->IsSeparator() && !HasFlag(wxTB_FLAT))
+ {
+ // Draw seperators only in flat mode
+ continue;
+ }
+
// deal with the flags
int flags = 0;
}
//else: leave both the label and the bitmap invalid to draw a separator
- rend->DrawToolBarButton(dc, label, bitmap, rectTool, flags);
+ if ( !tool->IsControl() )
+ {
+ rend->DrawToolBarButton(dc, label, bitmap, rectTool, flags, tool->GetStyle());
+ }
+ else // control
+ {
+ wxControl *control = tool->GetControl();
+ control->Move(tool->m_x, tool->m_y);
+ }
}
}
const wxString& strArg)
{
wxToolBarTool *tool = (wxToolBarTool*) FindById(numArg);
-
+ if (!tool)
+ return false;
+
if ( action == wxACTION_TOOLBAR_TOGGLE )
{
PerformAction( wxACTION_BUTTON_RELEASE, numArg );
else if ( action == wxACTION_TOOLBAR_PRESS )
{
wxLogTrace(_T("toolbar"), _T("Button '%s' pressed."), tool->GetShortHelp().c_str());
-
+
tool->Invert();
RefreshTool( tool );
wxLogTrace(_T("toolbar"), _T("Button '%s' released."), tool->GetShortHelp().c_str());
wxASSERT_MSG( tool->IsInverted(), _T("release unpressed button?") );
-
+
tool->Invert();
RefreshTool( tool );
}
else // simple non-checkable tool
{
- isToggled = FALSE;
+ isToggled = false;
}
OnLeftClick( tool->GetId(), isToggled );
}
else if ( action == wxACTION_TOOLBAR_ENTER )
{
- wxCHECK_MSG( tool, FALSE, _T("no tool to enter?") );
-
+ wxCHECK_MSG( tool, false, _T("no tool to enter?") );
+
if ( HasFlag(wxTB_FLAT) && tool->IsEnabled() )
{
- tool->SetUnderMouse( TRUE );
-
+ tool->SetUnderMouse( true );
+
if ( !tool->IsToggled() )
RefreshTool( tool );
}
}
else if ( action == wxACTION_TOOLBAR_LEAVE )
{
- wxCHECK_MSG( tool, FALSE, _T("no tool to leave?") );
-
+ wxCHECK_MSG( tool, false, _T("no tool to leave?") );
+
if ( HasFlag(wxTB_FLAT) && tool->IsEnabled() )
{
- tool->SetUnderMouse( FALSE );
-
+ tool->SetUnderMouse( false );
+
if ( !tool->IsToggled() )
RefreshTool( tool );
}
else
return wxControl::PerformAction(action, numArg, strArg);
- return TRUE;
+ return true;
}
// ============================================================================
if ( event.Button(1) )
{
- if ( !tool || !tool->IsEnabled() )
- return TRUE;
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;
+ return true;
}
else if ( event.LeftUp() )
{
m_winCapture = NULL;
}
- if ( tool == m_toolCapture )
+ if (m_toolCapture)
{
- // this will generate a click event
- consumer->PerformAction( wxACTION_BUTTON_TOGGLE, tool->GetId() );
-
- m_toolCapture = NULL;
-
- return TRUE;
+ if ( tool == m_toolCapture )
+ consumer->PerformAction( wxACTION_BUTTON_TOGGLE, m_toolCapture->GetId() );
+ else
+ consumer->PerformAction( wxACTION_TOOLBAR_LEAVE, m_toolCapture->GetId() );
}
- //else: the mouse was released outside the tool or in
- // a different tool
-
+
m_toolCapture = NULL;
-
+
+ return true;
}
//else: don't do anything special about the double click
}
if ( !wxStdInputHandler::HandleMouseMove(consumer, event) )
{
wxToolBar *tbar = wxStaticCast(consumer->GetInputWindow(), wxToolBar);
-
+
wxToolBarTool *tool;
if ( event.Leaving() )
{
{
tool = (wxToolBarTool*) tbar->FindToolForPosition( event.GetX(), event.GetY() );
}
-
- if ((tool) && (tool == m_toolLast))
- {
- // Still over the same tool as last time
- return TRUE;
- }
-
- if (m_toolLast)
+
+ if (m_toolCapture)
{
- // Leave old tool if any
- consumer->PerformAction( wxACTION_TOOLBAR_LEAVE, m_toolLast->GetId() );
+ // During capture we only care of the captured tool
+ if (tool && (tool != m_toolCapture))
+ tool = NULL;
+
+ if (tool == m_toolLast)
+ return true;
+
+ if (tool)
+ consumer->PerformAction( wxACTION_BUTTON_PRESS, m_toolCapture->GetId() );
+ else
+ consumer->PerformAction( wxACTION_BUTTON_RELEASE, m_toolCapture->GetId() );
+
+ m_toolLast = tool;
}
-
- if (m_toolCapture && (m_toolCapture != tool))
- m_toolLast = NULL;
else
- m_toolLast = tool;
-
- if (m_toolLast)
{
- // Enter new tool if any
- consumer->PerformAction( wxACTION_TOOLBAR_ENTER, m_toolLast->GetId() );
+ 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;
+
+ return true;
}
- return FALSE;
+ return false;
}
bool wxStdToolbarInputHandler::HandleFocus(wxInputConsumer *consumer,
- const wxFocusEvent& event)
+ const wxFocusEvent& WXUNUSED(event))
{
- if (m_toolCapture)
+ 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,
consumer->PerformAction( wxACTION_TOOLBAR_LEAVE, m_toolCapture->GetId() );
}
- return TRUE;
+ return true;
}
#endif // wxUSE_TOOLBAR
projects / wxWidgets.git / blobdiff