wxPython/src/stattool.i

/////////////////////////////////////////////////////////////////////////////
// Name:        stattool.i
// Purpose:     SWIG definitions for StatusBar and ToolBar classes
//
// Author:      Robin Dunn
//
// Created:     08/24/1998
// RCS-ID:      $Id$
// Copyright:   (c) 1998 by Total Control Software
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////


%module stattool

%{
#include "helpers.h"
#include <wx/toolbar.h>
#include <wx/tbarsmpl.h>
%}

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

%include typemaps.i
%include my_typemaps.i

// Import some definitions of other classes, etc.
%import _defs.i
%import misc.i
%import windows.i
%import controls.i

%pragma(python) code = "import wx"
%pragma(python) code = "wxITEM_NORMAL = 0 # predeclare this since wx isn't fully imported yet"

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

%{
    // Put some wx default wxChar* values into wxStrings.
    DECLARE_DEF_STRING(StatusLineNameStr);
    DECLARE_DEF_STRING(ToolBarNameStr);
    static const wxString wxPyEmptyString(wxT(""));
%}

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

class wxStatusBar : public wxWindow {
public:
    wxStatusBar(wxWindow* parent, wxWindowID id = -1,
                long style = wxST_SIZEGRIP,
                const wxString& name = wxPyStatusLineNameStr);
    %name(wxPreStatusBar)wxStatusBar();

    bool Create(wxWindow* parent, wxWindowID id,
                long style = wxST_SIZEGRIP,
                const wxString& name = wxPyStatusLineNameStr);

    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
    %pragma(python) addtomethod = "wxPreStatusBar:val._setOORInfo(val)"

    %addmethods {
        %new wxRect* GetFieldRect(long item) {
            wxRect* rect= new wxRect;
            self->GetFieldRect(item, *rect);
            return rect;
        }
    }
    int GetFieldsCount(void);
    wxString GetStatusText(int ir = 0);
    int GetBorderX();
    int GetBorderY();

    void SetFieldsCount(int number = 1);
    void SetStatusText(const wxString& text, int i = 0);
    void SetStatusWidths(int LCOUNT, int* choices);
    void PushStatusText(const wxString& text, int number = 0);
    void PopStatusText(int number = 0);

    void SetMinHeight(int height);
};


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

class wxToolBarBase;

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


class wxToolBarToolBase : public wxObject {
public:
//      wxToolBarToolBase(wxToolBarBase *tbar = (wxToolBarBase *)NULL,
//                        int id = wxID_SEPARATOR,
//                        const wxString& label = wxEmptyString,
//                        const wxBitmap& bmpNormal = wxNullBitmap,
//                        const wxBitmap& bmpDisabled = wxNullBitmap,
//                        wxItemKind kind = wxITEM_NORMAL,
//                        wxObject *clientData = (wxObject *) NULL,
//                        const wxString& shortHelpString = wxEmptyString,
//                        const wxString& longHelpString = wxEmptyString)
//      ~wxToolBarToolBase();

    %addmethods { void Destroy() { delete self; } }

    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();
    %addmethods {
        // 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));
        }
    }

    %pragma(python) addtoclass="
    GetBitmap1 = GetNormalBitmap
    GetBitmap2 = GetDisabledBitmap
    SetBitmap1 = SetNormalBitmap
    SetBitmap2 = SetDisabledBitmap
    "
};


class wxToolBarBase : public wxControl {
public:

    // This is an Abstract Base Class

    %addmethods {

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

    }


    %pragma(python) addtoclass = "
    # These match the original Add methods for this class, kept for
    # backwards compatibility with versions < 2.3.3.


    def AddTool(self, id, bitmap,
                pushedBitmap = wxNullBitmap,
                isToggle = 0,
                clientData = None,
                shortHelpString = '',
                longHelpString = '') :
        '''Old style method to add a tool to the toolbar.'''
        kind = wx.wxITEM_NORMAL
        if isToggle: kind = wx.wxITEM_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.wxITEM_NORMAL
        if isToggle: kind = wx.wxITEM_CHECK
        return self.DoAddTool(id, '', bitmap, wxNullBitmap, kind,
                              shortHelpString, longHelpString, None)

