ea406d2f3a
There is no need for this, these methods are not supposed to be overridden as they are only ever called by wxToolBar itself and making them virtual just confused things. See #16985.
716 lines
26 KiB
C++
716 lines
26 KiB
C++
/////////////////////////////////////////////////////////////////////////////
|
|
// Name: wx/tbarbase.h
|
|
// Purpose: Base class for toolbar classes
|
|
// Author: Julian Smart
|
|
// Modified by:
|
|
// Created: 01/02/97
|
|
// Copyright: (c) Julian Smart
|
|
// Licence: wxWindows licence
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifndef _WX_TBARBASE_H_
|
|
#define _WX_TBARBASE_H_
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// headers
|
|
// ----------------------------------------------------------------------------
|
|
|
|
#include "wx/defs.h"
|
|
|
|
#if wxUSE_TOOLBAR
|
|
|
|
#include "wx/bitmap.h"
|
|
#include "wx/list.h"
|
|
#include "wx/control.h"
|
|
|
|
class WXDLLIMPEXP_FWD_CORE wxToolBarBase;
|
|
class WXDLLIMPEXP_FWD_CORE wxToolBarToolBase;
|
|
class WXDLLIMPEXP_FWD_CORE wxImage;
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// constants
|
|
// ----------------------------------------------------------------------------
|
|
|
|
extern WXDLLIMPEXP_DATA_CORE(const char) wxToolBarNameStr[];
|
|
extern WXDLLIMPEXP_DATA_CORE(const wxSize) wxDefaultSize;
|
|
extern WXDLLIMPEXP_DATA_CORE(const wxPoint) wxDefaultPosition;
|
|
|
|
enum wxToolBarToolStyle
|
|
{
|
|
wxTOOL_STYLE_BUTTON = 1,
|
|
wxTOOL_STYLE_SEPARATOR = 2,
|
|
wxTOOL_STYLE_CONTROL
|
|
};
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// 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 WXDLLIMPEXP_CORE wxToolBarToolBase : public wxObject
|
|
{
|
|
public:
|
|
// ctors & dtor
|
|
// ------------
|
|
|
|
// 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
|
|
// ---------
|
|
|
|
// general
|
|
int GetId() const { return m_id; }
|
|
|
|
wxControl *GetControl() const
|
|
{
|
|
wxASSERT_MSG( IsControl(), wxT("this toolbar tool is not a control") );
|
|
|
|
return m_control;
|
|
}
|
|
|
|
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()); }
|
|
|
|
void SetNormalBitmap(const wxBitmap& bmp) { m_bmpNormal = bmp; }
|
|
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
|
|
{
|
|
wxObject *m_clientData;
|
|
wxControl *m_control;
|
|
};
|
|
|
|
// true if this tool is stretchable: currently is only value for separators
|
|
bool m_stretchable;
|
|
|
|
// tool state
|
|
bool m_toggled;
|
|
bool m_enabled;
|
|
|
|
// normal and disabled bitmaps for the tool, both can be invalid
|
|
wxBitmap m_bmpNormal;
|
|
wxBitmap m_bmpDisabled;
|
|
|
|
// the button label
|
|
wxString m_label;
|
|
|
|
// short and long help strings
|
|
wxString m_shortHelpString;
|
|
wxString m_longHelpString;
|
|
|
|
#if wxUSE_MENUS
|
|
wxMenu *m_dropdownMenu;
|
|
#endif
|
|
|
|
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxToolBarToolBase);
|
|
};
|
|
|
|
// a list of toolbar tools
|
|
WX_DECLARE_EXPORTED_LIST(wxToolBarToolBase, wxToolBarToolsList);
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// the base class for all toolbars
|
|
// ----------------------------------------------------------------------------
|
|
|
|
class WXDLLIMPEXP_CORE wxToolBarBase : public wxControl
|
|
{
|
|
public:
|
|
wxToolBarBase();
|
|
virtual ~wxToolBarBase();
|
|
|
|
// toolbar construction
|
|
// --------------------
|
|
|
|
// 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);
|
|
}
|
|
|
|
|
|
// 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
|
|
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 );
|
|
|
|
// 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
|
|
//
|
|
// derived class versions should call the base one first, before doing
|
|
// platform-specific stuff
|
|
virtual bool Realize();
|
|
|
|
// tools state
|
|
// -----------
|
|
|
|
virtual void EnableTool(int toolid, bool enable);
|
|
virtual void ToggleTool(int toolid, bool toggle);
|
|
|
|
// Set this to be togglable (or not)
|
|
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);
|
|
|
|
// 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)) {}
|
|
|
|
|
|
// margins/packing/separation
|
|
// --------------------------
|
|
|
|
virtual void SetMargins(int x, int y);
|
|
void SetMargins(const wxSize& size)
|
|
{ SetMargins((int) size.x, (int) size.y); }
|
|
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
|
|
// ----------------
|
|
|
|
// 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; }
|
|
|
|
// 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)
|
|
{ m_defaultWidth = size.x; m_defaultHeight = size.y; }
|
|
virtual wxSize GetToolBitmapSize() const
|
|
{ return wxSize(m_defaultWidth, m_defaultHeight); }
|
|
|
|
// 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
|
|
{ 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
|
|
|
|
// event handlers
|
|
// --------------
|
|
|
|
// 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 toolid, bool toggleDown);
|
|
|
|
// Call when right button down.
|
|
virtual void OnRightClick(int toolid, long x, long y);
|
|
|
|
// Called when the mouse cursor enters a tool bitmap.
|
|
// Argument is wxID_ANY if mouse is exiting the toolbar.
|
|
virtual void OnMouseEnter(int toolid);
|
|
|
|
// more deprecated functions
|
|
// -------------------------
|
|
|
|
// 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
|
|
// -------------------------------
|
|
|
|
// Do the toolbar button updates (check for EVT_UPDATE_UI handlers)
|
|
virtual void UpdateWindowUI(long flags = wxUPDATE_UI_NONE) wxOVERRIDE ;
|
|
|
|
// don't want toolbars to accept the focus
|
|
virtual bool AcceptsFocus() const wxOVERRIDE { return false; }
|
|
|
|
#if wxUSE_MENUS
|
|
// Set dropdown menu
|
|
bool SetDropdownMenu(int toolid, wxMenu *menu);
|
|
#endif
|
|
|
|
protected:
|
|
// choose the default border for this window
|
|
virtual wxBorder GetDefaultBorder() const wxOVERRIDE { return wxBORDER_NONE; }
|
|
|
|
// to implement in derived classes
|
|
// -------------------------------
|
|
|
|
// 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
|
|
);
|
|
|
|
// 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;
|
|
|
|
// 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;
|
|
|
|
// called when the tools enabled flag changes
|
|
virtual void DoEnableTool(wxToolBarToolBase *tool, bool enable) = 0;
|
|
|
|
// called when the tool is toggled
|
|
virtual void DoToggleTool(wxToolBarToolBase *tool, bool toggle) = 0;
|
|
|
|
// called when the tools "can be toggled" flag changes
|
|
virtual void DoSetToggle(wxToolBarToolBase *tool, bool toggle) = 0;
|
|
|
|
|
|
// helper functions
|
|
// ----------------
|
|
|
|
// 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();
|
|
|
|
// un-toggle all buttons in the same radio group
|
|
void UnToggleRadioGroup(wxToolBarToolBase *tool);
|
|
|
|
// make the size of the buttons big enough to fit the largest bitmap size
|
|
void AdjustToolBitmapSize();
|
|
|
|
// 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;
|
|
}
|
|
|
|
return tool;
|
|
}
|
|
|
|
// the list of all our tools
|
|
wxToolBarToolsList m_tools;
|
|
|
|
// the offset of the first tool
|
|
int m_xMargin;
|
|
int m_yMargin;
|
|
|
|
// 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:
|
|
wxDECLARE_EVENT_TABLE();
|
|
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_
|
|
|