wxPython/src/_toolbar.i

/////////////////////////////////////////////////////////////////////////////
// Name:        _toolbar.i
// Purpose:     SWIG interface defs for wxStatusBar
//
// Author:      Robin Dunn
//
// Created:     24-Aug-1998
// RCS-ID:      $Id$
// Copyright:   (c) 2003 by Total Control Software
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////

// Not a %module


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

MAKE_CONST_WXSTRING_NOSWIG(ToolBarNameStr);


//---------------------------------------------------------------------------
%newgroup;


class wxToolBarBase;

enum wxToolBarToolStyle
{
    wxTOOL_STYLE_BUTTON    = 1,
    wxTOOL_STYLE_SEPARATOR = 2,
    wxTOOL_STYLE_CONTROL
};

enum {
    wxTB_HORIZONTAL,
    wxTB_VERTICAL,
    wxTB_3DBUTTONS,
    wxTB_FLAT,
    wxTB_DOCKABLE,
    wxTB_NOICONS,
    wxTB_TEXT,
    wxTB_NODIVIDER,
    wxTB_NOALIGN,
    wxTB_HORZ_LAYOUT,
    wxTB_HORZ_TEXT,
    wxTB_NO_TOOLTIPS,
};


// wxToolBarTool is a toolbar element.
//
// It has a unique id (except for the separators which always have id -1), 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 wxToolBarToolBase : public wxObject {
public:
//      wxToolBarToolBase(wxToolBarBase *tbar = (wxToolBarBase *)NULL,
//                        int id = wxID_SEPARATOR,
//                        const wxString& label = wxPyEmptyString,
//                        const wxBitmap& bmpNormal = wxNullBitmap,
//                        const wxBitmap& bmpDisabled = wxNullBitmap,
//                        wxItemKind kind = wxITEM_NORMAL,
//                        wxObject *clientData = (wxObject *) NULL,
//                        const wxString& shortHelpString = wxPyEmptyString,
//                        const wxString& longHelpString = wxPyEmptyString)
//      ~wxToolBarToolBase();

    int GetId();
    wxControl *GetControl();
    wxToolBarBase *GetToolBar();
    int IsButton();
    int IsControl();
    int IsSeparator();
    int GetStyle();
    wxItemKind GetKind();
    bool IsEnabled();
    bool IsToggled();
    bool CanBeToggled();
    const wxBitmap& GetNormalBitmap();
    const wxBitmap& GetDisabledBitmap();
    wxBitmap GetBitmap();
    wxString GetLabel();
    wxString GetShortHelp();
    wxString GetLongHelp();
    bool Enable(bool enable);
    void Toggle();
    bool SetToggle(bool toggle);
    bool SetShortHelp(const wxString& help);
    bool SetLongHelp(const wxString& help);
    void SetNormalBitmap(const wxBitmap& bmp);
    void SetDisabledBitmap(const wxBitmap& bmp);
    void SetLabel(const wxString& label);
    void Detach();
    void Attach(wxToolBarBase *tbar);

    //wxObject *GetClientData();
    %extend {
        // convert the ClientData back to a PyObject
        PyObject* GetClientData() {
            wxPyUserData* udata = (wxPyUserData*)self->GetClientData();
            if (udata) {
                Py_INCREF(udata->m_obj);
                return udata->m_obj;
            } else {
                Py_INCREF(Py_None);
                return Py_None;
            }
        }

        void SetClientData(PyObject* clientData) {
            self->SetClientData(new wxPyUserData(clientData));
        }
    }

    %pythoncode {
    GetBitmap1 = GetNormalBitmap
    GetBitmap2 = GetDisabledBitmap
    SetBitmap1 = SetNormalBitmap
    SetBitmap2 = SetDisabledBitmap
    }
};


class wxToolBarBase : public wxControl {
public:

    // This is an Abstract Base Class