    def InsertTool(self, pos, id, bitmap,
                   pushedBitmap = wxNullBitmap,
                   isToggle = 0,
                   clientData = None,
                   shortHelpString = '',
                   longHelpString = ''):
        '''Old style method to insert a tool in the toolbar.'''
        kind = wx.wxITEM_NORMAL
        if isToggle: kind = wx.wxITEM_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.wxITEM_NORMAL
        if isToggle: kind = wx.wxITEM_CHECK
        return self.DoInsertTool(pos, id, '', bitmap, wxNullBitmap, 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 = wxNullBitmap,
                     kind = wxITEM_NORMAL,
                     shortHelp = '', longHelp = '',
                     clientData = None):
        '''
        The full AddTool() function.

        If bmpDisabled is wxNullBitmap, 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 = wxNullBitmap,
                        kind = wxITEM_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 = wxNullBitmap,
                        shortHelp = '', longHelp = '',
                        clientData = None):
        '''Add a check tool, i.e. a tool which can be toggled'''
        return self.DoAddTool(id, label, bitmap, bmpDisabled, wx.wxITEM_CHECK,
                              shortHelp, longHelp, clientData)

    def AddRadioLabelTool(self, id, label, bitmap,
                          bmpDisabled = wxNullBitmap,
                          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.wxITEM_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 = wxNullBitmap,
                     shortHelp = '', longHelp = '',
                     clientData = None):
        '''Add a check tool, i.e. a tool which can be toggled'''
        return self.DoAddTool(id, '', bitmap, bmpDisabled, wx.wxITEM_CHECK,
                              shortHelp, longHelp, clientData)

    def AddRadioTool(self, id, bitmap,
                     bmpDisabled = wxNullBitmap,
                     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.wxITEM_RADIO,
                              shortHelp, longHelp, clientData)
    "

    // TODO?
    //wxToolBarToolBase *AddTool (wxToolBarToolBase *tool);
    //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);


    %addmethods {
        // 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));
        }
    }


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

    // return TRUE if this is a vertical toolbar, otherwise FALSE
    bool IsVertical();
};


class wxToolBar : public wxToolBarBase {
public:
    wxToolBar(wxWindow *parent,
              wxWindowID id,
              const wxPoint& pos = wxDefaultPosition,
              const wxSize& size = wxDefaultSize,
              long style = wxNO_BORDER | wxTB_HORIZONTAL,
              const wxString& name = wxPyToolBarNameStr);
    %name(wxPreToolBar)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);

    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
    %pragma(python) addtomethod = "wxPreToolBar:val._setOORInfo(val)"

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


class wxToolBarSimple : public wxToolBarBase {
public:
    wxToolBarSimple(wxWindow *parent,
                    wxWindowID id,
                    const wxPoint& pos = wxDefaultPosition,
                    const wxSize& size = wxDefaultSize,
                    long style = wxNO_BORDER | wxTB_HORIZONTAL,
                    const wxString& name = wxPyToolBarNameStr);
    %name(wxPreToolBarSimple)wxToolBarSimple();

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

    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
    %pragma(python) addtomethod = "wxPreToolBarSimple:val._setOORInfo(val)"

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

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: stattool.i
	3	// Purpose: SWIG definitions for StatusBar and ToolBar classes
	4	//
	5	// Author: Robin Dunn
	6	//
	7	// Created: 08/24/1998
	8	// RCS-ID: $Id$
	9	// Copyright: (c) 1998 by Total Control Software
	10	// Licence: wxWindows license
	11	/////////////////////////////////////////////////////////////////////////////
	12
	13
	14	%module stattool
	15
	16	%{
	17	#include "helpers.h"
	18	#include <wx/toolbar.h>
	19	#include <wx/tbarsmpl.h>
	20	%}
	21
	22	//----------------------------------------------------------------------
	23
	24	%include typemaps.i
	25	%include my_typemaps.i
	26
	27	// Import some definitions of other classes, etc.
	28	%import _defs.i
	29	%import misc.i
	30	%import windows.i
	31	%import controls.i
	32
	33	%pragma(python) code = "import wx"
	34	%pragma(python) code = "wxITEM_NORMAL = 0 # predeclare this since wx isn't fully imported yet"
	35
	36	//----------------------------------------------------------------------
	37
	38	%{
	39	// Put some wx default wxChar* values into wxStrings.
	40	DECLARE_DEF_STRING(StatusLineNameStr);
	41	DECLARE_DEF_STRING(ToolBarNameStr);
	42	static const wxString wxPyEmptyString(wxT(""));
	43	%}
	44
	45	//---------------------------------------------------------------------------
	46
	47	class wxStatusBar : public wxWindow {
	48	public:
	49	wxStatusBar(wxWindow* parent, wxWindowID id = -1,
	50	long style = wxST_SIZEGRIP,
	51	const wxString& name = wxPyStatusLineNameStr);
	52	%name(wxPreStatusBar)wxStatusBar();
	53
	54	bool Create(wxWindow* parent, wxWindowID id,
	55	long style = wxST_SIZEGRIP,
	56	const wxString& name = wxPyStatusLineNameStr);
	57
	58	%pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
	59	%pragma(python) addtomethod = "wxPreStatusBar:val._setOORInfo(val)"
	60
	61	%addmethods {
	62	%new wxRect* GetFieldRect(long item) {
	63	wxRect* rect= new wxRect;
	64	self->GetFieldRect(item, *rect);
	65	return rect;
	66	}
	67	}
	68	int GetFieldsCount(void);
	69	wxString GetStatusText(int ir = 0);
	70	int GetBorderX();
	71	int GetBorderY();
	72
	73	void SetFieldsCount(int number = 1);
	74	void SetStatusText(const wxString& text, int i = 0);
	75	void SetStatusWidths(int LCOUNT, int* choices);
	76	void PushStatusText(const wxString& text, int number = 0);
	77	void PopStatusText(int number = 0);
	78
	79	void SetMinHeight(int height);
	80	};
	81
	82
	83	//---------------------------------------------------------------------------
	84
	85	class wxToolBarBase;
	86
	87	enum wxToolBarToolStyle
	88	{
	89	wxTOOL_STYLE_BUTTON = 1,
	90	wxTOOL_STYLE_SEPARATOR = 2,
	91	wxTOOL_STYLE_CONTROL
	92	};
	93
	94
	95
	96	class wxToolBarToolBase : public wxObject {
	97	public:
	98	// wxToolBarToolBase(wxToolBarBase tbar = (wxToolBarBase )NULL,
	99	// int id = wxID_SEPARATOR,
	100	// const wxString& label = wxEmptyString,
	101	// const wxBitmap& bmpNormal = wxNullBitmap,
	102	// const wxBitmap& bmpDisabled = wxNullBitmap,
	103	// wxItemKind kind = wxITEM_NORMAL,
	104	// wxObject clientData = (wxObject ) NULL,
	105	// const wxString& shortHelpString = wxEmptyString,
	106	// const wxString& longHelpString = wxEmptyString)
	107	// ~wxToolBarToolBase();
	108
	109	%addmethods { void Destroy() { delete self; } }
	110
	111	int GetId();
	112	wxControl *GetControl();
	113	wxToolBarBase *GetToolBar();
	114	int IsButton();
	115	int IsControl();
	116	int IsSeparator();
	117	int GetStyle();
	118	wxItemKind GetKind();
	119	bool IsEnabled();
	120	bool IsToggled();
	121	bool CanBeToggled();
	122	const wxBitmap& GetNormalBitmap();
	123	const wxBitmap& GetDisabledBitmap();
	124	wxBitmap GetBitmap();
	125	wxString GetLabel();
	126	wxString GetShortHelp();
	127	wxString GetLongHelp();
	128	bool Enable(bool enable);
	129	void Toggle();
	130	bool SetToggle(bool toggle);
	131	bool SetShortHelp(const wxString& help);
	132	bool SetLongHelp(const wxString& help);
	133	void SetNormalBitmap(const wxBitmap& bmp);
	134	void SetDisabledBitmap(const wxBitmap& bmp);
	135	void SetLabel(const wxString& label);
	136	void Detach();
	137	void Attach(wxToolBarBase *tbar);
	138
	139	//wxObject *GetClientData();
	140	%addmethods {
	141	// convert the ClientData back to a PyObject
	142	PyObject* GetClientData() {
	143	wxPyUserData* udata = (wxPyUserData*)self->GetClientData();
	144	if (udata) {
	145	Py_INCREF(udata->m_obj);
	146	return udata->m_obj;
	147	} else {
	148	Py_INCREF(Py_None);
	149	return Py_None;
	150	}
	151	}
	152
	153	void SetClientData(PyObject* clientData) {
	154	self->SetClientData(new wxPyUserData(clientData));
	155	}
	156	}
	157
	158	%pragma(python) addtoclass="
	159	GetBitmap1 = GetNormalBitmap
	160	GetBitmap2 = GetDisabledBitmap
	161	SetBitmap1 = SetNormalBitmap
	162	SetBitmap2 = SetDisabledBitmap
	163	"
	164	};
	165
	166
	167
	168	class wxToolBarBase : public wxControl {
	169	public:
	170
	171	// This is an Abstract Base Class
	172
	173	%addmethods {
	174
	175	// The full AddTool() function. Call it DoAddTool in wxPython and
	176	// implement the other Add methods by calling it.
	177	//
	178	// If bmpDisabled is wxNullBitmap, a shadowed version of the normal bitmap
	179	// is created and used as the disabled image.
	180	wxToolBarToolBase *DoAddTool(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->AddTool(id, label, bitmap, bmpDisabled, kind,
	193	shortHelp, longHelp, udata);
	194	}
	195
	196
	197	// Insert the new tool at the given position, if pos == GetToolsCount(), it
	198	// is equivalent to DoAddTool()
	199	wxToolBarToolBase *DoInsertTool(size_t pos,
	200	int id,
	201	const wxString& label,
	202	const wxBitmap& bitmap,
	203	const wxBitmap& bmpDisabled = wxNullBitmap,
	204	wxItemKind kind = wxITEM_NORMAL,
	205	const wxString& shortHelp = wxPyEmptyString,
	206	const wxString& longHelp = wxPyEmptyString,
	207	PyObject *clientData = NULL)
	208	{
	209	wxPyUserData* udata = NULL;
	210	if (clientData && clientData != Py_None)
	211	udata = new wxPyUserData(clientData);
	212	return self->InsertTool(pos, id, label, bitmap, bmpDisabled, kind,
	213	shortHelp, longHelp, udata);
	214	}
	215
	216	}
	217
	218
	219	%pragma(python) addtoclass = "
	220	# These match the original Add methods for this class, kept for
	221	# backwards compatibility with versions < 2.3.3.
	222
	223
	224	def AddTool(self, id, bitmap,
	225	pushedBitmap = wxNullBitmap,
	226	isToggle = 0,
	227	clientData = None,
	228	shortHelpString = '',
	229	longHelpString = '') :
	230	'''Old style method to add a tool to the toolbar.'''
	231	kind = wx.wxITEM_NORMAL
	232	if isToggle: kind = wx.wxITEM_CHECK
	233	return self.DoAddTool(id, '', bitmap, pushedBitmap, kind,
	234	shortHelpString, longHelpString, clientData)
	235
	236	def AddSimpleTool(self, id, bitmap,
	237	shortHelpString = '',
	238	longHelpString = '',
	239	isToggle = 0):
	240	'''Old style method to add a tool to the toolbar.'''
	241	kind = wx.wxITEM_NORMAL
	242	if isToggle: kind = wx.wxITEM_CHECK
	243	return self.DoAddTool(id, '', bitmap, wxNullBitmap, kind,
	244	shortHelpString, longHelpString, None)
	245
	246	def InsertTool(self, pos, id, bitmap,
	247	pushedBitmap = wxNullBitmap,
	248	isToggle = 0,
	249	clientData = None,
	250	shortHelpString = '',
	251	longHelpString = ''):
	252	'''Old style method to insert a tool in the toolbar.'''
	253	kind = wx.wxITEM_NORMAL
	254	if isToggle: kind = wx.wxITEM_CHECK
	255	return self.DoInsertTool(pos, id, '', bitmap, pushedBitmap, kind,
	256	shortHelpString, longHelpString, clientData)
	257
	258	def InsertSimpleTool(self, pos, id, bitmap,
	259	shortHelpString = '',
	260	longHelpString = '',
	261	isToggle = 0):
	262	'''Old style method to insert a tool in the toolbar.'''
	263	kind = wx.wxITEM_NORMAL
	264	if isToggle: kind = wx.wxITEM_CHECK
	265	return self.DoInsertTool(pos, id, '', bitmap, wxNullBitmap, kind,
	266	shortHelpString, longHelpString, None)
	267
	268
	269	# The following are the new toolbar Add methods starting with
	270	# 2.3.3. They are renamed to have 'Label' in the name so as to be
	271	# able to keep backwards compatibility with using the above
	272	# methods. Eventually these should migrate to be the methods used
	273	# primarily and lose the 'Label' in the name...
	274
	275	def AddLabelTool(self, id, label, bitmap,
	276	bmpDisabled = wxNullBitmap,
	277	kind = wxITEM_NORMAL,
	278	shortHelp = '', longHelp = '',
	279	clientData = None):
	280	'''
	281	The full AddTool() function.
	282
	283	If bmpDisabled is wxNullBitmap, a shadowed version of the normal bitmap
	284	is created and used as the disabled image.
	285	'''
	286	return self.DoAddTool(id, label, bitmap, bmpDisabled, kind,
	287	shortHelp, longHelp, clientData)
	288
	289
	290	def InsertLabelTool(self, pos, id, label, bitmap,
	291	bmpDisabled = wxNullBitmap,
	292	kind = wxITEM_NORMAL,
	293	shortHelp = '', longHelp = '',
	294	clientData = None):
	295	'''
	296	Insert the new tool at the given position, if pos == GetToolsCount(), it
	297	is equivalent to AddTool()
	298	'''
	299	return self.DoInsertTool(pos, id, label, bitmap, bmpDisabled, kind,
	300	shortHelp, longHelp, clientData)
	301
	302	def AddCheckLabelTool(self, id, label, bitmap,
	303	bmpDisabled = wxNullBitmap,
	304	shortHelp = '', longHelp = '',
	305	clientData = None):
	306	'''Add a check tool, i.e. a tool which can be toggled'''
	307	return self.DoAddTool(id, label, bitmap, bmpDisabled, wx.wxITEM_CHECK,
	308	shortHelp, longHelp, clientData)
	309
	310	def AddRadioLabelTool(self, id, label, bitmap,
	311	bmpDisabled = wxNullBitmap,
	312	shortHelp = '', longHelp = '',
	313	clientData = None):
	314	'''
	315	Add a radio tool, i.e. a tool which can be toggled and releases any
	316	other toggled radio tools in the same group when it happens
	317	'''
	318	return self.DoAddTool(id, label, bitmap, bmpDisabled, wx.wxITEM_RADIO,
	319	shortHelp, longHelp, clientData)
	320
	321
	322	# For consistency with the backwards compatible methods above, here are
	323	# some non-'Label' versions of the Check and Radio methods
	324	def AddCheckTool(self, id, bitmap,
	325	bmpDisabled = wxNullBitmap,
	326	shortHelp = '', longHelp = '',
	327	clientData = None):
	328	'''Add a check tool, i.e. a tool which can be toggled'''
	329	return self.DoAddTool(id, '', bitmap, bmpDisabled, wx.wxITEM_CHECK,
	330	shortHelp, longHelp, clientData)
	331
	332	def AddRadioTool(self, id, bitmap,
	333	bmpDisabled = wxNullBitmap,
	334	shortHelp = '', longHelp = '',
	335	clientData = None):
	336	'''
	337	Add a radio tool, i.e. a tool which can be toggled and releases any
	338	other toggled radio tools in the same group when it happens
	339	'''
	340	return self.DoAddTool(id, '', bitmap, bmpDisabled, wx.wxITEM_RADIO,
	341	shortHelp, longHelp, clientData)
	342	"
	343
	344	// TODO?
	345	//wxToolBarToolBase AddTool (wxToolBarToolBase tool);
	346	//wxToolBarToolBase InsertTool (size_t pos, wxToolBarToolBase tool);
	347
	348	wxToolBarToolBase AddControl(wxControl control);
	349	wxToolBarToolBase InsertControl(size_t pos, wxControl control);
	350	wxControl *FindControl( int id );
	351
	352	wxToolBarToolBase *AddSeparator();
	353	wxToolBarToolBase *InsertSeparator(size_t pos);
	354
	355	wxToolBarToolBase *RemoveTool(int id);
	356
	357	bool DeleteToolByPos(size_t pos);
	358	bool DeleteTool(int id);
	359	void ClearTools();
	360	bool Realize();
	361
	362	void EnableTool(int id, bool enable);
	363	void ToggleTool(int id, bool toggle);
	364	void SetToggle(int id, bool toggle);
	365
	366
	367	%addmethods {
	368	// convert the ClientData back to a PyObject
	369	PyObject* GetToolClientData(int id) {
	370	wxPyUserData* udata = (wxPyUserData*)self->GetToolClientData(id);
	371	if (udata) {
	372	Py_INCREF(udata->m_obj);
	373	return udata->m_obj;
	374	} else {
	375	Py_INCREF(Py_None);
	376	return Py_None;
	377	}
	378	}
	379
	380	void SetToolClientData(int id, PyObject* clientData) {
	381	self->SetToolClientData(id, new wxPyUserData(clientData));
	382	}
	383	}
	384
	385
	386	bool GetToolState(int id);
	387	bool GetToolEnabled(int id);
	388	void SetToolShortHelp(int id, const wxString& helpString);
	389	wxString GetToolShortHelp(int id);
	390	void SetToolLongHelp(int id, const wxString& helpString);
	391	wxString GetToolLongHelp(int id);
	392
	393	%name(SetMarginsXY) void SetMargins(int x, int y);
	394	void SetMargins(const wxSize& size);
	395	void SetToolPacking(int packing);
	396	void SetToolSeparation(int separation);
	397	wxSize GetToolMargins();
	398	wxSize GetMargins();
	399	int GetToolPacking();
	400	int GetToolSeparation();
	401
	402	void SetRows(int nRows);
	403	void SetMaxRowsCols(int rows, int cols);
	404	int GetMaxRows();
	405	int GetMaxCols();
	406
	407	void SetToolBitmapSize(const wxSize& size);
	408	wxSize GetToolBitmapSize();
	409	wxSize GetToolSize();
	410
	411	// returns a (non separator) tool containing the point (x, y) or NULL if
	412	// there is no tool at this point (corrdinates are client)
	413	wxToolBarToolBase *FindToolForPosition(wxCoord x, wxCoord y);
	414
	415	// return TRUE if this is a vertical toolbar, otherwise FALSE
	416	bool IsVertical();
	417	};
	418
	419
	420
	421
	422	class wxToolBar : public wxToolBarBase {
	423	public:
	424	wxToolBar(wxWindow *parent,
	425	wxWindowID id,
	426	const wxPoint& pos = wxDefaultPosition,
	427	const wxSize& size = wxDefaultSize,
	428	long style = wxNO_BORDER \| wxTB_HORIZONTAL,
	429	const wxString& name = wxPyToolBarNameStr);
	430	%name(wxPreToolBar)wxToolBar();
	431
	432	bool Create(wxWindow *parent,
	433	wxWindowID id,
	434	const wxPoint& pos = wxDefaultPosition,
	435	const wxSize& size = wxDefaultSize,
	436	long style = wxNO_BORDER \| wxTB_HORIZONTAL,
	437	const wxString& name = wxPyToolBarNameStr);
	438
	439	%pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
	440	%pragma(python) addtomethod = "wxPreToolBar:val._setOORInfo(val)"
	441
	442	wxToolBarToolBase *FindToolForPosition(wxCoord x, wxCoord y);
	443	};
	444
	445
	446
	447
	448	class wxToolBarSimple : public wxToolBarBase {
	449	public:
	450	wxToolBarSimple(wxWindow *parent,
	451	wxWindowID id,
	452	const wxPoint& pos = wxDefaultPosition,
	453	const wxSize& size = wxDefaultSize,
	454	long style = wxNO_BORDER \| wxTB_HORIZONTAL,
	455	const wxString& name = wxPyToolBarNameStr);
	456	%name(wxPreToolBarSimple)wxToolBarSimple();
	457
	458	bool Create(wxWindow *parent,
	459	wxWindowID id,
	460	const wxPoint& pos = wxDefaultPosition,
	461	const wxSize& size = wxDefaultSize,
	462	long style = wxNO_BORDER \| wxTB_HORIZONTAL,
	463	const wxString& name = wxPyToolBarNameStr);
	464
	465	%pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
	466	%pragma(python) addtomethod = "wxPreToolBarSimple:val._setOORInfo(val)"
	467
	468	wxToolBarToolBase *FindToolForPosition(wxCoord x, wxCoord y);
	469	};
	470
	471	//---------------------------------------------------------------------------
	472	//---------------------------------------------------------------------------
	473