[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"


%{
    static wxString wxPyEmptyStr("");
%}

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

class wxStatusBar : public wxWindow {
public:
    wxStatusBar(wxWindow* parent, wxWindowID id,
                const wxPoint& pos = wxDefaultPosition,
                const wxSize& size = wxDefaultSize,
                long style = wxST_SIZEGRIP,
                char* name = "statusBar");
    %name(wxPreStatusBar)wxStatusBar();

    bool Create(wxWindow* parent, wxWindowID id,
                long style = wxST_SIZEGRIP,
                char* name = "statusBar");

    %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"

    %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 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 wxBitmap& bitmap1 = wxNullBitmap,
//                        const wxBitmap& bitmap2 = wxNullBitmap,
//                        bool toggle = FALSE,
//                        wxObject *clientData = (wxObject *) NULL,
//                        const wxString& shortHelpString = wxEmptyString,
//                        const wxString& longHelpString = wxEmptyString);
//      wxToolBarToolBase(wxToolBarBase *tbar, wxControl *control);
//      ~wxToolBarToolBase();

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

    int GetId();
    wxControl *GetControl();
    wxToolBarBase *GetToolBar();
    int IsButton();
    int IsControl();
    int IsSeparator();
    int GetStyle();
    bool IsEnabled();
    bool IsToggled();
    bool CanBeToggled();
    const wxBitmap& GetBitmap1();
    const wxBitmap& GetBitmap2();
    const wxBitmap& GetBitmap();
    wxString GetShortHelp();
    wxString GetLongHelp();
    bool Enable(bool enable);
    bool Toggle(bool toggle);
    bool SetToggle(bool toggle);
    bool SetShortHelp(const wxString& help);
    bool SetLongHelp(const wxString& help);
    void SetBitmap1(const wxBitmap& bmp);
    void SetBitmap2(const wxBitmap& bmp);
    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));
        }
    }
};


class wxToolBarBase : public wxControl {
public:

    // This is an Abstract Base Class

    %addmethods {
        // wrap ClientData in a class that knows about PyObjects
        wxToolBarToolBase *AddTool(int id,
                                   const wxBitmap& bitmap,
                                   const wxBitmap& pushedBitmap = wxNullBitmap,
                                   int isToggle = FALSE,
                                   PyObject *clientData = NULL,
                                   const wxString& shortHelpString = wxPyEmptyStr,
                                   const wxString& longHelpString = wxPyEmptyStr) {
            wxPyUserData* udata = NULL;
            if (clientData)
                udata = new wxPyUserData(clientData);
            return self->AddTool(id, bitmap, pushedBitmap, (bool)isToggle,
                                 udata, shortHelpString, longHelpString);
        }

        // This one is easier to use...
        wxToolBarToolBase *AddSimpleTool(int id,
                                         const wxBitmap& bitmap,
                                         const wxString& shortHelpString = wxPyEmptyStr,
                                         const wxString& longHelpString = wxPyEmptyStr,
                                         int isToggle = FALSE) {
            return self->AddTool(id, bitmap, wxNullBitmap, isToggle, NULL,
                                 shortHelpString, longHelpString);
        }


        // wrap ClientData in a class that knows about PyObjects
        wxToolBarToolBase *InsertTool(size_t pos,
                                      int id,
                                      const wxBitmap& bitmap,
                                      const wxBitmap& pushedBitmap = wxNullBitmap,
                                      int isToggle = FALSE,
                                      PyObject *clientData = NULL,
                                      const wxString& shortHelpString = wxPyEmptyStr,
                                      const wxString& longHelpString = wxPyEmptyStr) {
            wxPyUserData* udata = NULL;
            if (clientData)
                udata = new wxPyUserData(clientData);
            return self->InsertTool(pos, id, bitmap, pushedBitmap, (bool)isToggle,
                                    udata, shortHelpString, longHelpString);
        }

        // This one is easier to use...
        wxToolBarToolBase *InsertSimpleTool(size_t pos,
                                            int id,
                                            const wxBitmap& bitmap,
                                            const wxString& shortHelpString = wxPyEmptyStr,
                                            const wxString& longHelpString = wxPyEmptyStr,
                                            int isToggle = FALSE) {
            return self->InsertTool(pos, id, bitmap, wxNullBitmap, isToggle, NULL,
                                    shortHelpString, longHelpString);
        }
    }