    %extend {

        // The full AddTool() function.  Call it DoAddTool in wxPython and
        // implement the other Add methods by calling it.
        //
        // If bmpDisabled is wxNullBitmap, a shadowed version of the normal bitmap
        // is created and used as the disabled image.
        wxToolBarToolBase *DoAddTool(int id,
                                     const wxString& label,
                                     const wxBitmap& bitmap,
                                     const wxBitmap& bmpDisabled = wxNullBitmap,
                                     wxItemKind kind = wxITEM_NORMAL,
                                     const wxString& shortHelp = wxPyEmptyString,
                                     const wxString& longHelp = wxPyEmptyString,
                                     PyObject *clientData = NULL)
        {
            wxPyUserData* udata = NULL;
            if (clientData && clientData != Py_None)
                udata = new wxPyUserData(clientData);
            return self->AddTool(id, label, bitmap, bmpDisabled, kind,
                                 shortHelp, longHelp, udata);
        }


        // Insert the new tool at the given position, if pos == GetToolsCount(), it
        // is equivalent to DoAddTool()
        wxToolBarToolBase *DoInsertTool(size_t pos,
                                      int id,
                                      const wxString& label,
                                      const wxBitmap& bitmap,
                                      const wxBitmap& bmpDisabled = wxNullBitmap,
                                      wxItemKind kind = wxITEM_NORMAL,
                                      const wxString& shortHelp = wxPyEmptyString,
                                      const wxString& longHelp = wxPyEmptyString,
                                      PyObject *clientData = NULL)
        {
            wxPyUserData* udata = NULL;
            if (clientData && clientData != Py_None)
                udata = new wxPyUserData(clientData);
            return self->InsertTool(pos, id, label, bitmap, bmpDisabled, kind,
                                    shortHelp, longHelp, udata);
        }

    }


    %pythoncode {
    %# These match the original Add methods for this class, kept for
    %# backwards compatibility with versions < 2.3.3.


    def AddTool(self, id, bitmap,
                pushedBitmap = wx.NullBitmap,
                isToggle = 0,
                clientData = None,
                shortHelpString = '',
                longHelpString = '') :
        '''Old style method to add a tool to the toolbar.'''
        kind = wx.ITEM_NORMAL
        if isToggle: kind = wx.ITEM_CHECK
        return self.DoAddTool(id, '', bitmap, pushedBitmap, kind,
                              shortHelpString, longHelpString, clientData)

    def AddSimpleTool(self, id, bitmap,
                      shortHelpString = '',
                      longHelpString = '',
                      isToggle = 0):
        '''Old style method to add a tool to the toolbar.'''
        kind = wx.ITEM_NORMAL
        if isToggle: kind = wx.ITEM_CHECK
        return self.DoAddTool(id, '', bitmap, wx.NullBitmap, kind,
                              shortHelpString, longHelpString, None)

    def InsertTool(self, pos, id, bitmap,
                   pushedBitmap = wx.NullBitmap,
                   isToggle = 0,
                   clientData = None,
                   shortHelpString = '',
                   longHelpString = ''):
        '''Old style method to insert a tool in the toolbar.'''
        kind = wx.ITEM_NORMAL
        if isToggle: kind = wx.ITEM_CHECK
        return self.DoInsertTool(pos, id, '', bitmap, pushedBitmap, kind,
                                 shortHelpString, longHelpString, clientData)

    def InsertSimpleTool(self, pos, id, bitmap,
                         shortHelpString = '',
                         longHelpString = '',
                         isToggle = 0):
        '''Old style method to insert a tool in the toolbar.'''
        kind = wx.ITEM_NORMAL
        if isToggle: kind = wx.ITEM_CHECK
        return self.DoInsertTool(pos, id, '', bitmap, wx.NullBitmap, kind,
                                 shortHelpString, longHelpString, None)


    %# The following are the new toolbar Add methods starting with
    %# 2.3.3.  They are renamed to have 'Label' in the name so as to be
    %# able to keep backwards compatibility with using the above
    %# methods.  Eventually these should migrate to be the methods used
    %# primarily and lose the 'Label' in the name...

    def AddLabelTool(self, id, label, bitmap,
                     bmpDisabled = wx.NullBitmap,
                     kind = wx.ITEM_NORMAL,
                     shortHelp = '', longHelp = '',
                     clientData = None):
        '''
        The full AddTool() function.

        If bmpDisabled is wx.NullBitmap, a shadowed version of the normal bitmap
        is created and used as the disabled image.
        '''
        return self.DoAddTool(id, label, bitmap, bmpDisabled, kind,
                              shortHelp, longHelp, clientData)


    def InsertLabelTool(self, pos, id, label, bitmap,
                        bmpDisabled = wx.NullBitmap,
                        kind = wx.ITEM_NORMAL,
                        shortHelp = '', longHelp = '',
                        clientData = None):
        '''
        Insert the new tool at the given position, if pos == GetToolsCount(), it
        is equivalent to AddTool()
        '''
        return self.DoInsertTool(pos, id, label, bitmap, bmpDisabled, kind,
                                 shortHelp, longHelp, clientData)

    def AddCheckLabelTool(self, id, label, bitmap,
                        bmpDisabled = wx.NullBitmap,
                        shortHelp = '', longHelp = '',
                        clientData = None):
        '''Add a check tool, i.e. a tool which can be toggled'''
        return self.DoAddTool(id, label, bitmap, bmpDisabled, wx.ITEM_CHECK,
                              shortHelp, longHelp, clientData)

    def AddRadioLabelTool(self, id, label, bitmap,
                          bmpDisabled = wx.NullBitmap,
                          shortHelp = '', longHelp = '',
                          clientData = None):
        '''
        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
        '''
        return self.DoAddTool(id, label, bitmap, bmpDisabled, wx.ITEM_RADIO,
                              shortHelp, longHelp, clientData)


    %# For consistency with the backwards compatible methods above, here are
    %# some non-'Label' versions of the Check and Radio methods

    def AddCheckTool(self, id, bitmap,
                     bmpDisabled = wx.NullBitmap,
                     shortHelp = '', longHelp = '',
                     clientData = None):
        '''Add a check tool, i.e. a tool which can be toggled'''
        return self.DoAddTool(id, '', bitmap, bmpDisabled, wx.ITEM_CHECK,
                              shortHelp, longHelp, clientData)

    def AddRadioTool(self, id, bitmap,
                     bmpDisabled = wx.NullBitmap,
                     shortHelp = '', longHelp = '',
                     clientData = None):
        '''
        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
        '''
        return self.DoAddTool(id, '', bitmap, bmpDisabled, wx.ITEM_RADIO,
                              shortHelp, longHelp, clientData)
    }

