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_TOP,
    wxTB_LEFT,
    wxTB_BOTTOM,
    wxTB_RIGHT,

    wxTB_3DBUTTONS,
    wxTB_FLAT,
    wxTB_DOCKABLE,
    wxTB_NOICONS,
    wxTB_TEXT,
    wxTB_NODIVIDER,
    wxTB_NOALIGN,
    wxTB_HORZ_LAYOUT,
    wxTB_HORZ_TEXT,
    wxTB_NO_TOOLTIPS
};


// wxToolBarTool is a toolbar element.
//
// It has a unique id (except for the separators which always have id -1), the
// style (telling whether it is a normal button, separator or a control), the
// state (toggled or not, enabled or not) and short and long help strings. The
// default implementations use the short help string for the tooltip text which
// is popped up when the mouse pointer enters the tool and the long help string
// for the applications status bar.
class wxToolBarToolBase : public wxObject {
public:
//      wxToolBarToolBase(wxToolBarBase *tbar = (wxToolBarBase *)NULL,
//                        int id = wxID_SEPARATOR,
//                        const wxString& label = wxPyEmptyString,
//                        const wxBitmap& bmpNormal = wxNullBitmap,
//                        const wxBitmap& bmpDisabled = wxNullBitmap,
//                        wxItemKind kind = wxITEM_NORMAL,
//                        wxObject *clientData = (wxObject *) NULL,
//                        const wxString& shortHelpString = wxPyEmptyString,
//                        const wxString& longHelpString = wxPyEmptyString)
//      ~wxToolBarToolBase();

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

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

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

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

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