    wxToolBarToolBase *AddControl(wxControl *control);
    wxToolBarToolBase *InsertControl(size_t pos, wxControl *control);

    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 index) {
            wxPyUserData* udata = (wxPyUserData*)self->GetToolClientData(index);
            if (udata) {
                Py_INCREF(udata->m_obj);
                return udata->m_obj;
            } else {
                Py_INCREF(Py_None);
                return Py_None;
            }
        }

        void SetToolClientData(int index, PyObject* clientData) {
            self->SetToolClientData(index, 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();

};


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 char* name = wxToolBarNameStr);
    %name(wxPreToolBar)wxToolBar();

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

    %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"

    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 char* name = wxToolBarNameStr);
    %name(wxPreToolBarSimple)wxToolBarSimple();

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

    %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"

    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"
9c039d08	34
b68dc582 RD	35
	36	%{
	37	static wxString wxPyEmptyStr("");
	38	%}
	39
9c039d08 RD	40	//---------------------------------------------------------------------------
	41
	42	class wxStatusBar : public wxWindow {
	43	public:
	44	wxStatusBar(wxWindow* parent, wxWindowID id,
b68dc582 RD	45	const wxPoint& pos = wxDefaultPosition,
b68dc582 RD	46	const wxSize& size = wxDefaultSize,
9c039d08 RD	47	long style = wxST_SIZEGRIP,
9c039d08 RD	48	char* name = "statusBar");
09f3d4e6 RD	49	%name(wxPreStatusBar)wxStatusBar();
	50
	51	bool Create(wxWindow* parent, wxWindowID id,
	52	long style = wxST_SIZEGRIP,
	53	char* name = "statusBar");
9c039d08	54
f6bcfd97	55	%pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
9c039d08 RD	56
	57	%addmethods {
	58	%new wxRect* GetFieldRect(long item) {
	59	wxRect* rect= new wxRect;
	60	self->GetFieldRect(item, *rect);
	61	return rect;
	62	}
	63	}
	64	int GetFieldsCount(void);
	65	wxString GetStatusText(int ir = 0);
26b9cf27 RD	66	int GetBorderX();
	67	int GetBorderY();
	68
9c039d08 RD	69	void SetFieldsCount(int number = 1);
9c039d08 RD	70	void SetStatusText(const wxString& text, int i = 0);
eec92d76	71	void SetStatusWidths(int LCOUNT, int* choices);
26b9cf27	72	void SetMinHeight(int height);
9c039d08 RD	73	};
	74
	75
	76	//---------------------------------------------------------------------------
	77
9b3d3bc4 RD	78	class wxToolBarBase;
	79
	80	enum wxToolBarToolStyle
	81	{
	82	wxTOOL_STYLE_BUTTON = 1,
	83	wxTOOL_STYLE_SEPARATOR = 2,
	84	wxTOOL_STYLE_CONTROL
	85	};
	86
	87
	88
