X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/cfb7687556620cc0a558c9dab3f582de31369e67..f3ba93c1f025870aeda36082acecc87ab277ab7d:/src/common/tbarbase.cpp

diff --git a/src/common/tbarbase.cpp b/src/common/tbarbase.cpp
index 218ecbea4f..eb371ebc84 100644
--- a/src/common/tbarbase.cpp
+++ b/src/common/tbarbase.cpp
@@ -1,767 +1,640 @@
 /////////////////////////////////////////////////////////////////////////////
-// 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
+// Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
 #ifdef __GNUG__
-#pragma implementation "tbarbase.h"
+    #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 wxUSE_TOOLBAR
+#include "wx/frame.h"
+#include "wx/image.h"
+#include "wx/settings.h"
 
 #include "wx/tbarbase.h"
 
-#if !USE_SHARED_LIBRARY
-IMPLEMENT_ABSTRACT_CLASS(wxToolBarBase, wxControl)
-IMPLEMENT_DYNAMIC_CLASS(wxToolBarTool, wxObject)
+// ----------------------------------------------------------------------------
+// wxWindows macros
+// ----------------------------------------------------------------------------
+
+IMPLEMENT_CLASS(wxToolBarBase, wxControl)
 
 BEGIN_EVENT_TABLE(wxToolBarBase, wxControl)
-  EVT_SCROLL(wxToolBarBase::OnScroll)
-  EVT_SIZE(wxToolBarBase::OnSize)
-  EVT_IDLE(wxToolBarBase::OnIdle)
+    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;
+#include "wx/listimpl.cpp"
 