    %Rename(AddToolItem,  wxToolBarToolBase*, AddTool (wxToolBarToolBase *tool));
    %Rename(InsertToolItem,  wxToolBarToolBase*, InsertTool (size_t pos, wxToolBarToolBase *tool));

    wxToolBarToolBase *AddControl(wxControl *control);
    wxToolBarToolBase *InsertControl(size_t pos, wxControl *control);
    wxControl *FindControl( int id );

    wxToolBarToolBase *AddSeparator();
    wxToolBarToolBase *InsertSeparator(size_t pos);

    wxToolBarToolBase *RemoveTool(int id);

    bool DeleteToolByPos(size_t pos);
    bool DeleteTool(int id);
    void ClearTools();
    bool Realize();

    void EnableTool(int id, bool enable);
    void ToggleTool(int id, bool toggle);
    void SetToggle(int id, bool toggle);


    %extend {
        // convert the ClientData back to a PyObject
        PyObject* GetToolClientData(int id) {
            wxPyUserData* udata = (wxPyUserData*)self->GetToolClientData(id);
            if (udata) {
                Py_INCREF(udata->m_obj);
                return udata->m_obj;
            } else {
                Py_INCREF(Py_None);
                return Py_None;
            }
        }

        void SetToolClientData(int id, PyObject* clientData) {
            self->SetToolClientData(id, new wxPyUserData(clientData));
        }
    }

    // returns tool pos, or wxNOT_FOUND if tool isn't found
    int GetToolPos(int id) const;

    bool GetToolState(int id);
    bool GetToolEnabled(int id);
    void SetToolShortHelp(int id, const wxString& helpString);
    wxString GetToolShortHelp(int id);
    void SetToolLongHelp(int id, const wxString& helpString);
    wxString GetToolLongHelp(int id);

    %Rename(SetMarginsXY,  void, SetMargins(int x, int y));
    void SetMargins(const wxSize& size);
    void SetToolPacking(int packing);
    void SetToolSeparation(int separation);
    wxSize GetToolMargins();
    wxSize GetMargins();
    int GetToolPacking();
    int GetToolSeparation();

