Don't create multiple parent-less top level frames in layout sample.

[wxWidgets.git] / include / wx / tbarbase.h

diff --git a/include/wx/tbarbase.h b/include/wx/tbarbase.h
index 79e23497724fb39c92ae8787514a78f4ecf6b57c..709b7c53ea36be1013dd233f6caade8e787c7855 100644 (file)
--- a/include/wx/tbarbase.h
+++ b/include/wx/tbarbase.h
@@ -1,11 +1,11 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        tbarbase.h
+// Name:        wx/tbarbase.h

 // Purpose:     Base class for toolbar classes
 // Author:      Julian Smart
 // Modified by:
 // Created:     01/02/97
 // RCS-ID:      $Id$
 // Purpose:     Base class for toolbar classes
 // Author:      Julian Smart
 // Modified by:
 // Created:     01/02/97
 // RCS-ID:      $Id$

-// Copyright:   (c) Julian Smart and Markus Holzem
+// Copyright:   (c) Julian Smart

 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 


@@ -16,27 +16,27 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#ifdef __GNUG__
-    #pragma interface "tbarbase.h"
-#endif
-

 #include "wx/defs.h"
 
 #include "wx/defs.h"
 

+#if wxUSE_TOOLBAR
+

 #include "wx/bitmap.h"
 #include "wx/list.h"
 #include "wx/control.h"
 
 #include "wx/bitmap.h"
 #include "wx/list.h"
 #include "wx/control.h"
 

-class WXDLLEXPORT wxToolBar;
+class WXDLLIMPEXP_FWD_CORE wxToolBarBase;
+class WXDLLIMPEXP_FWD_CORE wxToolBarToolBase;
+class WXDLLIMPEXP_FWD_CORE wxImage;

 
 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------
 

-WXDLLEXPORT_DATA(extern const wxChar*) wxToolBarNameStr;
-WXDLLEXPORT_DATA(extern const wxSize) wxDefaultSize;
-WXDLLEXPORT_DATA(extern const wxPoint) wxDefaultPosition;
+extern WXDLLIMPEXP_DATA_CORE(const char) wxToolBarNameStr[];
+extern WXDLLIMPEXP_DATA_CORE(const wxSize) wxDefaultSize;
+extern WXDLLIMPEXP_DATA_CORE(const wxPoint) wxDefaultPosition;

 
 

-enum
+enum wxToolBarToolStyle

 {
     wxTOOL_STYLE_BUTTON    = 1,
     wxTOOL_STYLE_SEPARATOR = 2,
 {
     wxTOOL_STYLE_BUTTON    = 1,
     wxTOOL_STYLE_SEPARATOR = 2,


@@ -44,60 +44,198 @@ enum
 };
 
 // ----------------------------------------------------------------------------
 };
 
 // ----------------------------------------------------------------------------

-// wxToolBarTool is one button/separator/whatever in the toolbar
+// wxToolBarTool is a toolbar element.
+//
+// It has a unique id (except for the separators which always have id wxID_ANY), the
+// style (telling whether it is a normal button, separator or a control), the
+// state (toggled or not, enabled or not) and short and long help strings. The
+// default implementations use the short help string for the tooltip text which
+// is popped up when the mouse pointer enters the tool and the long help string
+// for the applications status bar.

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

