[wxWidgets.git] / 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
9c039d08 RD	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
b8b8dda7	33	%pragma(python) code = "import wx"
15030c51	34	%pragma(python) code = "wxITEM_NORMAL = 0 # predeclare this since wx isn't fully imported yet"
b68dc582	35
137b5242 RD	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
9c039d08 RD	45	//---------------------------------------------------------------------------
	46
	47	class wxStatusBar : public wxWindow {
	48	public:
99f7d340	49	wxStatusBar(wxWindow* parent, wxWindowID id = -1,
9c039d08	50	long style = wxST_SIZEGRIP,
137b5242	51	const wxString& name = wxPyStatusLineNameStr);
09f3d4e6 RD	52	%name(wxPreStatusBar)wxStatusBar();
	53
	54	bool Create(wxWindow* parent, wxWindowID id,
	55	long style = wxST_SIZEGRIP,
137b5242	56	const wxString& name = wxPyStatusLineNameStr);
9c039d08	57
0122b7e3	58	%pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
17c0e08c	59	%pragma(python) addtomethod = "wxPreStatusBar:val._setOORInfo(val)"
9c039d08 RD	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);
26b9cf27 RD	70	int GetBorderX();
	71	int GetBorderY();
	72
9c039d08 RD	73	void SetFieldsCount(int number = 1);
9c039d08 RD	74	void SetStatusText(const wxString& text, int i = 0);
eec92d76	75	void SetStatusWidths(int LCOUNT, int* choices);
94e36a51 RD	76	void PushStatusText(const wxString& text, int number = 0);
	77	void PopStatusText(int number = 0);
	78
26b9cf27	79	void SetMinHeight(int height);
9c039d08 RD	80	};
	81
	82
	83	//---------------------------------------------------------------------------
	84
9b3d3bc4 RD	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
9416aa89	96	class wxToolBarToolBase : public wxObject {
9b3d3bc4 RD	97	public:
	98	// wxToolBarToolBase(wxToolBarBase tbar = (wxToolBarBase )NULL,
	99	// int id = wxID_SEPARATOR,
b96c7a38 RD	100	// const wxString& label = wxEmptyString,
	101	// const wxBitmap& bmpNormal = wxNullBitmap,
	102	// const wxBitmap& bmpDisabled = wxNullBitmap,
	103	// wxItemKind kind = wxITEM_NORMAL,
9b3d3bc4	104	// wxObject clientData = (wxObject ) NULL,
b96c7a38 RD	105	// const wxString& shortHelpString = wxEmptyString,
b96c7a38 RD	106	// const wxString& longHelpString = wxEmptyString)
9b3d3bc4 RD	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();
b96c7a38	118	wxItemKind GetKind();
9b3d3bc4 RD	119	bool IsEnabled();
	120	bool IsToggled();
	121	bool CanBeToggled();
c6ebc32a RD	122	const wxBitmap& GetNormalBitmap();
c6ebc32a RD	123	const wxBitmap& GetDisabledBitmap();
c5943253	124	wxBitmap GetBitmap();
c6ebc32a	125	wxString GetLabel();
9b3d3bc4 RD	126	wxString GetShortHelp();
	127	wxString GetLongHelp();
	128	bool Enable(bool enable);
c6ebc32a	129	void Toggle();
9b3d3bc4 RD	130	bool SetToggle(bool toggle);
	131	bool SetShortHelp(const wxString& help);
	132	bool SetLongHelp(const wxString& help);
c6ebc32a RD	133	void SetNormalBitmap(const wxBitmap& bmp);
	134	void SetDisabledBitmap(const wxBitmap& bmp);
	135	void SetLabel(const wxString& label);
9b3d3bc4 RD	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	}
c6ebc32a RD	157
	158	%pragma(python) addtoclass="
	159	GetBitmap1 = GetNormalBitmap
	160	GetBitmap2 = GetDisabledBitmap
	161	SetBitmap1 = SetNormalBitmap
	162	SetBitmap2 = SetDisabledBitmap
	163	"