-#ifdef __WXGTK__
-wxToolBarTool::wxToolBarTool(wxToolBar *owner, int theIndex,
-                    const wxBitmap& theBitmap1, const  wxBitmap& theBitmap2,
-            bool toggle, wxObject *clientData,
-                 const wxString& helpS1, const wxString& helpS2,
-                    GtkWidget *item  )
-#else
-wxToolBarTool::wxToolBarTool(int theIndex,
-                    const wxBitmap& theBitmap1, const wxBitmap& theBitmap2, bool toggle,
-                    long xPos, long yPos, const wxString& helpS1, const wxString& helpS2)
-#endif
-{
-  m_toolStyle = wxTOOL_STYLE_BUTTON;
-#ifdef __WXGTK__
-  m_owner = owner;
-  m_item = item;
-  m_clientData = clientData;
-  m_x = 0;
-  m_y = 0;
-#else
-  m_clientData = NULL;
-  m_x = xPos;
-  m_y = yPos;
-#endif
-  m_index = theIndex;
-  m_isToggle = toggle;
-  m_toggleState = FALSE;
-  m_enabled = TRUE;
-  m_bitmap1 = theBitmap1;
-  m_bitmap2 = theBitmap2;
-  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()
-{
-/*
-  if (m_deleteSecondBitmap && m_bitmap2)
-    delete m_bitmap2;
-*/
-}
+WX_DEFINE_LIST(wxToolBarToolsList);
 
+// ============================================================================
+// implementation
+// ============================================================================
 
-// class wxToolBar
+// ----------------------------------------------------------------------------
+// wxToolBarToolBase
+// ----------------------------------------------------------------------------
 
-wxToolBarBase::wxToolBarBase(void) : m_tools(wxKEY_INTEGER)
+bool wxToolBarToolBase::Enable(bool enable)
 {
-  gs_ToolBars.Append(this);
+    if ( m_enabled == enable )
+        return FALSE;
 
-  m_maxRows = 1;
-  m_maxCols = 32000;
-  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;
+    m_enabled = enable;
 
-  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;
+    return TRUE;
 }
 
-wxToolBarBase::~wxToolBarBase ()
+bool wxToolBarToolBase::Toggle(bool toggle)
 {
-  gs_ToolBars.DeleteObject(this);
+    wxASSERT_MSG( CanBeToggled(), _T("can't toggle this tool") );
 
-  for ( wxNode *node = m_tools.First(); node; node = node->Next() )
-  {
-    wxToolBarTool *tool = (wxToolBarTool *)node->Data();
-    delete tool;
-  }
+    if ( m_toggled == toggle )
+        return FALSE;
+
+    m_toggled = toggle;
+
+    return TRUE;
 }
 
-// Only allow toggle if returns TRUE
-bool wxToolBarBase::OnLeftClick(int toolIndex, bool toggleDown)
+bool wxToolBarToolBase::SetToggle(bool toggle)
 {
-    wxCommandEvent event(wxEVT_COMMAND_TOOL_CLICKED, toolIndex);
-    event.SetEventObject(this);
-    event.SetExtraLong((long) toggleDown);
+    wxItemKind kind = toggle ? wxITEM_CHECK : wxITEM_NORMAL;
+    if ( m_kind == kind )
+        return FALSE;
 
-    GetEventHandler()->ProcessEvent(event);
+    m_kind = kind;
 
     return TRUE;
 }
 
-// Call when right button down.
-void wxToolBarBase::OnRightClick(int toolIndex,
-                                 long WXUNUSED(x),
-                                 long WXUNUSED(y))
+bool wxToolBarToolBase::SetShortHelp(const wxString& help)
 {
-    wxCommandEvent event(wxEVT_COMMAND_TOOL_RCLICKED, toolIndex);
-    event.SetEventObject(this);
-    event.SetInt(toolIndex);
+    if ( m_shortHelpString == help )
+        return FALSE;
 
-    GetEventHandler()->ProcessEvent(event);
+    m_shortHelpString = help;
+
+    return TRUE;
 }
 
-// Called when the mouse cursor enters a tool bitmap (no button pressed).
-// Argument is -1 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 toolIndex )
+bool wxToolBarToolBase::SetLongHelp(const wxString& help)
 {
-    wxCommandEvent event(wxEVT_COMMAND_TOOL_ENTER, GetId());
-    event.SetEventObject(this);
-    event.SetInt(toolIndex);
+    if ( m_longHelpString == help )
+        return FALSE;
 
-    GetEventHandler()->ProcessEvent(event);
+    m_longHelpString = 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)
+wxToolBarToolBase::~wxToolBarToolBase()
 {
-#ifdef __WXGTK__
-  wxToolBarTool *tool = new wxToolBarTool( (wxToolBar*)this, index, bitmap, pushedBitmap, toggle,
-                                           (wxObject*) NULL, helpString1, helpString2);
-#else
-  wxToolBarTool *tool = new wxToolBarTool(index, bitmap, pushedBitmap, toggle, xPos, yPos, helpString1, helpString2);
-#endif
-  tool->m_clientData = clientData;
-
-  if (xPos > -1)
-    tool->m_x = xPos;
-  else
-    tool->m_x = m_xMargin;
+}
 
-  if (yPos > -1)
-    tool->m_y = yPos;
-  else
-    tool->m_y = m_yMargin;
+// ----------------------------------------------------------------------------
+// wxToolBarBase adding/deleting items
+// ----------------------------------------------------------------------------
 
-  // 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);
+wxToolBarBase::wxToolBarBase()
+{
+    // the list owns the pointers
+    m_tools.DeleteContents(TRUE);
 
-  if ((tool->m_y + bitmap.GetHeight() + m_yMargin) > m_maxHeight)
-    m_maxHeight = (tool->m_y + bitmap.GetHeight() + m_yMargin);
+    m_xMargin = m_yMargin = 0;
 
-  m_tools.Append((long)index, tool);
-  return tool;
+    m_maxRows = m_maxCols = 0;
 }
 
-void wxToolBarBase::AddSeparator ()
+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))
 {
-  wxToolBarTool *tool = new wxToolBarTool;
-  tool->m_toolStyle = wxTOOL_STYLE_SEPARATOR;
-  m_tools.Append(-1, tool);
+    return InsertTool(GetToolsCount(), id, label, bitmap, bmpDisabled,
+                      kind, shortHelp, longHelp, clientData);
 }
 