-class WXDLLEXPORT wxToolBarTool : public wxObject
+class WXDLLIMPEXP_CORE wxToolBarToolBase : public wxObject

 {
 public:
     // ctors & dtor
     // ------------
 
 {
 public:
     // ctors & dtor
     // ------------
 

-    wxToolBarTool() { }
-
-#ifdef __WXGTK__
-    wxToolBarTool(wxToolBar *owner,
-                  int theIndex = 0,
-                  const wxBitmap& bitmap1 = wxNullBitmap,
-                  const wxBitmap& bitmap2 = wxNullBitmap,
-                  bool toggle = FALSE,
-                  wxObject *clientData = (wxObject *) NULL,
-                  const wxString& shortHelpString = wxEmptyString,
-                  const wxString& longHelpString = wxEmptyString,
-                  GtkWidget *pixmap = (GtkWidget *) NULL );
-#else // !GTK
-    wxToolBarTool(int theIndex,
-                  const wxBitmap& bitmap1 = wxNullBitmap,
-                  const wxBitmap& bitmap2 = wxNullBitmap,
-                  bool toggle = FALSE,
-                  long xPos = -1,
-                  long yPos = -1,
-                  const wxString& shortHelpString = wxEmptyString,
-                  const wxString& longHelpString = wxEmptyString);
-#endif // GTK/!GTK
-
-    wxToolBarTool(wxControl *control);
-
-    ~wxToolBarTool();
+    // generic ctor for any kind of tool
+    wxToolBarToolBase(wxToolBarBase *tbar = NULL,
+                      int toolid = wxID_SEPARATOR,
+                      const wxString& label = wxEmptyString,
+                      const wxBitmap& bmpNormal = wxNullBitmap,
+                      const wxBitmap& bmpDisabled = wxNullBitmap,
+                      wxItemKind kind = wxITEM_NORMAL,
+                      wxObject *clientData = NULL,
+                      const wxString& shortHelpString = wxEmptyString,
+                      const wxString& longHelpString = wxEmptyString)
+        : m_label(label),
+          m_shortHelpString(shortHelpString),
+          m_longHelpString(longHelpString)
+    {
+        Init
+        (
+            tbar,
+            toolid == wxID_SEPARATOR ? wxTOOL_STYLE_SEPARATOR
+                                     : wxTOOL_STYLE_BUTTON,
+            toolid == wxID_ANY ? wxWindow::NewControlId()
+                               : toolid,
+            kind
+        );
+
+        m_clientData = clientData;
+
+        m_bmpNormal = bmpNormal;
+        m_bmpDisabled = bmpDisabled;
+    }
+
+    // ctor for controls only
+    wxToolBarToolBase(wxToolBarBase *tbar,
+                      wxControl *control,
+                      const wxString& label)
+        : m_label(label)
+    {
+        Init(tbar, wxTOOL_STYLE_CONTROL, control->GetId(), wxITEM_MAX);
+
+        m_control = control;
+    }
+
+    virtual ~wxToolBarToolBase();

 
     // accessors
     // ---------
 
 
     // accessors
     // ---------
 

-    void SetSize( long w, long h ) { m_width = w; m_height = h; }
-    long GetWidth() const { return m_width; }
-    long GetHeight() const { return m_height; }
+    // general
+    int GetId() const { return m_id; }

 
     wxControl *GetControl() const
     {
 
     wxControl *GetControl() const
     {

-        wxASSERT_MSG( m_toolStyle == wxTOOL_STYLE_CONTROL,
-                      _T("this toolbar tool is not a control") );
+        wxASSERT_MSG( IsControl(), wxT("this toolbar tool is not a control") );

 
         return m_control;
     }
 
 
         return m_control;
     }
 

-public:
-    int                   m_toolStyle;
-    int                   m_index;
+    wxToolBarBase *GetToolBar() const { return m_tbar; }
+
+    // style/kind
+    bool IsStretchable() const { return m_stretchable; }
+    bool IsButton() const { return m_toolStyle == wxTOOL_STYLE_BUTTON; }
+    bool IsControl() const { return m_toolStyle == wxTOOL_STYLE_CONTROL; }
+    bool IsSeparator() const { return m_toolStyle == wxTOOL_STYLE_SEPARATOR; }
+    bool IsStretchableSpace() const { return IsSeparator() && IsStretchable(); }
+    int GetStyle() const { return m_toolStyle; }
+    wxItemKind GetKind() const
+    {
+        wxASSERT_MSG( IsButton(), wxT("only makes sense for buttons") );
+
+        return m_kind;
+    }
+
+    void MakeStretchable()
+    {
+        wxASSERT_MSG( IsSeparator(), "only separators can be stretchable" );
+
+        m_stretchable = true;
+    }
+
+    // state
+    bool IsEnabled() const { return m_enabled; }
+    bool IsToggled() const { return m_toggled; }
+    bool CanBeToggled() const
+        { return m_kind == wxITEM_CHECK || m_kind == wxITEM_RADIO; }
+
+    // attributes
+    const wxBitmap& GetNormalBitmap() const { return m_bmpNormal; }
+    const wxBitmap& GetDisabledBitmap() const { return m_bmpDisabled; }
+
+    const wxBitmap& GetBitmap() const
+        { return IsEnabled() ? GetNormalBitmap() : GetDisabledBitmap(); }
+
+    const wxString& GetLabel() const { return m_label; }
+
+    const wxString& GetShortHelp() const { return m_shortHelpString; }
+    const wxString& GetLongHelp() const { return m_longHelpString; }
+
+    wxObject *GetClientData() const
+    {
+        if ( m_toolStyle == wxTOOL_STYLE_CONTROL )
+        {
+            return (wxObject*)m_control->GetClientData();
+        }
+        else
+        {
+            return m_clientData;
+        }
+    }
+
+    // modifiers: return true if the state really changed
+    virtual bool Enable(bool enable);
+    virtual bool Toggle(bool toggle);
+    virtual bool SetToggle(bool toggle);
+    virtual bool SetShortHelp(const wxString& help);
+    virtual bool SetLongHelp(const wxString& help);
+
+    void Toggle() { Toggle(!IsToggled()); }
+
+    virtual void SetNormalBitmap(const wxBitmap& bmp) { m_bmpNormal = bmp; }
+    virtual void SetDisabledBitmap(const wxBitmap& bmp) { m_bmpDisabled = bmp; }
+
+    virtual void SetLabel(const wxString& label) { m_label = label; }
+
+    void SetClientData(wxObject *clientData)
+    {
+        if ( m_toolStyle == wxTOOL_STYLE_CONTROL )
+        {
+            m_control->SetClientData(clientData);
+        }
+        else
+        {
+            m_clientData = clientData;
+        }
+    }
+
+    // add tool to/remove it from a toolbar
+    virtual void Detach() { m_tbar = NULL; }
+    virtual void Attach(wxToolBarBase *tbar) { m_tbar = tbar; }
+
+#if wxUSE_MENUS
+    // these methods are only for tools of wxITEM_DROPDOWN kind (but even such
+    // tools can have a NULL associated menu)
+    virtual void SetDropdownMenu(wxMenu *menu);
+    wxMenu *GetDropdownMenu() const { return m_dropdownMenu; }
+#endif
+
+protected:
+    // common part of all ctors
+    void Init(wxToolBarBase *tbar,
+              wxToolBarToolStyle style,
+              int toolid,
+              wxItemKind kind)
+    {
+        m_tbar = tbar;
+        m_toolStyle = style;
+        m_id = toolid;
+        m_kind = kind;
+
+        m_clientData = NULL;
+
+        m_stretchable = false;
+        m_toggled = false;
+        m_enabled = true;
+
+#if wxUSE_MENUS
+        m_dropdownMenu = NULL;
+#endif
+
+    }
+
+    wxToolBarBase *m_tbar;  // the toolbar to which we belong (may be NULL)
+
+    // tool parameters
+    wxToolBarToolStyle m_toolStyle;
+    wxWindowIDRef m_id; // the tool id, wxID_SEPARATOR for separator
+    wxItemKind m_kind;  // for normal buttons may be wxITEM_NORMAL/CHECK/RADIO

 
     // as controls have their own client data, no need to waste memory
     union
 
     // as controls have their own client data, no need to waste memory
     union


@@ -106,93 +244,194 @@ public:
         wxControl        *m_control;
     };
 
         wxControl        *m_control;
     };
 