    void SetRows(int nRows);
    void SetMaxRowsCols(int rows, int cols);
    int GetMaxRows();
    int GetMaxCols();

    void SetToolBitmapSize(const wxSize& size);
    wxSize GetToolBitmapSize();
    wxSize GetToolSize();

    // returns a (non separator) tool containing the point (x, y) or NULL if
    // there is no tool at this point (corrdinates are client)
    wxToolBarToolBase *FindToolForPosition(wxCoord x, wxCoord y);

    // find the tool by id
    wxToolBarToolBase *FindById(int toolid) const;

    // return True if this is a vertical toolbar, otherwise False
    bool IsVertical();

    size_t GetToolsCount() const;
};


MustHaveApp(wxToolBar);

class wxToolBar : public wxToolBarBase {
public:
    %pythonAppend wxToolBar         "self._setOORInfo(self)"
    %pythonAppend wxToolBar()       ""
    %typemap(out) wxToolBar*;    // turn off this typemap

    wxToolBar(wxWindow *parent,
              wxWindowID id=-1,
              const wxPoint& pos = wxDefaultPosition,
              const wxSize& size = wxDefaultSize,
              long style = wxNO_BORDER | wxTB_HORIZONTAL,
              const wxString& name = wxPyToolBarNameStr);
    %RenameCtor(PreToolBar, wxToolBar());

    // Turn it back on again
    %typemap(out) wxToolBar* { $result = wxPyMake_wxObject($1, $owner); }

    bool Create(wxWindow *parent,
              wxWindowID id=-1,
              const wxPoint& pos = wxDefaultPosition,
              const wxSize& size = wxDefaultSize,
              long style = wxNO_BORDER | wxTB_HORIZONTAL,
              const wxString& name = wxPyToolBarNameStr);

    static wxVisualAttributes
    GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
};

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

#if 0
%{
#include <wx/generic/buttonbar.h>
%}

MustHaveApp(wxToolBar);
class  wxButtonToolBar : public wxToolBarBase
{
public:
    %pythonAppend wxButtonToolBar         "self._setOORInfo(self)"
    %pythonAppend wxButtonToolBar()       ""

    wxButtonToolBar(wxWindow *parent,
                    wxWindowID id=-1,
                    const wxPoint& pos = wxDefaultPosition,
                    const wxSize& size = wxDefaultSize,
                    long style = 0,
                    const wxString& name = wxPyToolBarNameStr);
    %RenameCtor(PreButtonToolBar, wxButtonToolBar());


    bool Create(wxWindow *parent,
              wxWindowID id=-1,
              const wxPoint& pos = wxDefaultPosition,
              const wxSize& size = wxDefaultSize,
              long style = 0,
              const wxString& name = wxPyToolBarNameStr);
};