-void wxToolBarBase::ClearTools()
+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)
 {
-  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;
-  }
+    wxCHECK_MSG( pos <= GetToolsCount(), (wxToolBarToolBase *)NULL,
+                 _T("invalid position in wxToolBar::InsertTool()") );
+
+    wxToolBarToolBase *tool = CreateTool(id, label, bitmap, bmpDisabled, kind,
+                                         clientData, shortHelp, longHelp);
+
+    if ( !tool || !DoInsertTool(pos, tool) )
+    {
+        delete tool;
+
+        return NULL;
+    }
+
+    m_tools.Insert(pos, tool);
+
+    return tool;
 }
 
-void wxToolBarBase::EnableTool(int index, bool enable)
+wxToolBarToolBase *wxToolBarBase::AddControl(wxControl *control)
 {
-  wxNode *node = m_tools.Find((long)index);
-  if (node)
-  {
-    wxToolBarTool *tool = (wxToolBarTool *)node->Data();
-    if (tool)
-      tool->m_enabled = enable;
-  }
+    return InsertControl(GetToolsCount(), control);
 }
 
-void wxToolBarBase::ToggleTool(int WXUNUSED(index),
-                               bool WXUNUSED(toggle))
+wxToolBarToolBase *wxToolBarBase::InsertControl(size_t pos, wxControl *control)
 {
+    wxCHECK_MSG( control, (wxToolBarToolBase *)NULL,
+                 _T("toolbar: can't insert NULL control") );
+
+    wxCHECK_MSG( control->GetParent() == this, (wxToolBarToolBase *)NULL,
+                 _T("control must have toolbar as parent") );
+
+    wxCHECK_MSG( pos <= GetToolsCount(), (wxToolBarToolBase *)NULL,
+                 _T("invalid position in wxToolBar::InsertControl()") );
+
+    wxToolBarToolBase *tool = CreateTool(control);
+
+    if ( !tool || !DoInsertTool(pos, tool) )
+    {
+        delete tool;
+
+        return NULL;
+    }
+
+    m_tools.Insert(pos, tool);
+
+    return tool;
 }
 
-void wxToolBarBase::SetToggle(int index, bool value)
+wxToolBarToolBase *wxToolBarBase::AddSeparator()
 {
-  wxNode *node=m_tools.Find((long)index);
-  if (node){
-    wxToolBarTool *tool = (wxToolBarTool *)node->Data();
-    tool->m_isToggle = value;
-  }
+    return InsertSeparator(GetToolsCount());
 }
 
-bool wxToolBarBase::GetToolState(int index) const
+wxToolBarToolBase *wxToolBarBase::InsertSeparator(size_t pos)
 {
-  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::InsertSeparator()") );
+
+    wxToolBarToolBase *tool = CreateTool(wxID_SEPARATOR,
+                                         wxEmptyString,
+                                         wxNullBitmap, wxNullBitmap,
+                                         wxITEM_SEPARATOR, (wxObject *)NULL,
+                                         wxEmptyString, wxEmptyString);
+
+    if ( !tool || !DoInsertTool(pos, tool) )
     {
-      return tool->m_toggleState;
+        delete tool;
+
+        return NULL;
     }
-    else return FALSE;
-  }
-  else return FALSE;
+
+    m_tools.Insert(pos, tool);
+
+    return tool;
 }
 
-bool wxToolBarBase::GetToolEnabled(int index) const
+wxToolBarToolBase *wxToolBarBase::RemoveTool(int id)
 {
-  wxNode *node = m_tools.Find((long)index);
-  if (node)
-  {
-    wxToolBarTool *tool = (wxToolBarTool *)node->Data();
-    if (tool)
+    size_t pos = 0;
+    wxToolBarToolsList::Node *node;
+    for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
     {
-      return tool->m_enabled;
+        if ( node->GetData()->GetId() == id )
+            break;
+
+        pos++;
     }
-    else return FALSE;
-  }
-  else return FALSE;
-}
 