-    wxCoord               m_x;
-    wxCoord               m_y;
-    wxCoord               m_width;
-    wxCoord               m_height;
+    // true if this tool is stretchable: currently is only value for separators
+    bool m_stretchable;

 
 

-    bool                  m_toggleState;
-    bool                  m_isToggle;
-    bool                  m_enabled;
-    bool                  m_isMenuCommand;
+    // tool state
+    bool m_toggled;
+    bool m_enabled;

 
 

-    bool                  m_deleteSecondBitmap;
-    wxBitmap              m_bitmap1;
-    wxBitmap              m_bitmap2;
+    // normal and disabled bitmaps for the tool, both can be invalid
+    wxBitmap m_bmpNormal;
+    wxBitmap m_bmpDisabled;

 
 

-    wxString              m_shortHelpString;
-    wxString              m_longHelpString;
+    // the button label
+    wxString m_label;

 
 

-#ifdef __WXGTK__
-    wxToolBar            *m_owner;
-    GtkWidget            *m_item;
-    GtkWidget            *m_pixmap;
-#endif // GTK
+    // short and long help strings
+    wxString m_shortHelpString;
+    wxString m_longHelpString;

 
 

-private:
-    DECLARE_DYNAMIC_CLASS(wxToolBarTool)
+#if wxUSE_MENUS
+    wxMenu *m_dropdownMenu;
+#endif
+
+    DECLARE_DYNAMIC_CLASS_NO_COPY(wxToolBarToolBase)

 };
 
 };
 

+// a list of toolbar tools
+WX_DECLARE_EXPORTED_LIST(wxToolBarToolBase, wxToolBarToolsList);
+

 // ----------------------------------------------------------------------------
 // the base class for all toolbars
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // the base class for all toolbars
 // ----------------------------------------------------------------------------
 

