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)
    }

    %name(AddToolItem) wxToolBarToolBase *AddTool (wxToolBarToolBase *tool);
    %name(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);

    %name(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();
};


class wxToolBar : public wxToolBarBase {
public:
    %addtofunc wxToolBar         "self._setOORInfo(self)"
    %addtofunc wxToolBar()       ""

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

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

    wxToolBarToolBase *FindToolForPosition(wxCoord x, wxCoord y);
};

//---------------------------------------------------------------------------
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	def AddCheckTool(self, id, bitmap,
	286	bmpDisabled = wx.NullBitmap,
	287	shortHelp = '', longHelp = '',
	288	clientData = None):
	289	'''Add a check tool, i.e. a tool which can be toggled'''
	290	return self.DoAddTool(id, '', bitmap, bmpDisabled, wx.ITEM_CHECK,
	291	shortHelp, longHelp, clientData)
	292
	293	def AddRadioTool(self, id, bitmap,
	294	bmpDisabled = wx.NullBitmap,
	295	shortHelp = '', longHelp = '',
	296	clientData = None):
	297	'''
	298	Add a radio tool, i.e. a tool which can be toggled and releases any
	299	other toggled radio tools in the same group when it happens
	300	'''
	301	return self.DoAddTool(id, '', bitmap, bmpDisabled, wx.ITEM_RADIO,
	302	shortHelp, longHelp, clientData)
	303	}
	304
	305	%name(AddToolItem) wxToolBarToolBase AddTool (wxToolBarToolBase tool);
	306	%name(InsertToolItem) wxToolBarToolBase InsertTool (size_t pos, wxToolBarToolBase tool);
	307
	308	wxToolBarToolBase AddControl(wxControl control);
	309	wxToolBarToolBase InsertControl(size_t pos, wxControl control);
	310	wxControl *FindControl( int id );
	311
	312	wxToolBarToolBase *AddSeparator();
	313	wxToolBarToolBase *InsertSeparator(size_t pos);
	314
	315	wxToolBarToolBase *RemoveTool(int id);
	316
	317	bool DeleteToolByPos(size_t pos);
	318	bool DeleteTool(int id);
	319	void ClearTools();
	320	bool Realize();
	321
	322	void EnableTool(int id, bool enable);
	323	void ToggleTool(int id, bool toggle);
	324	void SetToggle(int id, bool toggle);
	325
	326
	327	%extend {
	328	// convert the ClientData back to a PyObject
	329	PyObject* GetToolClientData(int id) {
	330	wxPyUserData* udata = (wxPyUserData*)self->GetToolClientData(id);
	331	if (udata) {
	332	Py_INCREF(udata->m_obj);
	333	return udata->m_obj;
	334	} else {
	335	Py_INCREF(Py_None);
	336	return Py_None;
	337	}
	338	}
	339
	340	void SetToolClientData(int id, PyObject* clientData) {
	341	self->SetToolClientData(id, new wxPyUserData(clientData));
	342	}
	343	}
	344
	345	// returns tool pos, or wxNOT_FOUND if tool isn't found
	346	int GetToolPos(int id) const;
	347
	348	bool GetToolState(int id);
	349	bool GetToolEnabled(int id);
	350	void SetToolShortHelp(int id, const wxString& helpString);
	351	wxString GetToolShortHelp(int id);
	352	void SetToolLongHelp(int id, const wxString& helpString);
	353	wxString GetToolLongHelp(int id);
	354
	355	%name(SetMarginsXY) void SetMargins(int x, int y);
	356	void SetMargins(const wxSize& size);
	357	void SetToolPacking(int packing);
	358	void SetToolSeparation(int separation);
	359	wxSize GetToolMargins();
	360	wxSize GetMargins();
	361	int GetToolPacking();
	362	int GetToolSeparation();
	363
	364	void SetRows(int nRows);
	365	void SetMaxRowsCols(int rows, int cols);
	366	int GetMaxRows();
	367	int GetMaxCols();
	368
	369	void SetToolBitmapSize(const wxSize& size);
	370	wxSize GetToolBitmapSize();
	371	wxSize GetToolSize();
	372
	373	// returns a (non separator) tool containing the point (x, y) or NULL if
	374	// there is no tool at this point (corrdinates are client)
	375	wxToolBarToolBase *FindToolForPosition(wxCoord x, wxCoord y);
	376
	377	// find the tool by id
	378	wxToolBarToolBase *FindById(int toolid) const;
	379
	380	// return True if this is a vertical toolbar, otherwise False
	381	bool IsVertical();
	382	};
	383
	384
	385
	386
	387	class wxToolBar : public wxToolBarBase {
	388	public:
	389	%addtofunc wxToolBar "self._setOORInfo(self)"
	390	%addtofunc wxToolBar() ""
	391
	392	wxToolBar(wxWindow *parent,
	393	wxWindowID id,
	394	const wxPoint& pos = wxDefaultPosition,
	395	const wxSize& size = wxDefaultSize,
	396	long style = wxNO_BORDER \| wxTB_HORIZONTAL,
	397	const wxString& name = wxPyToolBarNameStr);
	398	%name(PreToolBar)wxToolBar();
	399
	400	bool Create(wxWindow *parent,
	401	wxWindowID id,
	402	const wxPoint& pos = wxDefaultPosition,
	403	const wxSize& size = wxDefaultSize,
	404	long style = wxNO_BORDER \| wxTB_HORIZONTAL,
	405	const wxString& name = wxPyToolBarNameStr);
	406
	407	wxToolBarToolBase *FindToolForPosition(wxCoord x, wxCoord y);
	408	};
	409
	410	//---------------------------------------------------------------------------