-wxObject *wxToolBarBase::GetToolClientData(int index) const
-{
-  wxNode *node = m_tools.Find((long)index);
-  if (node)
-  {
-    wxToolBarTool *tool = (wxToolBarTool *)node->Data();
-    if (tool)
+    if ( !node )
     {
-      return tool->m_clientData;
+        // 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;
     }
-    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;
-  }
-}
+    wxToolBarToolBase *tool = node->GetData();
+    if ( !DoDeleteTool(pos, tool) )
+    {
+        return (wxToolBarToolBase *)NULL;
+    }
 
-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("");
-}
+    // the node would delete the data, so set it to NULL to avoid this
+    node->SetData(NULL);
 
-void wxToolBarBase::SetToolLongHelp(int index, const wxString& helpString)
-{
-  wxNode *node=m_tools.Find((long)index);
-  if (node)
-  {
-    wxToolBarTool *tool = (wxToolBarTool *)node->Data();
-    tool->m_longHelpString = helpString;
-  }
-}
+    m_tools.DeleteNode(node);
 
-wxString wxToolBarBase::GetToolLongHelp(int index) const
-{
-  wxNode *node=m_tools.Find((long)index);
-  if (node)
-  {
-    wxToolBarTool *tool = (wxToolBarTool *)node->Data();
-    return tool->m_longHelpString;
-  }
-  else
-    return wxString("");
+    return tool;
 }
 
-wxToolBarTool *wxToolBarBase::FindToolForPosition(long x, long y) const
+bool wxToolBarBase::DeleteToolByPos(size_t pos)
 {
-  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( pos < GetToolsCount(), FALSE,
+                 _T("invalid position in wxToolBar::DeleteToolByPos()") );
 
-    node = node->Next();
-  }
-  return NULL;
-}
+    wxToolBarToolsList::Node *node = m_tools.Item(pos);
 
-wxSize wxToolBarBase::GetMaxSize ( void ) const
-{
-  return wxSize(m_maxWidth, m_maxHeight);
+    if ( !DoDeleteTool(pos, node->GetData()) )
+    {
+        return FALSE;
+    }
+
+    m_tools.DeleteNode(node);
+
+    return TRUE;
 }
 
-// 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)
+bool wxToolBarBase::DeleteTool(int id)
 {
-  m_xMargin = x;
-  m_yMargin = y;
+    size_t pos = 0;
+    wxToolBarToolsList::Node *node;
+    for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
+    {
+        if ( node->GetData()->GetId() == id )
+            break;
+
+        pos++;
+    }
+
+    if ( !node || !DoDeleteTool(pos, node->GetData()) )
+    {
+        return FALSE;
+    }
+
+    m_tools.DeleteNode(node);
+
+    return TRUE;
 }
 
-void wxToolBarBase::SetToolPacking(int packing)
+wxToolBarToolBase *wxToolBarBase::FindById(int id) const
 {
-  m_toolPacking = packing;
+    wxToolBarToolBase *tool = (wxToolBarToolBase *)NULL;
+
+    for ( wxToolBarToolsList::Node *node = m_tools.GetFirst();
+          node;
+          node = node->GetNext() )
+    {
+        tool = node->GetData();
+        if ( tool->GetId() == id )
+        {
+            // found
+            break;
+        }
+
+        tool = NULL;
+    }
+
+    return tool;
 }
 
-void wxToolBarBase::SetToolSeparation(int separation)
+void wxToolBarBase::ClearTools()
 {
-  m_toolSeparation = separation;
+    m_tools.Clear();
 }
 
-void wxToolBarBase::Command(wxCommandEvent& WXUNUSED(event))
+bool wxToolBarBase::Realize()
 {
+    return TRUE;
 }
 
-void wxToolBarBase::Layout()
+wxToolBarBase::~wxToolBarBase()
 {
 }
 
+// ----------------------------------------------------------------------------
+// wxToolBarBase tools state
+// ----------------------------------------------------------------------------
 