9416aa89	89	class wxToolBarToolBase : public wxObject {
9b3d3bc4 RD	90	public:
	91	// wxToolBarToolBase(wxToolBarBase tbar = (wxToolBarBase )NULL,
	92	// int id = wxID_SEPARATOR,
	93	// const wxBitmap& bitmap1 = wxNullBitmap,
	94	// const wxBitmap& bitmap2 = wxNullBitmap,
	95	// bool toggle = FALSE,
	96	// wxObject clientData = (wxObject ) NULL,
	97	// const wxString& shortHelpString = wxEmptyString,
	98	// const wxString& longHelpString = wxEmptyString);
	99	// wxToolBarToolBase(wxToolBarBase tbar, wxControl control);
	100	// ~wxToolBarToolBase();
	101
	102	%addmethods { void Destroy() { delete self; } }
	103
	104	int GetId();
	105	wxControl *GetControl();
	106	wxToolBarBase *GetToolBar();
	107	int IsButton();
	108	int IsControl();
	109	int IsSeparator();
	110	int GetStyle();
	111	bool IsEnabled();
	112	bool IsToggled();
	113	bool CanBeToggled();
	114	const wxBitmap& GetBitmap1();
	115	const wxBitmap& GetBitmap2();
	116	const wxBitmap& GetBitmap();
	117	wxString GetShortHelp();
	118	wxString GetLongHelp();
	119	bool Enable(bool enable);
	120	bool Toggle(bool toggle);
	121	bool SetToggle(bool toggle);
	122	bool SetShortHelp(const wxString& help);
	123	bool SetLongHelp(const wxString& help);
	124	void SetBitmap1(const wxBitmap& bmp);
	125	void SetBitmap2(const wxBitmap& bmp);
	126	void Detach();
	127	void Attach(wxToolBarBase *tbar);
	128
	129	//wxObject *GetClientData();
	130	%addmethods {
	131	// convert the ClientData back to a PyObject
	132	PyObject* GetClientData() {
	133	wxPyUserData* udata = (wxPyUserData*)self->GetClientData();
	134	if (udata) {
	135	Py_INCREF(udata->m_obj);
	136	return udata->m_obj;
	137	} else {
	138	Py_INCREF(Py_None);
	139	return Py_None;
	140	}
	141	}
	142
	143	void SetClientData(PyObject* clientData) {
	144	self->SetClientData(new wxPyUserData(clientData));
	145	}
	146	}
	147	};
	148
	149
	150
	151	class wxToolBarBase : public wxControl {
	152	public:
	153
154	// This is an Abstract Base Class
155
156	%addmethods {
157	// wrap ClientData in a class that knows about PyObjects
158	wxToolBarToolBase *AddTool(int id,
159	const wxBitmap& bitmap,
160	const wxBitmap& pushedBitmap = wxNullBitmap,
c368d904	161	int isToggle = FALSE,
9b3d3bc4 RD	162	PyObject *clientData = NULL,
	163	const wxString& shortHelpString = wxPyEmptyStr,
	164	const wxString& longHelpString = wxPyEmptyStr) {
	165	wxPyUserData* udata = NULL;
	166	if (clientData)
	167	udata = new wxPyUserData(clientData);
c368d904	168	return self->AddTool(id, bitmap, pushedBitmap, (bool)isToggle,
9b3d3bc4 RD	169	udata, shortHelpString, longHelpString);
	170	}
	171
	172	// This one is easier to use...
	173	wxToolBarToolBase *AddSimpleTool(int id,
	174	const wxBitmap& bitmap,
	175	const wxString& shortHelpString = wxPyEmptyStr,
	176	const wxString& longHelpString = wxPyEmptyStr,
c368d904 RD	177	int isToggle = FALSE) {
c368d904 RD	178	return self->AddTool(id, bitmap, wxNullBitmap, isToggle, NULL,
9b3d3bc4 RD	179	shortHelpString, longHelpString);
	180	}
	181
	182
	183	// wrap ClientData in a class that knows about PyObjects
	184	wxToolBarToolBase *InsertTool(size_t pos,
	185	int id,
	186	const wxBitmap& bitmap,
	187	const wxBitmap& pushedBitmap = wxNullBitmap,
c368d904	188	int isToggle = FALSE,
9b3d3bc4 RD	189	PyObject *clientData = NULL,
	190	const wxString& shortHelpString = wxPyEmptyStr,
	191	const wxString& longHelpString = wxPyEmptyStr) {
	192	wxPyUserData* udata = NULL;
	193	if (clientData)
	194	udata = new wxPyUserData(clientData);
c368d904	195	return self->InsertTool(pos, id, bitmap, pushedBitmap, (bool)isToggle,
9b3d3bc4 RD	196	udata, shortHelpString, longHelpString);
	197	}
	198
	199	// This one is easier to use...
	200	wxToolBarToolBase *InsertSimpleTool(size_t pos,
	201	int id,
	202	const wxBitmap& bitmap,
	203	const wxString& shortHelpString = wxPyEmptyStr,
	204	const wxString& longHelpString = wxPyEmptyStr,
c368d904 RD	205	int isToggle = FALSE) {
c368d904 RD	206	return self->InsertTool(pos, id, bitmap, wxNullBitmap, isToggle, NULL,
9b3d3bc4 RD	207	shortHelpString, longHelpString);
	208	}
	209	}
	210
	211
	212	wxToolBarToolBase AddControl(wxControl control);
	213	wxToolBarToolBase InsertControl(size_t pos, wxControl control);
	214
	215	wxToolBarToolBase *AddSeparator();
	216	wxToolBarToolBase *InsertSeparator(size_t pos);
	217
	218	wxToolBarToolBase *RemoveTool(int id);
	219
	220	bool DeleteToolByPos(size_t pos);
	221	bool DeleteTool(int id);
	222	void ClearTools();
	223	bool Realize();
	224
	225	void EnableTool(int id, bool enable);
	226	void ToggleTool(int id, bool toggle);
	227	void SetToggle(int id, bool toggle);
	228
	229
	230	%addmethods {
	231	// convert the ClientData back to a PyObject
	232	PyObject* GetToolClientData(int index) {
	233	wxPyUserData* udata = (wxPyUserData*)self->GetToolClientData(index);
	234	if (udata) {
	235	Py_INCREF(udata->m_obj);
	236	return udata->m_obj;
	237	} else {
	238	Py_INCREF(Py_None);
	239	return Py_None;
	240	}
	241	}
	242
	243	void SetToolClientData(int index, PyObject* clientData) {
	244	self->SetToolClientData(index, new wxPyUserData(clientData));
	245	}
	246	}
	247
	248
	249	bool GetToolState(int id);
	250	bool GetToolEnabled(int id);
	251	void SetToolShortHelp(int id, const wxString& helpString);
	252	wxString GetToolShortHelp(int id);
	253	void SetToolLongHelp(int id, const wxString& helpString);
	254	wxString GetToolLongHelp(int id);
	255
	256	%name(SetMarginsXY) void SetMargins(int x, int y);
	257	void SetMargins(const wxSize& size);
	258	void SetToolPacking(int packing);
	259	void SetToolSeparation(int separation);
	260	wxSize GetToolMargins();
83b18bab	261	wxSize GetMargins();
9b3d3bc4 RD	262	int GetToolPacking();
	263	int GetToolSeparation();
	264
	265	void SetRows(int nRows);
	266	void SetMaxRowsCols(int rows, int cols);
	267	int GetMaxRows();
	268	int GetMaxCols();
	269
	270	void SetToolBitmapSize(const wxSize& size);
	271	wxSize GetToolBitmapSize();
	272	wxSize GetToolSize();
	273
	274	};
	275
	276
	277
	278
	279	class wxToolBar : public wxToolBarBase {
	280	public:
	281	wxToolBar(wxWindow *parent,
	282	wxWindowID id,
b68dc582 RD	283	const wxPoint& pos = wxDefaultPosition,
b68dc582 RD	284	const wxSize& size = wxDefaultSize,
9b3d3bc4	285	long style = wxNO_BORDER \| wxTB_HORIZONTAL,
8e425133	286	const char* name = wxToolBarNameStr);
09f3d4e6 RD	287	%name(wxPreToolBar)wxToolBar();
	288
	289	bool Create(wxWindow *parent,
	290	wxWindowID id,
	291	const wxPoint& pos = wxDefaultPosition,
	292	const wxSize& size = wxDefaultSize,
	293	long style = wxNO_BORDER \| wxTB_HORIZONTAL,
	294	const char* name = wxToolBarNameStr);
9b3d3bc4	295
f6bcfd97	296	%pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
9b3d3bc4 RD	297
	298	wxToolBarToolBase *FindToolForPosition(wxCoord x, wxCoord y);
	299	};
	300
	301
	302
	303
	304	class wxToolBarSimple : public wxToolBarBase {
	305	public:
	306	wxToolBarSimple(wxWindow *parent,
	307	wxWindowID id,
b68dc582 RD	308	const wxPoint& pos = wxDefaultPosition,
b68dc582 RD	309	const wxSize& size = wxDefaultSize,
9b3d3bc4	310	long style = wxNO_BORDER \| wxTB_HORIZONTAL,
8e425133	311	const char* name = wxToolBarNameStr);
09f3d4e6 RD	312	%name(wxPreToolBarSimple)wxToolBarSimple();
	313
	314	bool Create(wxWindow *parent,
	315	wxWindowID id,
	316	const wxPoint& pos = wxDefaultPosition,
	317	const wxSize& size = wxDefaultSize,
	318	long style = wxNO_BORDER \| wxTB_HORIZONTAL,
	319	const char* name = wxToolBarNameStr);
9b3d3bc4	320
f6bcfd97	321	%pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
9b3d3bc4 RD	322
	323	wxToolBarToolBase *FindToolForPosition(wxCoord x, wxCoord y);
	324	};
	325
	326	//---------------------------------------------------------------------------
9c039d08 RD	327	//---------------------------------------------------------------------------
9c039d08 RD	328