-class WXDLLEXPORT wxToolBarBase : public wxControl
+class WXDLLIMPEXP_CORE wxToolBarBase : public wxControl

 {
 public:
     wxToolBarBase();
 {
 public:
     wxToolBarBase();

-    ~wxToolBarBase();
+    virtual ~wxToolBarBase();

 
     // toolbar construction
     // --------------------
 
 
     // toolbar construction
     // --------------------
 

-    // 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.
-    virtual wxToolBarTool *AddTool(int toolIndex,
-                                   const wxBitmap& bitmap,
-                                   const wxBitmap& pushedBitmap = wxNullBitmap,
-                                   bool toggle = FALSE,
-                                   wxCoord xPos = -1,
-                                   wxCoord yPos = -1,
-                                   wxObject *clientData = NULL,
-                                   const wxString& helpString1 = wxEmptyString,
-                                   const wxString& helpString2 = wxEmptyString);
+    // the full AddTool() function
+    //
+    // If bmpDisabled is wxNullBitmap, a shadowed version of the normal bitmap
+    // is created and used as the disabled image.
+    wxToolBarToolBase *AddTool(int toolid,
+                               const wxString& label,
+                               const wxBitmap& bitmap,
+                               const wxBitmap& bmpDisabled,
+                               wxItemKind kind = wxITEM_NORMAL,
+                               const wxString& shortHelp = wxEmptyString,
+                               const wxString& longHelp = wxEmptyString,
+                               wxObject *data = NULL)
+    {
+        return DoAddTool(toolid, label, bitmap, bmpDisabled, kind,
+                         shortHelp, longHelp, data);
+    }
+
+    // the most common AddTool() version
+    wxToolBarToolBase *AddTool(int toolid,
+                               const wxString& label,
+                               const wxBitmap& bitmap,
+                               const wxString& shortHelp = wxEmptyString,
+                               wxItemKind kind = wxITEM_NORMAL)
+    {
+        return AddTool(toolid, label, bitmap, wxNullBitmap, kind, shortHelp);
+    }
+
+    // add a check tool, i.e. a tool which can be toggled
+    wxToolBarToolBase *AddCheckTool(int toolid,
+                                    const wxString& label,
+                                    const wxBitmap& bitmap,
+                                    const wxBitmap& bmpDisabled = wxNullBitmap,
+                                    const wxString& shortHelp = wxEmptyString,
+                                    const wxString& longHelp = wxEmptyString,
+                                    wxObject *data = NULL)
+    {
+        return AddTool(toolid, label, bitmap, bmpDisabled, wxITEM_CHECK,
+                       shortHelp, longHelp, data);
+    }
+
+    // add a radio tool, i.e. a tool which can be toggled and releases any
+    // other toggled radio tools in the same group when it happens
+    wxToolBarToolBase *AddRadioTool(int toolid,
+                                    const wxString& label,
+                                    const wxBitmap& bitmap,
+                                    const wxBitmap& bmpDisabled = wxNullBitmap,
+                                    const wxString& shortHelp = wxEmptyString,
+                                    const wxString& longHelp = wxEmptyString,
+                                    wxObject *data = NULL)
+    {
+        return AddTool(toolid, label, bitmap, bmpDisabled, wxITEM_RADIO,
+                       shortHelp, longHelp, data);
+    }

 
 

-    // add an arbitrary control to the toolbar at given index, return TRUE if
-    // ok (notice that the control will be deleted by the toolbar and that it
-    // will also adjust its position/size)
+
+    // insert the new tool at the given position, if pos == GetToolsCount(), it
+    // is equivalent to AddTool()
+    virtual wxToolBarToolBase *InsertTool
+                               (
+                                    size_t pos,
+                                    int toolid,
+                                    const wxString& label,
+                                    const wxBitmap& bitmap,
+                                    const wxBitmap& bmpDisabled = wxNullBitmap,
+                                    wxItemKind kind = wxITEM_NORMAL,
+                                    const wxString& shortHelp = wxEmptyString,
+                                    const wxString& longHelp = wxEmptyString,
+                                    wxObject *clientData = NULL
+                               );
+
+    virtual wxToolBarToolBase *AddTool (wxToolBarToolBase *tool);
+    virtual wxToolBarToolBase *InsertTool (size_t pos, wxToolBarToolBase *tool);
+
+    // add an arbitrary control to the toolbar (notice that the control will be
+    // deleted by the toolbar and that it will also adjust its position/size)

     //
     //

+    // the label is optional and, if specified, will be shown near the control

     // NB: the control should have toolbar as its parent
     // NB: the control should have toolbar as its parent

-    virtual bool AddControl(wxControl * WXUNUSED(control)) { return FALSE; }
+    virtual wxToolBarToolBase *
+    AddControl(wxControl *control, const wxString& label = wxEmptyString);
+
+    virtual wxToolBarToolBase *
+    InsertControl(size_t pos, wxControl *control,
+                  const wxString& label = wxEmptyString);
+
+    // get the control with the given id or return NULL
+    virtual wxControl *FindControl( int toolid );

 
 

-    virtual void AddSeparator();
+    // add a separator to the toolbar
+    virtual wxToolBarToolBase *AddSeparator();
+    virtual wxToolBarToolBase *InsertSeparator(size_t pos);
+
+    // add a stretchable space to the toolbar: this is similar to a separator
+    // except that it's always blank and that all the extra space the toolbar
+    // has is [equally] distributed among the stretchable spaces in it
+    virtual wxToolBarToolBase *AddStretchableSpace();
+    virtual wxToolBarToolBase *InsertStretchableSpace(size_t pos);
+
+    // remove the tool from the toolbar: the caller is responsible for actually
+    // deleting the pointer
+    virtual wxToolBarToolBase *RemoveTool(int toolid);
+
+    // delete tool either by index or by position
+    virtual bool DeleteToolByPos(size_t pos);
+    virtual bool DeleteTool(int toolid);
+
+    // delete all tools

     virtual void ClearTools();
 
     // must be called after all buttons have been created to finish toolbar
     // initialisation
     virtual void ClearTools();
 
     // must be called after all buttons have been created to finish toolbar
     // initialisation

-    virtual bool Realize() = 0;
+    //
+    // derived class versions should call the base one first, before doing
+    // platform-specific stuff
+    virtual bool Realize();

 
     // tools state
     // -----------
 
 
     // tools state
     // -----------
 

-    virtual void EnableTool(int toolIndex, bool enable);
-
-    // toggle is TRUE if toggled on
-    virtual void ToggleTool(int toolIndex, bool toggle);
+    virtual void EnableTool(int toolid, bool enable);
+    virtual void ToggleTool(int toolid, bool toggle);

 
     // Set this to be togglable (or not)
 
     // Set this to be togglable (or not)

-    virtual void SetToggle(int toolIndex, bool toggle); 
-    virtual wxObject *GetToolClientData(int index) const;
+    virtual void SetToggle(int toolid, bool toggle);
+
+    // set/get tools client data (not for controls)
+    virtual wxObject *GetToolClientData(int toolid) const;
+    virtual void SetToolClientData(int toolid, wxObject *clientData);

 
 

-    virtual bool GetToolState(int toolIndex) const;
-    virtual bool GetToolEnabled(int toolIndex) const;
-    virtual wxToolBarTool *FindToolForPosition(long x, long y) const;
+    // returns tool pos, or wxNOT_FOUND if tool isn't found
+    virtual int GetToolPos(int id) const;
+
+    // return true if the tool is toggled
+    virtual bool GetToolState(int toolid) const;
+
+    virtual bool GetToolEnabled(int toolid) const;
+
+    virtual void SetToolShortHelp(int toolid, const wxString& helpString);
+    virtual wxString GetToolShortHelp(int toolid) const;
+    virtual void SetToolLongHelp(int toolid, const wxString& helpString);
+    virtual wxString GetToolLongHelp(int toolid) const;
+
+    virtual void SetToolNormalBitmap(int WXUNUSED(id),
+                                     const wxBitmap& WXUNUSED(bitmap)) {}
+    virtual void SetToolDisabledBitmap(int WXUNUSED(id),
+                                       const wxBitmap& WXUNUSED(bitmap)) {}

 
 

-    virtual void SetToolShortHelp(int toolIndex, const wxString& helpString);
-    virtual wxString GetToolShortHelp(int toolIndex) const;
-    virtual void SetToolLongHelp(int toolIndex, const wxString& helpString);
-    virtual wxString GetToolLongHelp(int toolIndex) const;

 
     // margins/packing/separation
     // --------------------------
 
     // margins/packing/separation
     // --------------------------


@@ -200,160 +439,278 @@ public:
     virtual void SetMargins(int x, int y);
     void SetMargins(const wxSize& size)
         { SetMargins((int) size.x, (int) size.y); }
     virtual void SetMargins(int x, int y);
     void SetMargins(const wxSize& size)
         { SetMargins((int) size.x, (int) size.y); }

-    virtual void SetToolPacking(int packing);
-    virtual void SetToolSeparation(int separation);
+    virtual void SetToolPacking(int packing)
+        { m_toolPacking = packing; }
+    virtual void SetToolSeparation(int separation)
+        { m_toolSeparation = separation; }
+
+    virtual wxSize GetToolMargins() const { return wxSize(m_xMargin, m_yMargin); }
+    virtual int GetToolPacking() const { return m_toolPacking; }
+    virtual int GetToolSeparation() const { return m_toolSeparation; }
+
+    // toolbar geometry
+    // ----------------

 
 

-    virtual wxSize GetToolMargins() { return wxSize(m_xMargin, m_yMargin); }
-    virtual int GetToolPacking() { return m_toolPacking; }
-    virtual int GetToolSeparation() { return m_toolSeparation; }
+    // set the number of toolbar rows
+    virtual void SetRows(int nRows);

 
 

+    // the toolbar can wrap - limit the number of columns or rows it may take

     void SetMaxRowsCols(int rows, int cols)
         { m_maxRows = rows; m_maxCols = cols; }
     int GetMaxRows() const { return m_maxRows; }
     int GetMaxCols() const { return m_maxCols; }
 
     void SetMaxRowsCols(int rows, int cols)
         { m_maxRows = rows; m_maxCols = cols; }
     int GetMaxRows() const { return m_maxRows; }
     int GetMaxCols() const { return m_maxCols; }
 

-    // tool(bar) size
-    // -------------
-
+    // get/set the size of the bitmaps used by the toolbar: should be called
+    // before adding any tools to the toolbar

     virtual void SetToolBitmapSize(const wxSize& size)
     virtual void SetToolBitmapSize(const wxSize& size)

-        { m_defaultWidth = size.x; m_defaultHeight = size.y; };
+        { m_defaultWidth = size.x; m_defaultHeight = size.y; }

     virtual wxSize GetToolBitmapSize() const
         { return wxSize(m_defaultWidth, m_defaultHeight); }
 
     virtual wxSize GetToolBitmapSize() const
         { return wxSize(m_defaultWidth, m_defaultHeight); }
 

-    // After the toolbar has initialized, this is the size the tools take up
-    virtual wxSize GetMaxSize() const;
-
-    // The button size (in some implementations) is bigger than the bitmap size: this returns
-    // the total button size.
+    // the button size in some implementations is bigger than the bitmap size:
+    // get the total button size (by default the same as bitmap size)

     virtual wxSize GetToolSize() const
     virtual wxSize GetToolSize() const

-        { return wxSize(m_defaultWidth, m_defaultHeight); } ;
+        { return GetToolBitmapSize(); }
+
+    // returns a (non separator) tool containing the point (x, y) or NULL if
+    // there is no tool at this point (coordinates are client)
+    virtual wxToolBarToolBase *FindToolForPosition(wxCoord x,
+                                                   wxCoord y) const = 0;
+
+    // find the tool by id
+    wxToolBarToolBase *FindById(int toolid) const;
+
+    // return true if this is a vertical toolbar, otherwise false
+    bool IsVertical() const;
+
+    // these methods allow to access tools by their index in the toolbar
+    size_t GetToolsCount() const { return m_tools.GetCount(); }
+    const wxToolBarToolBase *GetToolByPos(int pos) const { return m_tools[pos]; }
+
+#if WXWIN_COMPATIBILITY_2_8
+    // the old versions of the various methods kept for compatibility
+    // don't use in the new code!
+    // --------------------------------------------------------------
+    wxDEPRECATED_INLINE(
+    wxToolBarToolBase *AddTool(int toolid,
+                               const wxBitmap& bitmap,
+                               const wxBitmap& bmpDisabled,
+                               bool toggle = false,
+                               wxObject *clientData = NULL,
+                               const wxString& shortHelpString = wxEmptyString,
+                               const wxString& longHelpString = wxEmptyString)
+    ,
+        return AddTool(toolid, wxEmptyString,
+                       bitmap, bmpDisabled,
+                       toggle ? wxITEM_CHECK : wxITEM_NORMAL,
+                       shortHelpString, longHelpString, clientData);
+    )
+    wxDEPRECATED_INLINE(
+    wxToolBarToolBase *AddTool(int toolid,
+                               const wxBitmap& bitmap,
+                               const wxString& shortHelpString = wxEmptyString,
+                               const wxString& longHelpString = wxEmptyString)
+    ,
+        return AddTool(toolid, wxEmptyString,
+                       bitmap, wxNullBitmap, wxITEM_NORMAL,
+                       shortHelpString, longHelpString, NULL);
+    )
+    wxDEPRECATED_INLINE(
+    wxToolBarToolBase *AddTool(int toolid,
+                               const wxBitmap& bitmap,
+                               const wxBitmap& bmpDisabled,
+                               bool toggle,
+                               wxCoord xPos,
+                               wxCoord yPos = wxDefaultCoord,
+                               wxObject *clientData = NULL,
+                               const wxString& shortHelp = wxEmptyString,
+                               const wxString& longHelp = wxEmptyString)
+    ,
+        return DoAddTool(toolid, wxEmptyString, bitmap, bmpDisabled,
+                         toggle ? wxITEM_CHECK : wxITEM_NORMAL,
+                         shortHelp, longHelp, clientData, xPos, yPos);
+    )
+    wxDEPRECATED_INLINE(
+    wxToolBarToolBase *InsertTool(size_t pos,
+                                  int toolid,
+                                  const wxBitmap& bitmap,
+                                  const wxBitmap& bmpDisabled = wxNullBitmap,
+                                  bool toggle = false,
+                                  wxObject *clientData = NULL,
+                                  const wxString& shortHelp = wxEmptyString,
+                                  const wxString& longHelp = wxEmptyString)
+    ,
+        return InsertTool(pos, toolid, wxEmptyString, bitmap, bmpDisabled,
+                          toggle ? wxITEM_CHECK : wxITEM_NORMAL,
+                          shortHelp, longHelp, clientData);
+    )
+#endif // WXWIN_COMPATIBILITY_2_8

 
 

-    // Handle wxToolBar events
-    // -----------------------
+    // event handlers
+    // --------------

 
     // NB: these functions are deprecated, use EVT_TOOL_XXX() instead!
 
 
     // NB: these functions are deprecated, use EVT_TOOL_XXX() instead!
 

-    // Only allow toggle if returns TRUE. Call when left button up.
-    virtual bool OnLeftClick(int toolIndex, bool toggleDown);
+    // Only allow toggle if returns true. Call when left button up.
+    virtual bool OnLeftClick(int toolid, bool toggleDown);

 
     // Call when right button down.
 
     // Call when right button down.

-    virtual void OnRightClick(int toolIndex, long x, long y);
+    virtual void OnRightClick(int toolid, long x, long y);

 
     // Called when the mouse cursor enters a tool bitmap.
 
     // Called when the mouse cursor enters a tool bitmap.

-    // Argument is -1 if mouse is exiting the toolbar.
-    virtual void OnMouseEnter(int toolIndex);
+    // Argument is wxID_ANY if mouse is exiting the toolbar.
+    virtual void OnMouseEnter(int toolid);

 
     // more deprecated functions
     // -------------------------
 
 
     // more deprecated functions
     // -------------------------
 

-#if WXWIN_COMPATIBILITY
-    void SetDefaultSize(int w, int h) { SetDefaultSize(wxSize(w, h)); }
-    long GetDefaultWidth() const { return m_defaultWidth; }
-    long GetDefaultHeight() const { return m_defaultHeight; }
-    int GetDefaultButtonWidth() const { return (int) GetDefaultButtonSize().x; };
-    int GetDefaultButtonHeight() const { return (int) GetDefaultButtonSize().y; };
-    virtual void SetDefaultSize(const wxSize& size) { SetToolBitmapSize(size); }
-    virtual wxSize GetDefaultSize() const { return GetToolBitmapSize(); }
-    virtual wxSize GetDefaultButtonSize() const { return GetToolSize(); }
-    void GetMaxSize ( long * width, long * height ) const
-    { wxSize maxSize(GetMaxSize()); *width = maxSize.x; *height = maxSize.y; }
-#endif // WXWIN_COMPATIBILITY
+    // use GetToolMargins() instead
+    wxSize GetMargins() const { return GetToolMargins(); }
+
+    // Tool factories,
+    // helper functions to create toolbar tools
+    // -------------------------
+    virtual wxToolBarToolBase *CreateTool(int toolid,
+                                          const wxString& label,
+                                          const wxBitmap& bmpNormal,
+                                          const wxBitmap& bmpDisabled = wxNullBitmap,
+                                          wxItemKind kind = wxITEM_NORMAL,
+                                          wxObject *clientData = NULL,
+                                          const wxString& shortHelp = wxEmptyString,
+                                          const wxString& longHelp = wxEmptyString) = 0;
+
+    virtual wxToolBarToolBase *CreateTool(wxControl *control,
+                                          const wxString& label) = 0;
+
+    // this one is not virtual but just a simple helper/wrapper around
+    // CreateTool() for separators
+    wxToolBarToolBase *CreateSeparator()
+    {
+        return CreateTool(wxID_SEPARATOR,
+                          wxEmptyString,
+                          wxNullBitmap, wxNullBitmap,
+                          wxITEM_SEPARATOR, NULL,
+                          wxEmptyString, wxEmptyString);
+    }

 
 

+    

     // implementation only from now on
     // -------------------------------
 
     // implementation only from now on
     // -------------------------------
 

-    wxList& GetTools() const { return (wxList&) m_tools; }
+    // Do the toolbar button updates (check for EVT_UPDATE_UI handlers)
+    virtual void UpdateWindowUI(long flags = wxUPDATE_UI_NONE) ;

 
 

-    // Lay the tools out
-    virtual void LayoutTools();
+    // don't want toolbars to accept the focus
+    virtual bool AcceptsFocus() const { return false; }

 
 

-    // Add all the buttons: required for Win95.
-    virtual bool CreateTools() { return TRUE; }
+#if wxUSE_MENUS
+    // Set dropdown menu
+    bool SetDropdownMenu(int toolid, wxMenu *menu);
+#endif

 
 

-    void Command(wxCommandEvent& event);
+protected:
+    // choose the default border for this window
+    virtual wxBorder GetDefaultBorder() const { return wxBORDER_NONE; }

 
 

-    // SCROLLING: this has to be copied from wxScrolledWindow since wxToolBarBase
-    // inherits from wxControl. This could have been put into wxToolBarSimple,
-    // but we might want any derived toolbar class to be scrollable.
+    // to implement in derived classes
+    // -------------------------------

 
 

-    // Number of pixels per user unit (0 or -1 for no scrollbar)
-    // Length of virtual canvas in user units
-    virtual void SetScrollbars(int horizontal, int vertical,
-            int x_length, int y_length,
-            int x_pos = 0, int y_pos = 0);
+    // create a new toolbar tool and add it to the toolbar, this is typically
+    // implemented by just calling InsertTool()
+    virtual wxToolBarToolBase *DoAddTool
+                               (
+                                   int toolid,
+                                   const wxString& label,
+                                   const wxBitmap& bitmap,
+                                   const wxBitmap& bmpDisabled,
+                                   wxItemKind kind,
+                                   const wxString& shortHelp = wxEmptyString,
+                                   const wxString& longHelp = wxEmptyString,
+                                   wxObject *clientData = NULL,
+                                   wxCoord xPos = wxDefaultCoord,
+                                   wxCoord yPos = wxDefaultCoord
+                               );

 
 

-    // Physically scroll the window
-    virtual void Scroll(int x_pos, int y_pos);
-    virtual void GetScrollPixelsPerUnit(int *x_unit, int *y_unit) const;
-    virtual void EnableScrolling(bool x_scrolling, bool y_scrolling);
-    virtual void AdjustScrollbars();
+    // the tool is not yet inserted into m_tools list when this function is
+    // called and will only be added to it if this function succeeds
+    virtual bool DoInsertTool(size_t pos, wxToolBarToolBase *tool) = 0;

 
 

-    // Prepare the DC by translating it according to the current scroll position
-    virtual void PrepareDC(wxDC& dc);
+    // the tool is still in m_tools list when this function is called, it will
+    // only be deleted from it if it succeeds
+    virtual bool DoDeleteTool(size_t pos, wxToolBarToolBase *tool) = 0;

 
 

-    int GetScrollPageSize(int orient) const ;
-    void SetScrollPageSize(int orient, int pageSize);
+    // called when the tools enabled flag changes
+    virtual void DoEnableTool(wxToolBarToolBase *tool, bool enable) = 0;

 
 

-    // Get the view start
-    virtual void ViewStart(int *x, int *y) const;
+    // called when the tool is toggled
+    virtual void DoToggleTool(wxToolBarToolBase *tool, bool toggle) = 0;

 
 

-    // Actual size in pixels when scrolling is taken into account
-    virtual void GetVirtualSize(int *x, int *y) const;
+    // called when the tools "can be toggled" flag changes
+    virtual void DoSetToggle(wxToolBarToolBase *tool, bool toggle) = 0;

 
 

-    // Do the toolbar button updates (check for EVT_UPDATE_UI handlers)
-    virtual void DoToolbarUpdates();

 
 

-    // event handlers
-    void OnScroll(wxScrollEvent& event);
-    void OnSize(wxSizeEvent& event);
-    void OnIdle(wxIdleEvent& event);
+    // helper functions
+    // ----------------

 
 

-protected:
-    wxList                m_tools;
+    // call this from derived class ctor/Create() to ensure that we have either
+    // wxTB_HORIZONTAL or wxTB_VERTICAL style, there is a lot of existing code
+    // which randomly checks either one or the other of them and gets confused
+    // if neither is set (and making one of them 0 is not an option neither as
+    // then the existing tests would break down)
+    void FixupStyle();

 
 

-    int                   m_maxRows;
-    int                   m_maxCols;
-    long                  m_maxWidth,
-                          m_maxHeight;
+    // un-toggle all buttons in the same radio group
+    void UnToggleRadioGroup(wxToolBarToolBase *tool);

 
 

-    int                   m_currentTool; // Tool where mouse currently is
-    int                   m_pressedTool; // Tool where mouse pressed
+    // make the size of the buttons big enough to fit the largest bitmap size
+    void AdjustToolBitmapSize();

 
 

-    int                   m_xMargin;
-    int                   m_yMargin;
-    int                   m_toolPacking;
-    int                   m_toolSeparation;
+    // calls InsertTool() and deletes the tool if inserting it failed
+    wxToolBarToolBase *DoInsertNewTool(size_t pos, wxToolBarToolBase *tool)
+    {
+        if ( !InsertTool(pos, tool) )
+        {
+            delete tool;
+            return NULL;
+        }

 
 

-    wxCoord               m_defaultWidth;
-    wxCoord               m_defaultHeight;
+        return tool;
+    }

 
 

-public:
-    ////////////////////////////////////////////////////////////////////////
-    //// IMPLEMENTATION
+    // the list of all our tools
+    wxToolBarToolsList m_tools;

 
 

-    // Calculate scroll increment
-    virtual int CalcScrollInc(wxScrollEvent& event);
+    // the offset of the first tool
+    int m_xMargin;
+    int m_yMargin;

 
 

-    ////////////////////////////////////////////////////////////////////////
-    //// PROTECTED DATA
-protected:
-    int                   m_xScrollPixelsPerLine;
-    int                   m_yScrollPixelsPerLine;
-    bool                  m_xScrollingEnabled;
-    bool                  m_yScrollingEnabled;
-    int                   m_xScrollPosition;
-    int                   m_yScrollPosition;
-    bool                  m_calcScrolledOffset; // If TRUE, wxCanvasDC uses scrolled offsets
-    int                   m_xScrollLines;
-    int                   m_yScrollLines;
-    int                   m_xScrollLinesPerPage;
-    int                   m_yScrollLinesPerPage;
+    // the maximum number of toolbar rows/columns
+    int m_maxRows;
+    int m_maxCols;
+
+    // the tool packing and separation
+    int m_toolPacking,
+        m_toolSeparation;
+
+    // the size of the toolbar bitmaps
+    wxCoord m_defaultWidth, m_defaultHeight;

 
 private:
     DECLARE_EVENT_TABLE()
 
 private:
     DECLARE_EVENT_TABLE()

-    DECLARE_ABSTRACT_CLASS(wxToolBarBase)
+    wxDECLARE_NO_COPY_CLASS(wxToolBarBase);

 };
 
 };
 

+// deprecated function for creating the image for disabled buttons, use
+// wxImage::ConvertToGreyscale() instead
+#if WXWIN_COMPATIBILITY_2_8
+
+wxDEPRECATED( bool wxCreateGreyedImage(const wxImage& in, wxImage& out) );
+
+#endif // WXWIN_COMPATIBILITY_2_8
+
+
+#endif // wxUSE_TOOLBAR
+

 #endif
     // _WX_TBARBASE_H_
 
 #endif
     // _WX_TBARBASE_H_