-// SCROLLING IMPLEMENTATION
-
-/*
- * 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)
+void wxToolBarBase::EnableTool(int id, bool enable)
 {
-      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
+    wxToolBarToolBase *tool = FindById(id);
+    if ( tool )
     {
-      SetScrollbar(wxHORIZONTAL, 0, 0, 0, FALSE);
-      m_xScrollPosition = 0;
+        if ( tool->Enable(enable) )
+        {
+            DoEnableTool(tool, enable);
+        }
     }
+}
 
-    if (m_yScrollLines > 0)
-    {
-      m_yScrollPosition = yPos;
-      SetScrollPos (wxVERTICAL, m_yScrollPosition, TRUE);
-    }
-    else
+void wxToolBarBase::ToggleTool(int id, bool toggle)
+{
+    wxToolBarToolBase *tool = FindById(id);
+    if ( tool && tool->CanBeToggled() )
     {
-      SetScrollbar(wxVERTICAL, 0, 0, 0, FALSE);
-      m_yScrollPosition = 0;
+        if ( tool->Toggle(toggle) )
+        {
+            DoToggleTool(tool, toggle);
+        }
     }
-    AdjustScrollbars();
-    Refresh();
-#ifdef __WXMSW__
-    ::UpdateWindow ((HWND) GetHWND());
-#endif
 }
 
-
-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 wxEVT_SCROLL_TOP:
-    {
-      if (orient == wxHORIZONTAL)
-        nScrollInc = - m_xScrollPosition;
-      else
-        nScrollInc = - m_yScrollPosition;
-      break;
-    }
-    case wxEVT_SCROLL_BOTTOM:
-    {
-      if (orient == wxHORIZONTAL)
-        nScrollInc = m_xScrollLines - m_xScrollPosition;
-      else
-        nScrollInc = m_yScrollLines - m_yScrollPosition;
-      break;
-    }
-    case wxEVT_SCROLL_LINEUP:
-    {
-      nScrollInc = -1;
-      break;
-    }
-    case wxEVT_SCROLL_LINEDOWN:
-    {
-      nScrollInc = 1;
-      break;
-    }
-    case wxEVT_SCROLL_PAGEUP:
-    {
-      if (orient == wxHORIZONTAL)
-        nScrollInc = -GetScrollPageSize(wxHORIZONTAL);
-      else
-        nScrollInc = -GetScrollPageSize(wxVERTICAL);
-      break;
-    }
-    case wxEVT_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 wxEVT_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()
-{
-  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& WXUNUSED(event))
-{
-#if wxUSE_CONSTRAINTS
-  if (GetAutoLayout())
-    Layout();
-#endif
+}
 
-  AdjustScrollbars();
+wxObject *wxToolBarBase::GetToolClientData(int id) const
+{
+    wxToolBarToolBase *tool = FindById(id);
+
+    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
+bool wxToolBarBase::GetToolState(int id) const
 {
-      *x_unit = m_xScrollPixelsPerLine;
-      *y_unit = m_yScrollPixelsPerLine;
+    wxToolBarToolBase *tool = FindById(id);
+    wxCHECK_MSG( tool, FALSE, _T("no such tool") );
+
+    return tool->IsToggled();
 }
 
-int wxToolBarBase::GetScrollPageSize(int orient) const
+bool wxToolBarBase::GetToolEnabled(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->IsEnabled();
 }
 
-void wxToolBarBase::SetScrollPageSize(int orient, int pageSize)
+wxString wxToolBarBase::GetToolShortHelp(int id) const
 {
-    if ( orient == wxHORIZONTAL )
-        m_xScrollLinesPerPage = pageSize;
-    else
-        m_yScrollLinesPerPage = pageSize;
+    wxToolBarToolBase *tool = FindById(id);
+    wxCHECK_MSG( tool, _T(""), _T("no such tool") );
+
+    return tool->GetShortHelp();
 }
 
-/*
- * Scroll to given position (scroll position, not pixel position)
- */
-void wxToolBarBase::Scroll (int x_pos, int y_pos)
+wxString wxToolBarBase::GetToolLongHelp(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, _T(""), _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->GetLongHelp();
+}
+
+// ----------------------------------------------------------------------------
+// wxToolBarBase geometry
+// ----------------------------------------------------------------------------
+
+void wxToolBarBase::SetMargins(int x, int y)
+{
+    m_xMargin = x;
+    m_yMargin = y;
 }
 