#endif
//---------------------------------------------------------------------------
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: _toolbar.i
	3	// Purpose: SWIG interface defs for wxStatusBar
	4	//
	5	// Author: Robin Dunn
	6	//
	7	// Created: 24-Aug-1998
	8	// RCS-ID: $Id$
	9	// Copyright: (c) 2003 by Total Control Software
	10	// Licence: wxWindows license
	11	/////////////////////////////////////////////////////////////////////////////
	12
	13	// Not a %module
	14
	15
	16	//---------------------------------------------------------------------------
	17
	18	MAKE_CONST_WXSTRING_NOSWIG(ToolBarNameStr);
	19
	20
	21	//---------------------------------------------------------------------------
	22	%newgroup;
	23
	24
	25	class wxToolBarBase;
	26
	27	enum wxToolBarToolStyle
	28	{
	29	wxTOOL_STYLE_BUTTON = 1,
	30	wxTOOL_STYLE_SEPARATOR = 2,
	31	wxTOOL_STYLE_CONTROL
	32	};
	33
	34	enum {
	35	wxTB_HORIZONTAL,
	36	wxTB_VERTICAL,
	37	wxTB_3DBUTTONS,
	38	wxTB_FLAT,
	39	wxTB_DOCKABLE,
	40	wxTB_NOICONS,
	41	wxTB_TEXT,
	42	wxTB_NODIVIDER,
	43	wxTB_NOALIGN,
	44	wxTB_HORZ_LAYOUT,
	45	wxTB_HORZ_TEXT,
	46	wxTB_NO_TOOLTIPS,
	47	};
	48
	49
	50
	51	// wxToolBarTool is a toolbar element.
	52	//
	53	// It has a unique id (except for the separators which always have id -1), the
	54	// style (telling whether it is a normal button, separator or a control), the
	55	// state (toggled or not, enabled or not) and short and long help strings. The
	56	// default implementations use the short help string for the tooltip text which
	57	// is popped up when the mouse pointer enters the tool and the long help string
	58	// for the applications status bar.
	59	class wxToolBarToolBase : public wxObject {
	60	public:
	61	// wxToolBarToolBase(wxToolBarBase tbar = (wxToolBarBase )NULL,
	62	// int id = wxID_SEPARATOR,
	63	// const wxString& label = wxPyEmptyString,
	64	// const wxBitmap& bmpNormal = wxNullBitmap,
	65	// const wxBitmap& bmpDisabled = wxNullBitmap,
	66	// wxItemKind kind = wxITEM_NORMAL,
	67	// wxObject clientData = (wxObject ) NULL,
	68	// const wxString& shortHelpString = wxPyEmptyString,
	69	// const wxString& longHelpString = wxPyEmptyString)
	70	// ~wxToolBarToolBase();
	71
	72	int GetId();
	73	wxControl *GetControl();
	74	wxToolBarBase *GetToolBar();
	75	int IsButton();
	76	int IsControl();
	77	int IsSeparator();
	78	int GetStyle();
	79	wxItemKind GetKind();
	80	bool IsEnabled();
	81	bool IsToggled();
	82	bool CanBeToggled();
	83	const wxBitmap& GetNormalBitmap();
	84	const wxBitmap& GetDisabledBitmap();
	85	wxBitmap GetBitmap();
	86	wxString GetLabel();
	87	wxString GetShortHelp();
	88	wxString GetLongHelp();
	89	bool Enable(bool enable);
	90	void Toggle();
	91	bool SetToggle(bool toggle);
	92	bool SetShortHelp(const wxString& help);
	93	bool SetLongHelp(const wxString& help);
	94	void SetNormalBitmap(const wxBitmap& bmp);
	95	void SetDisabledBitmap(const wxBitmap& bmp);
	96	void SetLabel(const wxString& label);
	97	void Detach();
	98	void Attach(wxToolBarBase *tbar);
	99
	100	//wxObject *GetClientData();
	101	%extend {
	102	// convert the ClientData back to a PyObject
	103	PyObject* GetClientData() {
	104	wxPyUserData* udata = (wxPyUserData*)self->GetClientData();
	105	if (udata) {
	106	Py_INCREF(udata->m_obj);
	107	return udata->m_obj;
	108	} else {
	109	Py_INCREF(Py_None);
	110	return Py_None;
	111	}
	112	}
	113
	114	void SetClientData(PyObject* clientData) {
	115	self->SetClientData(new wxPyUserData(clientData));
	116	}
	117	}
	118
	119	%pythoncode {
	120	GetBitmap1 = GetNormalBitmap
	121	GetBitmap2 = GetDisabledBitmap
	122	SetBitmap1 = SetNormalBitmap
	123	SetBitmap2 = SetDisabledBitmap
	124	}
	125	};
	126
	127
	128
	129
	130	class wxToolBarBase : public wxControl {
	131	public:
	132
	133	// This is an Abstract Base Class
	134
	135	%extend {
	136
	137	// The full AddTool() function. Call it DoAddTool in wxPython and
	138	// implement the other Add methods by calling it.
	139	//
	140	// If bmpDisabled is wxNullBitmap, a shadowed version of the normal bitmap
	141	// is created and used as the disabled image.
	142	wxToolBarToolBase *DoAddTool(int id,
	143	const wxString& label,
	144	const wxBitmap& bitmap,
	145	const wxBitmap& bmpDisabled = wxNullBitmap,
	146	wxItemKind kind = wxITEM_NORMAL,
	147	const wxString& shortHelp = wxPyEmptyString,
	148	const wxString& longHelp = wxPyEmptyString,
	149	PyObject *clientData = NULL)
	150	{
	151	wxPyUserData* udata = NULL;
	152	if (clientData && clientData != Py_None)
	153	udata = new wxPyUserData(clientData);
	154	return self->AddTool(id, label, bitmap, bmpDisabled, kind,
	155	shortHelp, longHelp, udata);
	156	}
	157
	158
	159	// Insert the new tool at the given position, if pos == GetToolsCount(), it
	160	// is equivalent to DoAddTool()
	161	wxToolBarToolBase *DoInsertTool(size_t pos,
	162	int id,
	163	const wxString& label,
	164	const wxBitmap& bitmap,
	165	const wxBitmap& bmpDisabled = wxNullBitmap,
	166	wxItemKind kind = wxITEM_NORMAL,
	167	const wxString& shortHelp = wxPyEmptyString,
	168	const wxString& longHelp = wxPyEmptyString,
	169	PyObject *clientData = NULL)
	170	{
	171	wxPyUserData* udata = NULL;
	172	if (clientData && clientData != Py_None)
	173	udata = new wxPyUserData(clientData);
	174	return self->InsertTool(pos, id, label, bitmap, bmpDisabled, kind,
	175	shortHelp, longHelp, udata);
	176	}
	177
	178	}
	179
	180
	181	%pythoncode {
	182	%# These match the original Add methods for this class, kept for
	183	%# backwards compatibility with versions < 2.3.3.
	184
	185
	186	def AddTool(self, id, bitmap,
	187	pushedBitmap = wx.NullBitmap,
	188	isToggle = 0,
	189	clientData = None,
	190	shortHelpString = '',
	191	longHelpString = '') :
	192	'''Old style method to add a tool to the toolbar.'''
	193	kind = wx.ITEM_NORMAL
	194	if isToggle: kind = wx.ITEM_CHECK
	195	return self.DoAddTool(id, '', bitmap, pushedBitmap, kind,
	196	shortHelpString, longHelpString, clientData)
	197
	198	def AddSimpleTool(self, id, bitmap,
	199	shortHelpString = '',
	200	longHelpString = '',
	201	isToggle = 0):
	202	'''Old style method to add a tool to the toolbar.'''
	203	kind = wx.ITEM_NORMAL
	204	if isToggle: kind = wx.ITEM_CHECK
	205	return self.DoAddTool(id, '', bitmap, wx.NullBitmap, kind,
	206	shortHelpString, longHelpString, None)
	207
	208	def InsertTool(self, pos, id, bitmap,
	209	pushedBitmap = wx.NullBitmap,
	210	isToggle = 0,
	211	clientData = None,
	212	shortHelpString = '',
	213	longHelpString = ''):
	214	'''Old style method to insert a tool in the toolbar.'''
	215	kind = wx.ITEM_NORMAL
	216	if isToggle: kind = wx.ITEM_CHECK
	217	return self.DoInsertTool(pos, id, '', bitmap, pushedBitmap, kind,
	218	shortHelpString, longHelpString, clientData)
	219
	220	def InsertSimpleTool(self, pos, id, bitmap,
	221	shortHelpString = '',
	222	longHelpString = '',
	223	isToggle = 0):
	224	'''Old style method to insert a tool in the toolbar.'''
	225	kind = wx.ITEM_NORMAL
	226	if isToggle: kind = wx.ITEM_CHECK
	227	return self.DoInsertTool(pos, id, '', bitmap, wx.NullBitmap, kind,
	228	shortHelpString, longHelpString, None)
	229
	230
	231	%# The following are the new toolbar Add methods starting with
	232	%# 2.3.3. They are renamed to have 'Label' in the name so as to be
	233	%# able to keep backwards compatibility with using the above
	234	%# methods. Eventually these should migrate to be the methods used
	235	%# primarily and lose the 'Label' in the name...
	236
	237	def AddLabelTool(self, id, label, bitmap,
	238	bmpDisabled = wx.NullBitmap,
	239	kind = wx.ITEM_NORMAL,
	240	shortHelp = '', longHelp = '',
	241	clientData = None):
	242	'''
	243	The full AddTool() function.
	244
	245	If bmpDisabled is wx.NullBitmap, a shadowed version of the normal bitmap
	246	is created and used as the disabled image.
	247	'''
	248	return self.DoAddTool(id, label, bitmap, bmpDisabled, kind,
	249	shortHelp, longHelp, clientData)
	250
	251
	252	def InsertLabelTool(self, pos, id, label, bitmap,
	253	bmpDisabled = wx.NullBitmap,
	254	kind = wx.ITEM_NORMAL,
	255	shortHelp = '', longHelp = '',
	256	clientData = None):
	257	'''
	258	Insert the new tool at the given position, if pos == GetToolsCount(), it
	259	is equivalent to AddTool()
	260	'''
	261	return self.DoInsertTool(pos, id, label, bitmap, bmpDisabled, kind,
	262	shortHelp, longHelp, clientData)
	263
	264	def AddCheckLabelTool(self, id, label, bitmap,
	265	bmpDisabled = wx.NullBitmap,
	266	shortHelp = '', longHelp = '',
	267	clientData = None):
	268	'''Add a check tool, i.e. a tool which can be toggled'''
	269	return self.DoAddTool(id, label, bitmap, bmpDisabled, wx.ITEM_CHECK,
	270	shortHelp, longHelp, clientData)
	271
	272	def AddRadioLabelTool(self, id, label, bitmap,
	273	bmpDisabled = wx.NullBitmap,
	274	shortHelp = '', longHelp = '',
	275	clientData = None):
	276	'''
	277	Add a radio tool, i.e. a tool which can be toggled and releases any
	278	other toggled radio tools in the same group when it happens
	279	'''
	280	return self.DoAddTool(id, label, bitmap, bmpDisabled, wx.ITEM_RADIO,
	281	shortHelp, longHelp, clientData)
	282
	283
	284	%# For consistency with the backwards compatible methods above, here are
	285	%# some non-'Label' versions of the Check and Radio methods
	286
	287	def AddCheckTool(self, id, bitmap,
	288	bmpDisabled = wx.NullBitmap,
	289	shortHelp = '', longHelp = '',
	290	clientData = None):
	291	'''Add a check tool, i.e. a tool which can be toggled'''
	292	return self.DoAddTool(id, '', bitmap, bmpDisabled, wx.ITEM_CHECK,
	293	shortHelp, longHelp, clientData)
	294
	295	def AddRadioTool(self, id, bitmap,
	296	bmpDisabled = wx.NullBitmap,
	297	shortHelp = '', longHelp = '',
	298	clientData = None):
	299	'''
	300	Add a radio tool, i.e. a tool which can be toggled and releases any
	301	other toggled radio tools in the same group when it happens
	302	'''
	303	return self.DoAddTool(id, '', bitmap, bmpDisabled, wx.ITEM_RADIO,
	304	shortHelp, longHelp, clientData)
	305	}
	306
	307	%Rename(AddToolItem, wxToolBarToolBase, AddTool (wxToolBarToolBase tool));
	308	%Rename(InsertToolItem, wxToolBarToolBase, InsertTool (size_t pos, wxToolBarToolBase tool));
	309
	310	wxToolBarToolBase AddControl(wxControl control);
	311	wxToolBarToolBase InsertControl(size_t pos, wxControl control);
	312	wxControl *FindControl( int id );
	313
	314	wxToolBarToolBase *AddSeparator();
	315	wxToolBarToolBase *InsertSeparator(size_t pos);
	316
	317	wxToolBarToolBase *RemoveTool(int id);
	318
	319	bool DeleteToolByPos(size_t pos);
	320	bool DeleteTool(int id);
	321	void ClearTools();
	322	bool Realize();
	323
	324	void EnableTool(int id, bool enable);
	325	void ToggleTool(int id, bool toggle);
	326	void SetToggle(int id, bool toggle);
	327
	328
	329	%extend {
	330	// convert the ClientData back to a PyObject
	331	PyObject* GetToolClientData(int id) {
	332	wxPyUserData* udata = (wxPyUserData*)self->GetToolClientData(id);
	333	if (udata) {
	334	Py_INCREF(udata->m_obj);
	335	return udata->m_obj;
	336	} else {
	337	Py_INCREF(Py_None);
	338	return Py_None;
	339	}
	340	}
	341
	342	void SetToolClientData(int id, PyObject* clientData) {
	343	self->SetToolClientData(id, new wxPyUserData(clientData));
	344	}
	345	}
	346
	347	// returns tool pos, or wxNOT_FOUND if tool isn't found
	348	int GetToolPos(int id) const;
	349
	350	bool GetToolState(int id);
	351	bool GetToolEnabled(int id);
	352	void SetToolShortHelp(int id, const wxString& helpString);
	353	wxString GetToolShortHelp(int id);
	354	void SetToolLongHelp(int id, const wxString& helpString);
	355	wxString GetToolLongHelp(int id);
	356
	357	%Rename(SetMarginsXY, void, SetMargins(int x, int y));
	358	void SetMargins(const wxSize& size);
	359	void SetToolPacking(int packing);
	360	void SetToolSeparation(int separation);
	361	wxSize GetToolMargins();
	362	wxSize GetMargins();
	363	int GetToolPacking();
	364	int GetToolSeparation();
	365
	366	void SetRows(int nRows);
	367	void SetMaxRowsCols(int rows, int cols);
	368	int GetMaxRows();
	369	int GetMaxCols();
	370
	371	void SetToolBitmapSize(const wxSize& size);
	372	wxSize GetToolBitmapSize();
	373	wxSize GetToolSize();
	374
	375	// returns a (non separator) tool containing the point (x, y) or NULL if
	376	// there is no tool at this point (corrdinates are client)
	377	wxToolBarToolBase *FindToolForPosition(wxCoord x, wxCoord y);
	378
	379	// find the tool by id
	380	wxToolBarToolBase *FindById(int toolid) const;
	381
	382	// return True if this is a vertical toolbar, otherwise False
	383	bool IsVertical();
	384
	385	size_t GetToolsCount() const;
	386	};
	387
	388
	389
	390
	391	MustHaveApp(wxToolBar);
	392
	393	class wxToolBar : public wxToolBarBase {
	394	public:
	395	%pythonAppend wxToolBar "self._setOORInfo(self)"
	396	%pythonAppend wxToolBar() ""
	397	%typemap(out) wxToolBar*; // turn off this typemap
	398
	399	wxToolBar(wxWindow *parent,
	400	wxWindowID id=-1,
	401	const wxPoint& pos = wxDefaultPosition,
	402	const wxSize& size = wxDefaultSize,
	403	long style = wxNO_BORDER \| wxTB_HORIZONTAL,
	404	const wxString& name = wxPyToolBarNameStr);
	405	%RenameCtor(PreToolBar, wxToolBar());
	406
	407	// Turn it back on again
	408	%typemap(out) wxToolBar* { $result = wxPyMake_wxObject($1, $owner); }
	409
	410	bool Create(wxWindow *parent,
	411	wxWindowID id=-1,
	412	const wxPoint& pos = wxDefaultPosition,
	413	const wxSize& size = wxDefaultSize,
	414	long style = wxNO_BORDER \| wxTB_HORIZONTAL,
	415	const wxString& name = wxPyToolBarNameStr);
	416
	417	static wxVisualAttributes
	418	GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
	419	};
	420
	421	//---------------------------------------------------------------------------
	422
	423	#if 0
	424	%{
	425	#include <wx/generic/buttonbar.h>
	426	%}
	427
	428	MustHaveApp(wxToolBar);
	429	class wxButtonToolBar : public wxToolBarBase
	430	{
	431	public:
	432	%pythonAppend wxButtonToolBar "self._setOORInfo(self)"
	433	%pythonAppend wxButtonToolBar() ""
	434
	435	wxButtonToolBar(wxWindow *parent,
	436	wxWindowID id=-1,
	437	const wxPoint& pos = wxDefaultPosition,
	438	const wxSize& size = wxDefaultSize,
	439	long style = 0,
	440	const wxString& name = wxPyToolBarNameStr);
	441	%RenameCtor(PreButtonToolBar, wxButtonToolBar());
	442
	443
	444	bool Create(wxWindow *parent,
	445	wxWindowID id=-1,
	446	const wxPoint& pos = wxDefaultPosition,
	447	const wxSize& size = wxDefaultSize,
	448	long style = 0,
	449	const wxString& name = wxPyToolBarNameStr);
	450	};
	451
	452	#endif
	453	//---------------------------------------------------------------------------