/////////////////////////////////////////////////////////////////////////////
-// Name: tbarbase.cpp
-// Purpose: Toolbar base classes
+// Name: common/tbarbase.cpp
+// Purpose: wxToolBarBase implementation
// Author: Julian Smart
-// Modified by:
+// Modified by: VZ at 11.12.99 (wxScrollableToolBar splitted off)
// Created: 04/01/98
// RCS-ID: $Id$
-// Copyright: (c) Julian Smart and Markus Holzem
-// Licence: wxWindows license
+// Copyright: (c) Julian Smart
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-#ifdef __GNUG__
-#pragma implementation "tbarbase.h"
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
+ #pragma implementation "tbarbase.h"
#endif
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
-#pragma hdrstop
+ #pragma hdrstop
#endif
-#ifndef WX_PRECOMP
-#include "wx/wx.h"
-#endif
+#if wxUSE_TOOLBAR
-// For ::UpdateWindow
-#ifdef __WXMSW__
-#include <windows.h>
+#ifndef WX_PRECOMP
+ #include "wx/control.h"
#endif
-#if USE_TOOLBAR
+#include "wx/frame.h"
+#include "wx/image.h"
+#include "wx/settings.h"
-#include "wx/tbarbase.h"
+#include "wx/toolbar.h"
-#if !USE_SHARED_LIBRARY
-IMPLEMENT_DYNAMIC_CLASS(wxToolBarBase, wxControl)
-IMPLEMENT_DYNAMIC_CLASS(wxToolBarTool, wxObject)
+// ----------------------------------------------------------------------------
+// wxWidgets macros
+// ----------------------------------------------------------------------------
BEGIN_EVENT_TABLE(wxToolBarBase, wxControl)
- EVT_SCROLL(wxToolBarBase::OnScroll)
- EVT_SIZE(wxToolBarBase::OnSize)
- EVT_IDLE(wxToolBarBase::OnIdle)
END_EVENT_TABLE()
-#endif
-
-// Keep a list of all toolbars created, so you can tell whether a toolbar
-// is still valid: a tool may have quit the toolbar.
-static wxList gs_ToolBars;
-
-wxToolBarTool::wxToolBarTool(int theIndex,
- const wxBitmap& theBitmap1, const wxBitmap& theBitmap2, bool toggle,
- long xPos, long yPos, const wxString& helpS1, const wxString& helpS2)
-{
- m_toolStyle = wxTOOL_STYLE_BUTTON;
- m_clientData = NULL;
- m_index = theIndex;
- m_isToggle = toggle;
- m_toggleState = FALSE;
- m_enabled = TRUE;
- m_bitmap1 = theBitmap1;
- m_bitmap2 = theBitmap2;
- m_x = xPos;
- m_y = yPos;
- m_width = m_height = 0;
- m_deleteSecondBitmap = FALSE;
- if (m_bitmap1.Ok())
- {
- m_width = m_bitmap1.GetWidth()+2;
- m_height = m_bitmap1.GetHeight()+2;
- }
- m_shortHelpString = helpS1;
- m_longHelpString = helpS2;
-}
-
-wxToolBarTool::~wxToolBarTool(void)
-{
-/*
- if (m_deleteSecondBitmap && m_bitmap2)
- delete m_bitmap2;
-*/
-}
+#include "wx/listimpl.cpp"
-// class wxToolBar
+WX_DEFINE_LIST(wxToolBarToolsList);
-wxToolBarBase::wxToolBarBase(void) : m_tools(wxKEY_INTEGER)
-{
- gs_ToolBars.Append(this);
+// ============================================================================
+// implementation
+// ============================================================================
- m_tilingDirection = wxVERTICAL;
- m_rowsOrColumns = 0;
- m_maxWidth = 0;
- m_maxHeight = 0;
- m_defaultWidth = 16;
- m_defaultHeight = 15;
- m_xMargin = 0;
- m_yMargin = 0;
- m_toolPacking = 1;
- m_toolSeparation = 5;
- m_currentTool = -1;
+// ----------------------------------------------------------------------------
+// wxToolBarToolBase
+// ----------------------------------------------------------------------------
- m_xScrollPixelsPerLine = 0;
- m_yScrollPixelsPerLine = 0;
- m_xScrollingEnabled = TRUE;
- m_yScrollingEnabled = TRUE;
- m_xScrollPosition = 0;
- m_yScrollPosition = 0;
- m_calcScrolledOffset = TRUE;
- m_xScrollLines = 0;
- m_yScrollLines = 0;
- m_xScrollLinesPerPage = 0;
- m_yScrollLinesPerPage = 0;
-}
+IMPLEMENT_DYNAMIC_CLASS(wxToolBarToolBase, wxObject)
-wxToolBarBase::~wxToolBarBase ()
+bool wxToolBarToolBase::Enable(bool enable)
{
- gs_ToolBars.DeleteObject(this);
+ if ( m_enabled == enable )
+ return false;
+
+ m_enabled = enable;
- for ( wxNode *node = m_tools.First(); node; node = node->Next() )
- {
- wxToolBarTool *tool = (wxToolBarTool *)node->Data();
- delete tool;
- }
+ return true;
}
-// Only allow toggle if returns TRUE
-bool wxToolBarBase::OnLeftClick(int toolIndex, bool toggleDown)
+bool wxToolBarToolBase::Toggle(bool toggle)
{
- wxCommandEvent event(wxEVT_COMMAND_TOOL_CLICKED, toolIndex);
- event.SetEventObject(this);
- event.SetExtraLong((long) toggleDown);
+ wxASSERT_MSG( CanBeToggled(), _T("can't toggle this tool") );
- GetEventHandler()->ProcessEvent(event);
+ if ( m_toggled == toggle )
+ return false;
- return TRUE;
+ m_toggled = toggle;
+
+ return true;
}
-// Call when right button down.
-void wxToolBarBase::OnRightClick(int toolIndex, long x, long y)
+bool wxToolBarToolBase::SetToggle(bool toggle)
{
- wxCommandEvent event(wxEVT_COMMAND_TOOL_RCLICKED, toolIndex);
- event.SetEventObject(this);
- event.SetInt(toolIndex);
+ wxItemKind kind = toggle ? wxITEM_CHECK : wxITEM_NORMAL;
+ if ( m_kind == kind )
+ return false;
- GetEventHandler()->ProcessEvent(event);
+ m_kind = kind;
+
+ return true;
}
-// Called when the mouse cursor enters a tool bitmap (no button pressed).
-// Argument is -1 if mouse is exiting the toolbar.
-void wxToolBarBase::OnMouseEnter ( int toolIndex )
+bool wxToolBarToolBase::SetShortHelp(const wxString& help)
{
- wxCommandEvent event(wxEVT_COMMAND_TOOL_ENTER, toolIndex);
- event.SetEventObject(this);
- event.SetInt(toolIndex);
+ if ( m_shortHelpString == help )
+ return false;
- GetEventHandler()->ProcessEvent(event);
+ m_shortHelpString = help;
+
+ return true;
}
-// If pushedBitmap is NULL, a reversed version of bitmap is
-// created and used as the pushed/toggled image.
-// If toggle is TRUE, the button toggles between the two states.
-wxToolBarTool *wxToolBarBase::AddTool(int index, const wxBitmap& bitmap, const wxBitmap& pushedBitmap,
- bool toggle, long xPos, long yPos, wxObject *clientData,
- const wxString& helpString1, const wxString& helpString2)
+bool wxToolBarToolBase::SetLongHelp(const wxString& help)
{
- wxToolBarTool *tool = new wxToolBarTool(index, bitmap, pushedBitmap, toggle, xPos, yPos, helpString1, helpString2);
- tool->m_clientData = clientData;
+ if ( m_longHelpString == help )
+ return false;
- if (xPos > -1)
- tool->m_x = xPos;
- else
- tool->m_x = m_xMargin;
+ m_longHelpString = help;
- if (yPos > -1)
- tool->m_y = yPos;
- else
- tool->m_y = m_yMargin;
-
- // Calculate reasonable max size in case Layout() not called
- if ((tool->m_x + bitmap.GetWidth() + m_xMargin) > m_maxWidth)
- m_maxWidth = (tool->m_x + bitmap.GetWidth() + m_xMargin);
+ return true;
+}
- if ((tool->m_y + bitmap.GetHeight() + m_yMargin) > m_maxHeight)
- m_maxHeight = (tool->m_y + bitmap.GetHeight() + m_yMargin);
+#if WXWIN_COMPATIBILITY_2_2
- m_tools.Append((long)index, tool);
- return tool;
+const wxBitmap& wxToolBarToolBase::GetBitmap1() const
+{
+ return GetNormalBitmap();
}
-void wxToolBarBase::AddSeparator ()
+const wxBitmap& wxToolBarToolBase::GetBitmap2() const
{
- wxToolBarTool *tool = new wxToolBarTool;
- tool->m_toolStyle = wxTOOL_STYLE_SEPARATOR;
- m_tools.Append(tool);
+ return GetDisabledBitmap();
}
-void wxToolBarBase::ClearTools(void)
+void wxToolBarToolBase::SetBitmap1(const wxBitmap& bmp)
{
- m_pressedTool = m_currentTool = -1;
- wxNode *node = m_tools.First();
- while (node)
- {
- wxToolBarTool *tool = (wxToolBarTool *)node->Data();
- wxNode *nextNode = node->Next();
- delete tool;
- delete node;
- node = nextNode;
- }
+ SetNormalBitmap(bmp);
}
-void wxToolBarBase::EnableTool(int index, bool enable)
+void wxToolBarToolBase::SetBitmap2(const wxBitmap& bmp)
{
- wxNode *node = m_tools.Find((long)index);
- if (node)
- {
- wxToolBarTool *tool = (wxToolBarTool *)node->Data();
- if (tool)
- tool->m_enabled = enable;
- }
+ SetDisabledBitmap(bmp);
}
-void wxToolBarBase::ToggleTool(int index, bool toggle)
+#endif // WXWIN_COMPATIBILITY_2_2
+
+// ----------------------------------------------------------------------------
+// wxToolBarBase adding/deleting items
+// ----------------------------------------------------------------------------
+
+wxToolBarBase::wxToolBarBase()
{
+ // the list owns the pointers
+ m_xMargin = m_yMargin = 0;
+
+ m_maxRows = m_maxCols = 0;
}
-void wxToolBarBase::SetToggle(int index, bool value)
+wxToolBarToolBase *wxToolBarBase::DoAddTool(int id,
+ const wxString& label,
+ const wxBitmap& bitmap,
+ const wxBitmap& bmpDisabled,
+ wxItemKind kind,
+ const wxString& shortHelp,
+ const wxString& longHelp,
+ wxObject *clientData,
+ wxCoord WXUNUSED(xPos),
+ wxCoord WXUNUSED(yPos))
{
- wxNode *node=m_tools.Find((long)index);
- if (node){
- wxToolBarTool *tool = (wxToolBarTool *)node->Data();
- tool->m_isToggle = value;
- }
+ InvalidateBestSize();
+ return InsertTool(GetToolsCount(), id, label, bitmap, bmpDisabled,
+ kind, shortHelp, longHelp, clientData);
}
-bool wxToolBarBase::GetToolState(int index) const
+wxToolBarToolBase *wxToolBarBase::InsertTool(size_t pos,
+ int id,
+ const wxString& label,
+ const wxBitmap& bitmap,
+ const wxBitmap& bmpDisabled,
+ wxItemKind kind,
+ const wxString& shortHelp,
+ const wxString& longHelp,
+ wxObject *clientData)
{
- wxNode *node = m_tools.Find((long)index);
- if (node)
- {
- wxToolBarTool *tool = (wxToolBarTool *)node->Data();
- if (tool)
+ wxCHECK_MSG( pos <= GetToolsCount(), (wxToolBarToolBase *)NULL,
+ _T("invalid position in wxToolBar::InsertTool()") );
+
+ wxToolBarToolBase *tool = CreateTool(id, label, bitmap, bmpDisabled, kind,
+ clientData, shortHelp, longHelp);
+
+ if ( !InsertTool(pos, tool) )
{
- return tool->m_toggleState;
+ delete tool;
+
+ return NULL;
}
- else return FALSE;
- }
- else return FALSE;
+
+ return tool;
}
-bool wxToolBarBase::GetToolEnabled(int index) const
+wxToolBarToolBase *wxToolBarBase::AddTool(wxToolBarToolBase *tool)
{
- wxNode *node = m_tools.Find((long)index);
- if (node)
- {
- wxToolBarTool *tool = (wxToolBarTool *)node->Data();
- if (tool)
- {
- return tool->m_enabled;
- }
- else return FALSE;
- }
- else return FALSE;
+ return InsertTool(GetToolsCount(), tool);
}
-wxObject *wxToolBarBase::GetToolClientData(int index) const
+wxToolBarToolBase *
+wxToolBarBase::InsertTool(size_t pos, wxToolBarToolBase *tool)
{
- wxNode *node = m_tools.Find((long)index);
- if (node)
- {
- wxToolBarTool *tool = (wxToolBarTool *)node->Data();
- if (tool)
+ wxCHECK_MSG( pos <= GetToolsCount(), (wxToolBarToolBase *)NULL,
+ _T("invalid position in wxToolBar::InsertTool()") );
+
+ if ( !tool || !DoInsertTool(pos, tool) )
{
- return tool->m_clientData;
+ return NULL;
}
- else return NULL;
- }
- else return NULL;
-}
-void wxToolBarBase::SetToolShortHelp(int index, const wxString& helpString)
-{
- wxNode *node=m_tools.Find((long)index);
- if (node)
- {
- wxToolBarTool *tool = (wxToolBarTool *)node->Data();
- tool->m_shortHelpString = helpString;
- }
-}
+ m_tools.Insert(pos, tool);
-wxString wxToolBarBase::GetToolShortHelp(int index) const
-{
- wxNode *node=m_tools.Find((long)index);
- if (node)
- {
- wxToolBarTool *tool = (wxToolBarTool *)node->Data();
- return tool->m_shortHelpString;
- }
- else
- return wxString("");
+ return tool;
}
-void wxToolBarBase::SetToolLongHelp(int index, const wxString& helpString)
+wxToolBarToolBase *wxToolBarBase::AddControl(wxControl *control)
{
- wxNode *node=m_tools.Find((long)index);
- if (node)
- {
- wxToolBarTool *tool = (wxToolBarTool *)node->Data();
- tool->m_longHelpString = helpString;
- }
+ return InsertControl(GetToolsCount(), control);
}
-wxString wxToolBarBase::GetToolLongHelp(int index) const
+wxToolBarToolBase *wxToolBarBase::InsertControl(size_t pos, wxControl *control)
{
- wxNode *node=m_tools.Find((long)index);
- if (node)
- {
- wxToolBarTool *tool = (wxToolBarTool *)node->Data();
- return tool->m_longHelpString;
- }
- else
- return wxString("");
-}
+ wxCHECK_MSG( control, (wxToolBarToolBase *)NULL,
+ _T("toolbar: can't insert NULL control") );
-wxToolBarTool *wxToolBarBase::FindToolForPosition(long x, long y) const
-{
- wxNode *node = m_tools.First();
- while (node)
- {
- wxToolBarTool *tool = (wxToolBarTool *)node->Data();
- if ((x >= tool->m_x) && (y >= tool->m_y) &&
- (x <= (tool->m_x + tool->GetWidth())) &&
- (y <= (tool->m_y + tool->GetHeight())))
- return tool;
+ wxCHECK_MSG( control->GetParent() == this, (wxToolBarToolBase *)NULL,
+ _T("control must have toolbar as parent") );
- node = node->Next();
- }
- return NULL;
-}
+ wxCHECK_MSG( pos <= GetToolsCount(), (wxToolBarToolBase *)NULL,
+ _T("invalid position in wxToolBar::InsertControl()") );
-wxSize wxToolBarBase::GetMaxSize ( void ) const
-{
- return wxSize(m_maxWidth, m_maxHeight);
-}
+ wxToolBarToolBase *tool = CreateTool(control);
-// Okay, so we've left the tool we're in ... we must check if
-// the tool we're leaving was a 'sprung push button' and if so,
-// spring it back to the up state.
-//
-void wxToolBarBase::SetMargins(int x, int y)
-{
- m_xMargin = x;
- m_yMargin = y;
+ if ( !InsertTool(pos, tool) )
+ {
+ delete tool;
+
+ return NULL;
+ }
+
+ return tool;
}
-void wxToolBarBase::SetToolPacking(int packing)
+wxControl *wxToolBarBase::FindControl( int id )
{
- m_toolPacking = packing;
+ for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
+ node;
+ node = node->GetNext() )
+ {
+ const wxToolBarToolBase * const tool = node->GetData();
+ if ( tool->IsControl() )
+ {
+ wxControl * const control = tool->GetControl();
+
+ if ( !control )
+ {
+ wxFAIL_MSG( _T("NULL control in toolbar?") );
+ }
+ else if ( control->GetId() == id )
+ {
+ // found
+ return control;
+ }
+ }
+ }
+
+ return NULL;
}
-void wxToolBarBase::SetToolSeparation(int separation)
+wxToolBarToolBase *wxToolBarBase::AddSeparator()
{
- m_toolSeparation = separation;
+ return InsertSeparator(GetToolsCount());
}
-void wxToolBarBase::Command(wxCommandEvent& event)
+wxToolBarToolBase *wxToolBarBase::InsertSeparator(size_t pos)
{
+ wxCHECK_MSG( pos <= GetToolsCount(), (wxToolBarToolBase *)NULL,
+ _T("invalid position in wxToolBar::InsertSeparator()") );
+
+ wxToolBarToolBase *tool = CreateTool(wxID_SEPARATOR,
+ wxEmptyString,
+ wxNullBitmap, wxNullBitmap,
+ wxITEM_SEPARATOR, (wxObject *)NULL,
+ wxEmptyString, wxEmptyString);
+
+ if ( !tool || !DoInsertTool(pos, tool) )
+ {
+ delete tool;
+
+ return NULL;
+ }
+
+ m_tools.Insert(pos, tool);
+
+ return tool;
}
-void wxToolBarBase::Layout(void)
+wxToolBarToolBase *wxToolBarBase::RemoveTool(int id)
{
- m_currentRowsOrColumns = 0;
- m_lastX = m_xMargin;
- m_lastY = m_yMargin;
- int maxToolWidth = 0;
- int maxToolHeight = 0;
- m_maxWidth = 0;
- m_maxHeight = 0;
+ size_t pos = 0;
+ wxToolBarToolsList::compatibility_iterator node;
+ for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
+ {
+ if ( node->GetData()->GetId() == id )
+ break;
- // Find the maximum tool width and height
- wxNode *node = m_tools.First();
- while (node)
- {
- wxToolBarTool *tool = (wxToolBarTool *)node->Data();
- if (tool->GetWidth() > maxToolWidth)
- maxToolWidth = (int)tool->GetWidth();
- if (tool->GetHeight() > maxToolHeight)
- maxToolHeight = (int)tool->GetHeight();
- node = node->Next();
- }
+ pos++;
+ }
- int separatorSize = m_toolSeparation;
+ if ( !node )
+ {
+ // don't give any error messages - sometimes we might call RemoveTool()
+ // without knowing whether the tool is or not in the toolbar
+ return (wxToolBarToolBase *)NULL;
+ }
- node = m_tools.First();
- while (node)
- {
- wxToolBarTool *tool = (wxToolBarTool *)node->Data();
- if (tool->m_toolStyle == wxTOOL_STYLE_SEPARATOR)
+ wxToolBarToolBase *tool = node->GetData();
+ if ( !DoDeleteTool(pos, tool) )
{
- if (m_tilingDirection == wxHORIZONTAL)
- {
- if (m_currentRowsOrColumns >= m_rowsOrColumns)
- m_lastY += separatorSize;
- else
- m_lastX += separatorSize;
- }
- else
- {
- if (m_currentRowsOrColumns >= m_rowsOrColumns)
- m_lastX += separatorSize;
- else
- m_lastY += separatorSize;
- }
+ return (wxToolBarToolBase *)NULL;
}
- else if (tool->m_toolStyle == wxTOOL_STYLE_BUTTON)
+
+ m_tools.Erase(node);
+
+ return tool;
+}
+
+bool wxToolBarBase::DeleteToolByPos(size_t pos)
+{
+ wxCHECK_MSG( pos < GetToolsCount(), false,
+ _T("invalid position in wxToolBar::DeleteToolByPos()") );
+
+ wxToolBarToolsList::compatibility_iterator node = m_tools.Item(pos);
+
+ if ( !DoDeleteTool(pos, node->GetData()) )
{
- if (m_tilingDirection == wxHORIZONTAL)
- {
- if (m_currentRowsOrColumns >= m_rowsOrColumns)
- {
- m_currentRowsOrColumns = 0;
- m_lastX = m_xMargin;
- m_lastY += maxToolHeight + m_toolPacking;
- }
- tool->m_x = (long) (m_lastX + (maxToolWidth - tool->GetWidth())/2.0);
- tool->m_y = (long) (m_lastY + (maxToolHeight - tool->GetHeight())/2.0);
-
- m_lastX += maxToolWidth + m_toolPacking;
- }
- else
- {
- if (m_currentRowsOrColumns >= m_rowsOrColumns)
- {
- m_currentRowsOrColumns = 0;
- m_lastX += (maxToolWidth + m_toolPacking);
- m_lastY = m_yMargin;
- }
- tool->m_x = (long) (m_lastX + (maxToolWidth - tool->GetWidth())/2.0);
- tool->m_y = (long) (m_lastY + (maxToolHeight - tool->GetHeight())/2.0);
-
- m_lastY += maxToolHeight + m_toolPacking;
- }
- m_currentRowsOrColumns ++;
+ return false;
}
-
- if (m_lastX > m_maxWidth)
- m_maxWidth = m_lastX;
- if (m_lastY > m_maxHeight)
- m_maxHeight = m_lastY;
- node = node->Next();
- }
- if (m_tilingDirection == wxVERTICAL)
- m_maxWidth += maxToolWidth;
- else
- m_maxHeight += maxToolHeight;
+ delete node->GetData();
+ m_tools.Erase(node);
- m_maxWidth += m_xMargin;
- m_maxHeight += m_yMargin;
+ return true;
}
+bool wxToolBarBase::DeleteTool(int id)
+{
+ size_t pos = 0;
+ wxToolBarToolsList::compatibility_iterator node;
+ for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
+ {
+ if ( node->GetData()->GetId() == id )
+ break;
-// SCROLLING IMPLEMENTATION
+ pos++;
+ }
-/*
- * pixelsPerUnitX/pixelsPerUnitY: number of pixels per unit (e.g. pixels per text line)
- * noUnitsX/noUnitsY: : no. units per scrollbar
- */
-void wxToolBarBase::SetScrollbars (int pixelsPerUnitX, int pixelsPerUnitY,
- int noUnitsX, int noUnitsY,
- int xPos, int yPos)
-{
- m_xScrollPixelsPerLine = pixelsPerUnitX;
- m_yScrollPixelsPerLine = pixelsPerUnitY;
- m_xScrollLines = noUnitsX;
- m_yScrollLines = noUnitsY;
-
- int w, h;
- GetSize(&w, &h);
-
- // Recalculate scroll bar range and position
- if (m_xScrollLines > 0)
- {
- m_xScrollPosition = xPos;
- SetScrollPos (wxHORIZONTAL, m_xScrollPosition, TRUE);
- }
- else
+ if ( !node || !DoDeleteTool(pos, node->GetData()) )
{
- SetScrollbar(wxHORIZONTAL, 0, 0, 0, FALSE);
- m_xScrollPosition = 0;
+ return false;
}
- if (m_yScrollLines > 0)
- {
- m_yScrollPosition = yPos;
- SetScrollPos (wxVERTICAL, m_yScrollPosition, TRUE);
- }
- else
+ delete node->GetData();
+ m_tools.Erase(node);
+
+ return true;
+}
+
+wxToolBarToolBase *wxToolBarBase::FindById(int id) const
+{
+ wxToolBarToolBase *tool = (wxToolBarToolBase *)NULL;
+
+ for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
+ node;
+ node = node->GetNext() )
{
- SetScrollbar(wxVERTICAL, 0, 0, 0, FALSE);
- m_yScrollPosition = 0;
+ tool = node->GetData();
+ if ( tool->GetId() == id )
+ {
+ // found
+ break;
+ }
+
+ tool = NULL;
}
- AdjustScrollbars();
- Refresh();
-#ifdef __WXMSW__
- ::UpdateWindow ((HWND) GetHWND());
-#endif
+
+ return tool;
}
+void wxToolBarBase::UnToggleRadioGroup(wxToolBarToolBase *tool)
+{
+ wxCHECK_RET( tool, _T("NULL tool in wxToolBarTool::UnToggleRadioGroup") );
+
+ if ( !tool->IsButton() || tool->GetKind() != wxITEM_RADIO )
+ return;
-void wxToolBarBase::OnScroll(wxScrollEvent& event)
-{
- int orient = event.GetOrientation();
-
- int nScrollInc = CalcScrollInc(event);
- if (nScrollInc == 0)
- return;
-
- if (orient == wxHORIZONTAL)
- {
- int newPos = m_xScrollPosition + nScrollInc;
- SetScrollPos(wxHORIZONTAL, newPos, TRUE );
- }
- else
- {
- int newPos = m_yScrollPosition + nScrollInc;
- SetScrollPos(wxVERTICAL, newPos, TRUE );
- }
-
- if (orient == wxHORIZONTAL)
- {
- if (m_xScrollingEnabled)
- ScrollWindow(-m_xScrollPixelsPerLine * nScrollInc, 0, NULL);
- else
- Refresh();
- }
- else
- {
- if (m_yScrollingEnabled)
- ScrollWindow(0, -m_yScrollPixelsPerLine * nScrollInc, NULL);
- else
- Refresh();
- }
-
- if (orient == wxHORIZONTAL)
- {
- m_xScrollPosition += nScrollInc;
- }
- else
- {
- m_yScrollPosition += nScrollInc;
- }
-
-}
-
-int wxToolBarBase::CalcScrollInc(wxScrollEvent& event)
-{
- int pos = event.GetPosition();
- int orient = event.GetOrientation();
-
- int nScrollInc = 0;
- switch (event.GetEventType())
- {
- case wxEVENT_TYPE_SCROLL_TOP:
+ wxToolBarToolsList::compatibility_iterator node = m_tools.Find(tool);
+ wxCHECK_RET( node, _T("invalid tool in wxToolBarTool::UnToggleRadioGroup") );
+
+ wxToolBarToolsList::compatibility_iterator nodeNext = node->GetNext();
+ while ( nodeNext )
{
- if (orient == wxHORIZONTAL)
- nScrollInc = - m_xScrollPosition;
- else
- nScrollInc = - m_yScrollPosition;
- break;
+ wxToolBarToolBase *tool = nodeNext->GetData();
+
+ if ( !tool->IsButton() || tool->GetKind() != wxITEM_RADIO )
+ break;
+
+ if ( tool->Toggle(false) )
+ {
+ DoToggleTool(tool, false);
+ }
+
+ nodeNext = nodeNext->GetNext();
}
- case wxEVENT_TYPE_SCROLL_BOTTOM:
+
+ wxToolBarToolsList::compatibility_iterator nodePrev = node->GetPrevious();
+ while ( nodePrev )
{
- if (orient == wxHORIZONTAL)
- nScrollInc = m_xScrollLines - m_xScrollPosition;
- else
- nScrollInc = m_yScrollLines - m_yScrollPosition;
- break;
+ wxToolBarToolBase *tool = nodePrev->GetData();
+
+ if ( !tool->IsButton() || tool->GetKind() != wxITEM_RADIO )
+ break;
+
+ if ( tool->Toggle(false) )
+ {
+ DoToggleTool(tool, false);
+ }
+
+ nodePrev = nodePrev->GetPrevious();
}
- case wxEVENT_TYPE_SCROLL_LINEUP:
+}
+
+void wxToolBarBase::ClearTools()
+{
+ WX_CLEAR_LIST(wxToolBarToolsList, m_tools);
+}
+
+bool wxToolBarBase::Realize()
+{
+ return true;
+}
+
+wxToolBarBase::~wxToolBarBase()
+{
+ WX_CLEAR_LIST(wxToolBarToolsList, m_tools);
+
+ // notify the frame that it doesn't have a tool bar any longer to avoid
+ // dangling pointers
+ wxFrameBase *frame = wxDynamicCast(GetParent(), wxFrameBase);
+ if ( frame && frame->GetToolBar() == this )
{
- nScrollInc = -1;
- break;
+ frame->SetToolBar(NULL);
}
- case wxEVENT_TYPE_SCROLL_LINEDOWN:
+}
+
+// ----------------------------------------------------------------------------
+// wxToolBarBase tools state
+// ----------------------------------------------------------------------------
+
+void wxToolBarBase::EnableTool(int id, bool enable)
+{
+ wxToolBarToolBase *tool = FindById(id);
+ if ( tool )
{
- nScrollInc = 1;
- break;
+ if ( tool->Enable(enable) )
+ {
+ DoEnableTool(tool, enable);
+ }
}
- case wxEVENT_TYPE_SCROLL_PAGEUP:
+}
+
+void wxToolBarBase::ToggleTool(int id, bool toggle)
+{
+ wxToolBarToolBase *tool = FindById(id);
+ if ( tool && tool->CanBeToggled() )
{
- if (orient == wxHORIZONTAL)
- nScrollInc = -GetScrollPageSize(wxHORIZONTAL);
- else
- nScrollInc = -GetScrollPageSize(wxVERTICAL);
- break;
+ if ( tool->Toggle(toggle) )
+ {
+ UnToggleRadioGroup(tool);
+ DoToggleTool(tool, toggle);
+ }
}
- case wxEVENT_TYPE_SCROLL_PAGEDOWN:
+}
+
+void wxToolBarBase::SetToggle(int id, bool toggle)
+{
+ wxToolBarToolBase *tool = FindById(id);
+ if ( tool )
{
- if (orient == wxHORIZONTAL)
- nScrollInc = GetScrollPageSize(wxHORIZONTAL);
- else
- nScrollInc = GetScrollPageSize(wxVERTICAL);
- break;
+ if ( tool->SetToggle(toggle) )
+ {
+ DoSetToggle(tool, toggle);
+ }
}
- case wxEVENT_TYPE_SCROLL_THUMBTRACK:
+}
+
+void wxToolBarBase::SetToolShortHelp(int id, const wxString& help)
+{
+ wxToolBarToolBase *tool = FindById(id);
+ if ( tool )
{
- if (orient == wxHORIZONTAL)
- nScrollInc = pos - m_xScrollPosition;
- else
- nScrollInc = pos - m_yScrollPosition;
- break;
+ (void)tool->SetShortHelp(help);
}
- default:
+}
+
+void wxToolBarBase::SetToolLongHelp(int id, const wxString& help)
+{
+ wxToolBarToolBase *tool = FindById(id);
+ if ( tool )
{
- break;
+ (void)tool->SetLongHelp(help);
}
- }
- if (orient == wxHORIZONTAL)
- {
- int w, h;
- GetClientSize(&w, &h);
-
- int nMaxWidth = m_xScrollLines*m_xScrollPixelsPerLine;
- int noPositions = (int) ( ((nMaxWidth - w)/(float)m_xScrollPixelsPerLine) + 0.5 );
- if (noPositions < 0)
- noPositions = 0;
-
- if ( (m_xScrollPosition + nScrollInc) < 0 )
- nScrollInc = -m_xScrollPosition; // As -ve as we can go
- else if ( (m_xScrollPosition + nScrollInc) > noPositions )
- nScrollInc = noPositions - m_xScrollPosition; // As +ve as we can go
-
- return nScrollInc;
- }
- else
- {
- int w, h;
- GetClientSize(&w, &h);
-
- int nMaxHeight = m_yScrollLines*m_yScrollPixelsPerLine;
- int noPositions = (int) ( ((nMaxHeight - h)/(float)m_yScrollPixelsPerLine) + 0.5 );
- if (noPositions < 0)
- noPositions = 0;
-
- if ( (m_yScrollPosition + nScrollInc) < 0 )
- nScrollInc = -m_yScrollPosition; // As -ve as we can go
- else if ( (m_yScrollPosition + nScrollInc) > noPositions )
- nScrollInc = noPositions - m_yScrollPosition; // As +ve as we can go
-
- return nScrollInc;
- }
-}
-
-// Adjust the scrollbars - new version.
-void wxToolBarBase::AdjustScrollbars(void)
-{
- int w, h;
- GetClientSize(&w, &h);
-
- // Recalculate scroll bar range and position
- if (m_xScrollLines > 0)
- {
- int nMaxWidth = m_xScrollLines*m_xScrollPixelsPerLine;
- int newRange = (int) ( ((nMaxWidth)/(float)m_xScrollPixelsPerLine) + 0.5 );
- if (newRange < 0)
- newRange = 0;
-
- m_xScrollPosition = wxMin(newRange, m_xScrollPosition);
-
- // Calculate page size i.e. number of scroll units you get on the
- // current client window
- int noPagePositions = (int) ( (w/(float)m_xScrollPixelsPerLine) + 0.5 );
- if (noPagePositions < 1)
- noPagePositions = 1;
-
- SetScrollbar(wxHORIZONTAL, m_xScrollPosition, noPagePositions, newRange);
- SetScrollPageSize(wxHORIZONTAL, noPagePositions);
- }
- if (m_yScrollLines > 0)
- {
- int nMaxHeight = m_yScrollLines*m_yScrollPixelsPerLine;
- int newRange = (int) ( ((nMaxHeight)/(float)m_yScrollPixelsPerLine) + 0.5 );
- if (newRange < 0)
- newRange = 0;
-
- m_yScrollPosition = wxMin(newRange, m_yScrollPosition);
-
- // Calculate page size i.e. number of scroll units you get on the
- // current client window
- int noPagePositions = (int) ( (h/(float)m_yScrollPixelsPerLine) + 0.5 );
- if (noPagePositions < 1)
- noPagePositions = 1;
-
- SetScrollbar(wxVERTICAL, m_yScrollPosition, noPagePositions, newRange);
- SetScrollPageSize(wxVERTICAL, noPagePositions);
- }
-}
-
-// Default OnSize resets scrollbars, if any
-void wxToolBarBase::OnSize(wxSizeEvent& event)
-{
-#if USE_CONSTRAINTS
- if (GetAutoLayout())
- Layout();
-#endif
+}
+
+wxObject *wxToolBarBase::GetToolClientData(int id) const
+{
+ wxToolBarToolBase *tool = FindById(id);
- AdjustScrollbars();
+ return tool ? tool->GetClientData() : (wxObject *)NULL;
}
-// Prepare the DC by translating it according to the current scroll position
-void wxToolBarBase::PrepareDC(wxDC& dc)
+void wxToolBarBase::SetToolClientData(int id, wxObject *clientData)
{
- dc.SetDeviceOrigin(- m_xScrollPosition * m_xScrollPixelsPerLine, - m_yScrollPosition * m_yScrollPixelsPerLine);
+ wxToolBarToolBase *tool = FindById(id);
+
+ wxCHECK_RET( tool, _T("no such tool in wxToolBar::SetToolClientData") );
+
+ tool->SetClientData(clientData);
}
-void wxToolBarBase::GetScrollPixelsPerUnit (int *x_unit, int *y_unit) const
+int wxToolBarBase::GetToolPos(int id) const
{
- *x_unit = m_xScrollPixelsPerLine;
- *y_unit = m_yScrollPixelsPerLine;
+ size_t pos = 0;
+ wxToolBarToolsList::compatibility_iterator node;
+
+ for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
+ {
+ if ( node->GetData()->GetId() == id )
+ return pos;
+
+ pos++;
+ }
+
+ return wxNOT_FOUND;
}
-int wxToolBarBase::GetScrollPageSize(int orient) const
+bool wxToolBarBase::GetToolState(int id) const
{
- if ( orient == wxHORIZONTAL )
- return m_xScrollLinesPerPage;
- else
- return m_yScrollLinesPerPage;
+ wxToolBarToolBase *tool = FindById(id);
+ wxCHECK_MSG( tool, false, _T("no such tool") );
+
+ return tool->IsToggled();
}
-void wxToolBarBase::SetScrollPageSize(int orient, int pageSize)
+bool wxToolBarBase::GetToolEnabled(int id) const
{
- if ( orient == wxHORIZONTAL )
- m_xScrollLinesPerPage = pageSize;
- else
- m_yScrollLinesPerPage = pageSize;
+ wxToolBarToolBase *tool = FindById(id);
+ wxCHECK_MSG( tool, false, _T("no such tool") );
+
+ return tool->IsEnabled();
}
-/*
- * Scroll to given position (scroll position, not pixel position)
- */
-void wxToolBarBase::Scroll (int x_pos, int y_pos)
+wxString wxToolBarBase::GetToolShortHelp(int id) const
{
- int old_x, old_y;
- ViewStart (&old_x, &old_y);
- if (((x_pos == -1) || (x_pos == old_x)) && ((y_pos == -1) || (y_pos == old_y)))
- return;
+ wxToolBarToolBase *tool = FindById(id);
+ wxCHECK_MSG( tool, wxEmptyString, _T("no such tool") );
- if (x_pos > -1)
- {
- m_xScrollPosition = x_pos;
- SetScrollPos (wxHORIZONTAL, x_pos, TRUE);
- }
- if (y_pos > -1)
- {
- m_yScrollPosition = y_pos;
- SetScrollPos (wxVERTICAL, y_pos, TRUE);
- }
- Refresh();
-#ifdef __WXMSW__
- UpdateWindow ((HWND) GetHWND());
-#endif
+ return tool->GetShortHelp();
}
-void wxToolBarBase::EnableScrolling (bool x_scroll, bool y_scroll)
+wxString wxToolBarBase::GetToolLongHelp(int id) const
{
- m_xScrollingEnabled = x_scroll;
- m_yScrollingEnabled = y_scroll;
+ wxToolBarToolBase *tool = FindById(id);
+ wxCHECK_MSG( tool, wxEmptyString, _T("no such tool") );
+
+ return tool->GetLongHelp();
}
-void wxToolBarBase::GetVirtualSize (int *x, int *y) const
+// ----------------------------------------------------------------------------
+// wxToolBarBase geometry
+// ----------------------------------------------------------------------------
+
+void wxToolBarBase::SetMargins(int x, int y)
{
- *x = m_xScrollPixelsPerLine * m_xScrollLines;
- *y = m_yScrollPixelsPerLine * m_yScrollLines;
+ m_xMargin = x;
+ m_yMargin = y;
}
-// Where the current view starts from
-void wxToolBarBase::ViewStart (int *x, int *y) const
+void wxToolBarBase::SetRows(int WXUNUSED(nRows))
{
- *x = m_xScrollPosition;
- *y = m_yScrollPosition;
+ // nothing
}
-/*
-void wxToolBarBase::CalcScrolledPosition(int x, int y, int *xx, int *yy) const
+// ----------------------------------------------------------------------------
+// event processing
+// ----------------------------------------------------------------------------
+
+// Only allow toggle if returns true
+bool wxToolBarBase::OnLeftClick(int id, bool toggleDown)
{
- *xx = (m_calcScrolledOffset ? (x - m_xScrollPosition * m_xScrollPixelsPerLine) : x);
- *yy = (m_calcScrolledOffset ? (y - m_yScrollPosition * m_yScrollPixelsPerLine) : y);
+ wxCommandEvent event(wxEVT_COMMAND_TOOL_CLICKED, id);
+ event.SetEventObject(this);
+
+ // we use SetInt() to make wxCommandEvent::IsChecked() return toggleDown
+ event.SetInt((int)toggleDown);
+
+ // and SetExtraLong() for backwards compatibility
+ event.SetExtraLong((long)toggleDown);
+
+ // Send events to this toolbar instead (and thence up the window hierarchy)
+ GetEventHandler()->ProcessEvent(event);
+
+ return true;
}
-void wxToolBarBase::CalcUnscrolledPosition(int x, int y, float *xx, float *yy) const
+// Call when right button down.
+void wxToolBarBase::OnRightClick(int id,
+ long WXUNUSED(x),
+ long WXUNUSED(y))
{
- *xx = (float)(m_calcScrolledOffset ? (x + m_xScrollPosition * m_xScrollPixelsPerLine) : x);
- *yy = (float)(m_calcScrolledOffset ? (y + m_yScrollPosition * m_yScrollPixelsPerLine) : y);
+ wxCommandEvent event(wxEVT_COMMAND_TOOL_RCLICKED, id);
+ event.SetEventObject(this);
+ event.SetInt(id);
+
+ GetEventHandler()->ProcessEvent(event);
}
-*/
-void wxToolBarBase::OnIdle(wxIdleEvent& event)
+// Called when the mouse cursor enters a tool bitmap (no button pressed).
+// Argument is wxID_ANY if mouse is exiting the toolbar.
+// Note that for this event, the id of the window is used,
+// and the integer parameter of wxCommandEvent is used to retrieve
+// the tool id.
+void wxToolBarBase::OnMouseEnter(int id)
{
- wxWindow::OnIdle(event);
+ wxCommandEvent event(wxEVT_COMMAND_TOOL_ENTER, GetId());
+ event.SetEventObject(this);
+ event.SetInt(id);
- DoToolbarUpdates();
+ wxFrame *frame = wxDynamicCast(GetParent(), wxFrame);
+ if( frame )
+ {
+ wxString help;
+ wxToolBarToolBase* tool = id == wxID_ANY ? (wxToolBarToolBase*)NULL : FindById(id);
+ if(tool)
+ help = tool->GetLongHelp();
+ frame->DoGiveHelp( help, id != wxID_ANY );
+ }
+
+ (void)GetEventHandler()->ProcessEvent(event);
}
+// ----------------------------------------------------------------------------
+// UI updates
+// ----------------------------------------------------------------------------
+
// Do the toolbar button updates (check for EVT_UPDATE_UI handlers)
-void wxToolBarBase::DoToolbarUpdates(void)
-{
- wxNode* node = GetTools().First();
- while (node)
- {
- wxToolBarTool* tool = (wxToolBarTool* ) node->Data();
-
- wxUpdateUIEvent event(tool->m_index);
- event.SetEventObject(this);
-
- if (GetEventHandler()->ProcessEvent(event))
- {
- if (event.GetSetEnabled())
- EnableTool(tool->m_index, event.GetEnabled());
- if (event.GetSetChecked())
- ToggleTool(tool->m_index, event.GetChecked());
-/*
- if (event.GetSetText())
- // Set tooltip?
-*/
- }
+void wxToolBarBase::UpdateWindowUI(long flags)
+{
+ wxWindowBase::UpdateWindowUI(flags);
- node = node->Next();
- }
+ // There is no sense in updating the toolbar UI
+ // if the parent window is about to get destroyed
+ wxWindow *tlw = wxGetTopLevelParent( this );
+ if (tlw && wxPendingDelete.Member( tlw ))
+ return;
+
+ wxEvtHandler* evtHandler = GetEventHandler() ;
+
+ for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
+ node;
+ node = node->GetNext() )
+ {
+ int id = node->GetData()->GetId();
+
+ wxUpdateUIEvent event(id);
+ event.SetEventObject(this);
+
+ if ( evtHandler->ProcessEvent(event) )
+ {
+ if ( event.GetSetEnabled() )
+ EnableTool(id, event.GetEnabled());
+ if ( event.GetSetChecked() )
+ ToggleTool(id, event.GetChecked());
+#if 0
+ if ( event.GetSetText() )
+ // Set tooltip?
+#endif // 0
+ }
+ }
+}
+
+// Helper function, used by wxCreateGreyedImage
+
+static void wxGreyOutImage( const wxImage& src,
+ wxImage& dest,
+ const wxColour& darkCol,
+ const wxColour& lightCol,
+ const wxColour& bgCol )
+{
+ // Second attempt, just making things monochrome
+ int width = src.GetWidth();
+ int height = src.GetHeight();
+
+ int redCur, greenCur, blueCur;
+ for ( int x = 0; x < width; x++ )
+ {
+ for ( int y = 1; y < height; y++ )
+ {
+ redCur = src.GetRed(x, y);
+ greenCur = src.GetGreen(x, y);
+ blueCur = src.GetBlue(x, y);
+
+ // Change light things to the background colour
+ if ( redCur >= (lightCol.Red() - 50) && greenCur >= (lightCol.Green() - 50) && blueCur >= (lightCol.Blue() - 50) )
+ {
+ dest.SetRGB(x,y, bgCol.Red(), bgCol.Green(), bgCol.Blue());
+ }
+ else if ( redCur == bgCol.Red() && greenCur == bgCol.Green() && blueCur == bgCol.Blue() )
+ {
+ // Leave the background colour as-is
+ // dest.SetRGB(x,y, bgCol.Red(), bgCol.Green(), bgCol.Blue());
+ }
+ else // if ( redCur <= darkCol.Red() && greenCur <= darkCol.Green() && blueCur <= darkCol.Blue() )
+ {
+ // Change dark things to really dark
+ dest.SetRGB(x,y, darkCol.Red(), darkCol.Green(), darkCol.Blue());
+ }
+ }
+ }
}
-#ifdef __WXMSW__
-// Circumvent wxControl::MSWOnMouseMove which doesn't set the cursor.
-void wxToolBarBase::MSWOnMouseMove(int x, int y, const WXUINT flags)
+/*
+ * Make a greyed-out image suitable for disabled buttons.
+ * This code is adapted from wxNewBitmapButton in FL.
+ */
+
+bool wxCreateGreyedImage(const wxImage& in, wxImage& out)
{
- wxWindow::MSWOnMouseMove(x, y, flags);
+ out = in.Copy();
+
+ // assuming the pixels along the edges are of the background color
+ wxColour bgCol(in.GetRed(0, 0), in.GetGreen(0, 0), in.GetBlue(0, 0));
+
+ wxColour darkCol = wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW) ;
+ wxColour lightCol = wxSystemSettings::GetColour(wxSYS_COLOUR_3DHIGHLIGHT) ;
+
+ wxGreyOutImage(in, out, darkCol, lightCol, bgCol);
+
+ return true;
}
-#endif
-#endif
+#endif // wxUSE_TOOLBAR
projects / wxWidgets.git / blobdiff