-void wxToolBarBase::EnableScrolling (bool x_scroll, bool y_scroll)
+void wxToolBarBase::SetRows(int WXUNUSED(nRows))
+{
+    // nothing
+}
+
+// ----------------------------------------------------------------------------
+// event processing
+// ----------------------------------------------------------------------------
+
+// Only allow toggle if returns TRUE
+bool wxToolBarBase::OnLeftClick(int id, bool toggleDown)
 {
-  m_xScrollingEnabled = x_scroll;
-  m_yScrollingEnabled = y_scroll;
+    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::GetVirtualSize (int *x, int *y) const
+// Call when right button down.
+void wxToolBarBase::OnRightClick(int id,
+                                 long WXUNUSED(x),
+                                 long WXUNUSED(y))
 {
-      *x = m_xScrollPixelsPerLine * m_xScrollLines;
-      *y = m_yScrollPixelsPerLine * m_yScrollLines;
+    wxCommandEvent event(wxEVT_COMMAND_TOOL_RCLICKED, id);
+    event.SetEventObject(this);
+    event.SetInt(id);
+
+    GetEventHandler()->ProcessEvent(event);
 }
 
-// Where the current view starts from
-void wxToolBarBase::ViewStart (int *x, int *y) const
+// Called when the mouse cursor enters a tool bitmap (no button pressed).
+// Argument is -1 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)
 {
-  *x = m_xScrollPosition;
-  *y = m_yScrollPosition;
+    wxCommandEvent event(wxEVT_COMMAND_TOOL_ENTER, GetId());
+    event.SetEventObject(this);
+    event.SetInt(id);
+
+    (void)GetEventHandler()->ProcessEvent(event);
+
+    wxFrame *frame = wxDynamicCast(GetParent(), wxFrame);
+    if ( !frame )
+        return;
+
+    wxString helpstring;
+
+    if ( id != -1 )
+    {
+        wxToolBarToolBase *tool = FindById(id);
+        if ( tool )
+            helpstring = tool->GetLongHelp();
+    }
+
+    // set the status text anyhow, even if the string is empty: this ensures
+    // that it is cleared when the mouse leaves the toolbar or enters a tool
+    // without help
+    frame->SetStatusText(helpstring);
 }
 
+// ----------------------------------------------------------------------------
+// UI updates
+// ----------------------------------------------------------------------------
+
 void wxToolBarBase::OnIdle(wxIdleEvent& event)
 {
-#ifndef __WXGTK__
-    wxWindow::OnIdle(event);
-#endif
-
     DoToolbarUpdates();
+
+    event.Skip();
 }
 
 // Do the toolbar button updates (check for EVT_UPDATE_UI handlers)
 void wxToolBarBase::DoToolbarUpdates()
 {
-    wxNode* node = GetTools().First();
-    while (node)
+    wxWindow* parent = this;
+    while (parent->GetParent())
+        parent = parent->GetParent();
+
+#ifdef __WXMSW__
+    wxWindow* focusWin = wxFindFocusDescendant(parent);
+#else
+    wxWindow* focusWin = (wxWindow*) NULL;
+#endif
+
+    wxEvtHandler* evtHandler = focusWin ? focusWin->GetEventHandler() : GetEventHandler() ;
+
+    for ( wxToolBarToolsList::Node* node = m_tools.GetFirst();
+          node;
+          node = node->GetNext() )
     {
-        wxToolBarTool* tool = (wxToolBarTool* ) node->Data();
+        int id = node->GetData()->GetId();
 
-        wxUpdateUIEvent event(tool->m_index);
+        wxUpdateUIEvent event(id);
         event.SetEventObject(this);
 
-        if (GetEventHandler()->ProcessEvent(event))
+        if ( evtHandler->ProcessEvent(event) )
         {
-            if (event.GetSetEnabled())
-                EnableTool(tool->m_index, event.GetEnabled());
-            if (event.GetSetChecked())
-                ToggleTool(tool->m_index, event.GetChecked());
-/*
-            if (event.GetSetText())
+            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();
 
-        node = node->Next();
+    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, 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