9b3d3bc4 RD	164	};
	165
	166
	167
	168	class wxToolBarBase : public wxControl {
	169	public:
	170
	171	// This is an Abstract Base Class
	172
	173	%addmethods {
b96c7a38	174
15030c51 RD	175	// The full AddTool() function. Call it DoAddTool in wxPython and
15030c51 RD	176	// implement the other Add methods by calling it.
b96c7a38 RD	177	//
	178	// If bmpDisabled is wxNullBitmap, a shadowed version of the normal bitmap
	179	// is created and used as the disabled image.
15030c51 RD	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)
b96c7a38	188	{
9b3d3bc4	189	wxPyUserData* udata = NULL;
15030c51	190	if (clientData && clientData != Py_None)
9b3d3bc4	191	udata = new wxPyUserData(clientData);
b96c7a38 RD	192	return self->AddTool(id, label, bitmap, bmpDisabled, kind,
b96c7a38 RD	193	shortHelp, longHelp, udata);
9b3d3bc4 RD	194	}
9b3d3bc4 RD	195
9b3d3bc4	196
15030c51 RD	197	// Insert the new tool at the given position, if pos == GetToolsCount(), it
15030c51 RD	198	// is equivalent to DoAddTool()
1e4a197e	199	wxToolBarToolBase *DoInsertTool(size_t pos,
9b3d3bc4	200	int id,
b96c7a38	201	const wxString& label,
9b3d3bc4	202	const wxBitmap& bitmap,
b96c7a38 RD	203	const wxBitmap& bmpDisabled = wxNullBitmap,
b96c7a38 RD	204	wxItemKind kind = wxITEM_NORMAL,
c12de7f8 RD	205	const wxString& shortHelp = wxPyEmptyString,
c12de7f8 RD	206	const wxString& longHelp = wxPyEmptyString,
b96c7a38 RD	207	PyObject *clientData = NULL)
b96c7a38 RD	208	{
9b3d3bc4	209	wxPyUserData* udata = NULL;
15030c51	210	if (clientData && clientData != Py_None)
9b3d3bc4	211	udata = new wxPyUserData(clientData);
b96c7a38 RD	212	return self->InsertTool(pos, id, label, bitmap, bmpDisabled, kind,
b96c7a38 RD	213	shortHelp, longHelp, udata);
9b3d3bc4 RD	214	}
9b3d3bc4 RD	215
9b3d3bc4 RD	216	}
	217
	218
15030c51 RD	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
1e4a197e	273	# primarily and lose the 'Label' in the name...
15030c51 RD	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
9cbf6f6e RD	344	// TODO?
	345	//wxToolBarToolBase AddTool (wxToolBarToolBase tool);
	346	//wxToolBarToolBase InsertTool (size_t pos, wxToolBarToolBase tool);
15030c51	347
9b3d3bc4 RD	348	wxToolBarToolBase AddControl(wxControl control);
9b3d3bc4 RD	349	wxToolBarToolBase InsertControl(size_t pos, wxControl control);
fe953afb	350	wxControl *FindControl( int id );
9b3d3bc4 RD	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
c6ebc32a RD	369	PyObject* GetToolClientData(int id) {
c6ebc32a RD	370	wxPyUserData* udata = (wxPyUserData*)self->GetToolClientData(id);
9b3d3bc4 RD	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
c6ebc32a RD	380	void SetToolClientData(int id, PyObject* clientData) {
c6ebc32a RD	381	self->SetToolClientData(id, new wxPyUserData(clientData));
9b3d3bc4 RD	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();
83b18bab	398	wxSize GetMargins();
9b3d3bc4 RD	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
c6ebc32a RD	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();
9b3d3bc4 RD	417	};
	418
	419
	420
	421
	422	class wxToolBar : public wxToolBarBase {
	423	public:
	424	wxToolBar(wxWindow *parent,
	425	wxWindowID id,
b68dc582 RD	426	const wxPoint& pos = wxDefaultPosition,
b68dc582 RD	427	const wxSize& size = wxDefaultSize,
9b3d3bc4	428	long style = wxNO_BORDER \| wxTB_HORIZONTAL,
137b5242	429	const wxString& name = wxPyToolBarNameStr);
09f3d4e6 RD	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,
137b5242	437	const wxString& name = wxPyToolBarNameStr);
9b3d3bc4	438
0122b7e3	439	%pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
17c0e08c	440	%pragma(python) addtomethod = "wxPreToolBar:val._setOORInfo(val)"
9b3d3bc4 RD	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,
b68dc582 RD	452	const wxPoint& pos = wxDefaultPosition,
b68dc582 RD	453	const wxSize& size = wxDefaultSize,
9b3d3bc4	454	long style = wxNO_BORDER \| wxTB_HORIZONTAL,
137b5242	455	const wxString& name = wxPyToolBarNameStr);
09f3d4e6 RD	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,
137b5242	463	const wxString& name = wxPyToolBarNameStr);
9b3d3bc4	464
0122b7e3	465	%pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
17c0e08c	466	%pragma(python) addtomethod = "wxPreToolBarSimple:val._setOORInfo(val)"
9b3d3bc4 RD	467
	468	wxToolBarToolBase *FindToolForPosition(wxCoord x, wxCoord y);
	469	};
	470
	471	//---------------------------------------------------------------------------
9c039d08 RD	472	//---------------------------------------------------------------------------
9c039d08 RD	473