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,
};


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