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


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

    %property(Bitmap, GetBitmap, doc="See `GetBitmap`");
    %property(ClientData, GetClientData, SetClientData, doc="See `GetClientData` and `SetClientData`");
    %property(Control, GetControl, doc="See `GetControl`");
    %property(DisabledBitmap, GetDisabledBitmap, SetDisabledBitmap, doc="See `GetDisabledBitmap` and `SetDisabledBitmap`");
    %property(Id, GetId, doc="See `GetId`");
    %property(Kind, GetKind, doc="See `GetKind`");
    %property(Label, GetLabel, SetLabel, doc="See `GetLabel` and `SetLabel`");
    %property(LongHelp, GetLongHelp, SetLongHelp, doc="See `GetLongHelp` and `SetLongHelp`");
    %property(NormalBitmap, GetNormalBitmap, SetNormalBitmap, doc="See `GetNormalBitmap` and `SetNormalBitmap`");
    %property(ShortHelp, GetShortHelp, SetShortHelp, doc="See `GetShortHelp` and `SetShortHelp`");
    %property(Style, GetStyle, doc="See `GetStyle`");
    %property(ToolBar, GetToolBar, doc="See `GetToolBar`");
};


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;

    %property(Margins, GetMargins, SetMargins, doc="See `GetMargins` and `SetMargins`");
    %property(MaxCols, GetMaxCols, doc="See `GetMaxCols`");
    %property(MaxRows, GetMaxRows, doc="See `GetMaxRows`");
    %property(ToolBitmapSize, GetToolBitmapSize, SetToolBitmapSize, doc="See `GetToolBitmapSize` and `SetToolBitmapSize`");
    %property(ToolMargins, GetToolMargins, doc="See `GetToolMargins`");
    %property(ToolPacking, GetToolPacking, SetToolPacking, doc="See `GetToolPacking` and `SetToolPacking`");
    %property(ToolSeparation, GetToolSeparation, SetToolSeparation, doc="See `GetToolSeparation` and `SetToolSeparation`");
    %property(ToolSize, GetToolSize, doc="See `GetToolSize`");
    %property(ToolsCount, GetToolsCount, doc="See `GetToolsCount`");
};


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