[wxWidgets.git] / wxPython / src / sizers.i

/////////////////////////////////////////////////////////////////////////////
// Name:        sizers.i
// Purpose:     SWIG definitions of the wxSizer family of classes
//
// Author:      Robin Dunn
//
// Created:     18-Sept-1999
// RCS-ID:      $Id$
// Copyright:   (c) 1999 by Total Control Software
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////

%module sizers

%{
#include "helpers.h"

#include <wx/notebook.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 = "import string"

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


class wxSizerItem : public wxObject {
public:
    // No need to ever create one directly in Python...

    //wxSizerItem( int width, int height, int option, int flag, int border, wxObject* userData);
    //wxSizerItem( wxWindow *window, int option, int flag, int border, wxObject* userData );
    //wxSizerItem( wxSizer *sizer, int option, int flag, int border, wxObject* userData );

    wxPoint GetPosition();
    wxSize GetSize();
    wxSize CalcMin();
    void SetDimension( wxPoint pos, wxSize size );
    %name(SetRatioWH) void SetRatio( int width, int height );
    %name(SetRatioSize) void SetRatio( wxSize size );
    void SetRatio( float ratio );
    float GetRatio();

    bool IsWindow();
    bool IsSizer();
    bool IsSpacer();

    wxWindow *GetWindow();
    void SetWindow( wxWindow *window );
    wxSizer *GetSizer();
    void SetSizer( wxSizer *sizer );
    int GetOption();
    int GetFlag();
    int GetBorder();

    void SetInitSize( int x, int y );
    void SetOption( int option );
    void SetFlag( int flag );
    void SetBorder( int border );

    // wxObject* GetUserData();
    %addmethods {
        // Assume that the user data is a wxPyUserData object and return the contents
        PyObject* GetUserData() {
            wxPyUserData* data = (wxPyUserData*)self->GetUserData();
            if (data) {
                Py_INCREF(data->m_obj);
                return data->m_obj;
            } else {
                Py_INCREF(Py_None);
                return Py_None;
            }
        }
    }
};


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

class wxSizer : public wxObject {
public:
    // wxSizer();      ****  abstract, can't instantiate
    // ~wxSizer();

    %addmethods {
        void _setOORInfo(PyObject* _self) {
            self->SetClientObject(new wxPyClientData(_self));
        }
    }

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

        void AddWindow(wxWindow *window, int option=0, int flag=0, int border=0,
                       PyObject* userData=NULL) {
            wxPyUserData* data = NULL;
            if (userData) data = new wxPyUserData(userData);
            self->Add(window, option, flag, border, data);
        }
        void AddSizer(wxSizer *sizer, int option=0, int flag=0, int border=0,
                      PyObject* userData=NULL) {
            wxPyUserData* data = NULL;
            if (userData) data = new wxPyUserData(userData);
            self->Add(sizer, option, flag, border, data);
        }
        void AddSpacer(int width, int height, int option=0, int flag=0,
                       int border=0, PyObject* userData=NULL) {
            wxPyUserData* data = NULL;
            if (userData) data = new wxPyUserData(userData);
            self->Add(width, height, option, flag, border, data);
        }


        void InsertWindow(int before, wxWindow *window, int option=0, int flag=0,
                          int border=0, PyObject* userData=NULL) {
            wxPyUserData* data = NULL;
            if (userData) data = new wxPyUserData(userData);
            self->Insert(before, window, option, flag, border, data);
        }
        void InsertSizer(int before, wxSizer *sizer, int option=0, int flag=0,
                         int border=0, PyObject* userData=NULL) {
            wxPyUserData* data = NULL;
            if (userData) data = new wxPyUserData(userData);
            self->Insert(before, sizer, option, flag, border, data);
        }
        void InsertSpacer(int before, int width, int height, int option=0, int flag=0,
                          int border=0, PyObject* userData=NULL) {
            wxPyUserData* data = NULL;
            if (userData) data = new wxPyUserData(userData);
            self->Insert(before, width, height, option, flag, border, data);
        }


        void PrependWindow(wxWindow *window, int option=0, int flag=0, int border=0,
                           PyObject* userData=NULL) {
            wxPyUserData* data = NULL;
            if (userData) data = new wxPyUserData(userData);
            self->Prepend(window, option, flag, border, data);
        }
        void PrependSizer(wxSizer *sizer, int option=0, int flag=0, int border=0,
                          PyObject* userData=NULL) {
            wxPyUserData* data = NULL;
            if (userData) data = new wxPyUserData(userData);
            self->Prepend(sizer, option, flag, border, data);
        }
        void PrependSpacer(int width, int height, int option=0, int flag=0,
                           int border=0, PyObject* userData=NULL) {
            wxPyUserData* data = NULL;
            if (userData) data = new wxPyUserData(userData);
            self->Prepend(width, height, option, flag, border, data);
        }
    }

    %name(RemoveWindow)bool Remove( wxWindow *window );
    %name(RemoveSizer)bool Remove( wxSizer *sizer );
    %name(RemovePos)bool Remove( int pos );


    %pragma(python) addtoclass = "
    def Add(self, *args, **kw):
        if type(args[0]) == type(1):
            apply(self.AddSpacer, args, kw)
        elif string.find(args[0].this, 'Sizer') != -1:
            apply(self.AddSizer, args, kw)
        else:
            apply(self.AddWindow, args, kw)

    def Insert(self, *args, **kw):
        if type(args[1]) == type(1):
            apply(self.InsertSpacer, args, kw)
        elif string.find(args[1].this, 'Sizer') != -1:
            apply(self.InsertSizer, args, kw)
        else:
            apply(self.InsertWindow, args, kw)

    def Prepend(self, *args, **kw):
        if type(args[0]) == type(1):
            apply(self.PrependSpacer, args, kw)
        elif string.find(args[0].this, 'Sizer') != -1:
            apply(self.PrependSizer, args, kw)
        else:
            apply(self.PrependWindow, args, kw)

    def Remove(self, *args, **kw):
        if type(args[0]) == type(1):
            apply(self.RemovePos, args, kw)
        elif string.find(args[0].this, 'Sizer') != -1:
            apply(self.RemoveSizer, args, kw)
        else:
            apply(self.RemoveWindow, args, kw)

    def AddMany(self, widgets):
        for childinfo in widgets:
            if type(childinfo) != type(()):
                childinfo = (childinfo, )
            apply(self.Add, childinfo)
"


    void SetDimension( int x, int y, int width, int height );
    void SetMinSize(wxSize size);

    %name(SetItemMinSizeWindow) void SetItemMinSize(wxWindow* window, int width, int height);
    %name(SetItemMinSizeSizer) void SetItemMinSize(wxSizer* sizer, int width, int height);
    %name(SetItemMinSizePos) void SetItemMinSize(int pos, int width, int height);

    %pragma(python) addtoclass = "
    def SetItemMinSize(self, *args):
        if type(args[0]) == type(1):
            apply(self.SetItemMinSizePos, args)
        elif string.find(args[0].this, 'Sizer') != -1:
            apply(self.SetItemMinSizeSizer, args)
        else:
            apply(self.SetItemMinSizeWindow, args)
     "

    wxSize GetSize();
    wxPoint GetPosition();
    wxSize GetMinSize();

    // void RecalcSizes() = 0;
    // wxSize CalcMin() = 0;

    void Layout();

    void Fit( wxWindow *window );
    void SetSizeHints( wxWindow *window );

    // wxList& GetChildren();
    %addmethods {
        PyObject* GetChildren() {
            wxList& list = self->GetChildren();
            return wxPy_ConvertList(&list, "wxSizerItem");
        }
    }
};


//---------------------------------------------------------------------------
// Use this one for deriving Python classes from
%{
class wxPySizer : public wxSizer {
    DECLARE_DYNAMIC_CLASS(wxPySizer);
public:
    wxPySizer() : wxSizer() {};

    DEC_PYCALLBACK___pure(RecalcSizes);
    DEC_PYCALLBACK_wxSize__pure(CalcMin);
    PYPRIVATE;
};


IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);

IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
%}


class wxPySizer : public wxSizer {
public:
    wxPySizer();
    void _setCallbackInfo(PyObject* self, PyObject* _class);
    %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxPySizer)"
    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
};


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

class  wxBoxSizer : public wxSizer {
public:
    wxBoxSizer(int orient = wxHORIZONTAL);
    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
    int GetOrientation();
    void RecalcSizes();
    wxSize CalcMin();
};

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

class  wxStaticBoxSizer : public wxBoxSizer {
public:
    wxStaticBoxSizer(wxStaticBox *box, int orient = wxHORIZONTAL);
    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
    wxStaticBox *GetStaticBox();
    void RecalcSizes();
    wxSize CalcMin();
};

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

class wxNotebookSizer: public wxSizer {
public:
    wxNotebookSizer( wxNotebook *nb );
    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
    void RecalcSizes();
    wxSize CalcMin();
    wxNotebook *GetNotebook();
};

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

class wxGridSizer: public wxSizer
{
public:
    wxGridSizer( int rows=1, int cols=0, int vgap=0, int hgap=0 );
    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"

    void RecalcSizes();
    wxSize CalcMin();

    void SetCols( int cols );
    void SetRows( int rows );
    void SetVGap( int gap );
    void SetHGap( int gap );
    int GetCols();
    int GetRows();
    int GetVGap();
    int GetHGap();
};

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

class wxFlexGridSizer: public wxGridSizer
{
public:
    wxFlexGridSizer( int rows=1, int cols=0, int vgap=0, int hgap=0 );
    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"

    void RecalcSizes();
    wxSize CalcMin();

    void AddGrowableRow( size_t idx );
    void RemoveGrowableRow( size_t idx );
    void AddGrowableCol( size_t idx );
    void RemoveGrowableCol( size_t idx );

};

//---------------------------------------------------------------------------
Commit	Line	Data
2f90df85 RD	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: sizers.i
	3	// Purpose: SWIG definitions of the wxSizer family of classes
	4	//
	5	// Author: Robin Dunn
	6	//
	7	// Created: 18-Sept-1999
	8	// RCS-ID: $Id$
f0261a72	9	// Copyright: (c) 1999 by Total Control Software
2f90df85 RD	10	// Licence: wxWindows license
	11	/////////////////////////////////////////////////////////////////////////////
	12
	13	%module sizers
	14
	15	%{
	16	#include "helpers.h"
9416aa89 RD	17
9416aa89 RD	18	#include <wx/notebook.h>
2f90df85 RD	19	%}
	20
	21	//----------------------------------------------------------------------
	22
	23	%include typemaps.i
	24	%include my_typemaps.i
	25
	26	// Import some definitions of other classes, etc.
	27	%import _defs.i
	28	%import misc.i
	29	%import windows.i
	30	%import controls.i
	31
	32	%pragma(python) code = "import wx"
	33	%pragma(python) code = "import string"
	34
	35	//---------------------------------------------------------------------------
	36
2f90df85	37
9416aa89	38	class wxSizerItem : public wxObject {
2f90df85 RD	39	public:
	40	// No need to ever create one directly in Python...
	41
	42	//wxSizerItem( int width, int height, int option, int flag, int border, wxObject* userData);
	43	//wxSizerItem( wxWindow window, int option, int flag, int border, wxObject userData );
	44	//wxSizerItem( wxSizer sizer, int option, int flag, int border, wxObject userData );
	45
09f3d4e6	46	wxPoint GetPosition();
2f90df85 RD	47	wxSize GetSize();
	48	wxSize CalcMin();
	49	void SetDimension( wxPoint pos, wxSize size );
f6bcfd97 BP	50	%name(SetRatioWH) void SetRatio( int width, int height );
	51	%name(SetRatioSize) void SetRatio( wxSize size );
	52	void SetRatio( float ratio );
	53	float GetRatio();
2f90df85 RD	54
	55	bool IsWindow();
	56	bool IsSizer();
	57	bool IsSpacer();
	58
	59	wxWindow *GetWindow();
f6bcfd97	60	void SetWindow( wxWindow *window );
2f90df85	61	wxSizer *GetSizer();
f6bcfd97	62	void SetSizer( wxSizer *sizer );
2f90df85 RD	63	int GetOption();
	64	int GetFlag();
	65	int GetBorder();
	66
9b3d3bc4 RD	67	void SetInitSize( int x, int y );
	68	void SetOption( int option );
	69	void SetFlag( int flag );
	70	void SetBorder( int border );
	71
2f90df85 RD	72	// wxObject* GetUserData();
	73	%addmethods {
	74	// Assume that the user data is a wxPyUserData object and return the contents
	75	PyObject* GetUserData() {
	76	wxPyUserData* data = (wxPyUserData*)self->GetUserData();
	77	if (data) {
	78	Py_INCREF(data->m_obj);
	79	return data->m_obj;
	80	} else {
	81	Py_INCREF(Py_None);
	82	return Py_None;
	83	}
	84	}
	85	}
	86	};
	87
	88
	89	//---------------------------------------------------------------------------
	90
9416aa89	91	class wxSizer : public wxObject {
2f90df85 RD	92	public:
	93	// wxSizer(); **** abstract, can't instantiate
	94	// ~wxSizer();
	95
2aab8f16 RD	96	%addmethods {
	97	void _setOORInfo(PyObject* _self) {
	98	self->SetClientObject(new wxPyClientData(_self));
	99	}
	100	}
	101
2f90df85 RD	102	%addmethods {
	103	void Destroy() { delete self; }
	104
	105	void AddWindow(wxWindow *window, int option=0, int flag=0, int border=0,
	106	PyObject* userData=NULL) {
	107	wxPyUserData* data = NULL;
	108	if (userData) data = new wxPyUserData(userData);
	109	self->Add(window, option, flag, border, data);
	110	}
2f90df85 RD	111	void AddSizer(wxSizer *sizer, int option=0, int flag=0, int border=0,
	112	PyObject* userData=NULL) {
	113	wxPyUserData* data = NULL;
	114	if (userData) data = new wxPyUserData(userData);
	115	self->Add(sizer, option, flag, border, data);
	116	}
2f90df85 RD	117	void AddSpacer(int width, int height, int option=0, int flag=0,
	118	int border=0, PyObject* userData=NULL) {
	119	wxPyUserData* data = NULL;
	120	if (userData) data = new wxPyUserData(userData);
	121	self->Add(width, height, option, flag, border, data);
	122	}
	123
	124
f6bcfd97 BP	125	void InsertWindow(int before, wxWindow *window, int option=0, int flag=0,
	126	int border=0, PyObject* userData=NULL) {
	127	wxPyUserData* data = NULL;
	128	if (userData) data = new wxPyUserData(userData);
	129	self->Insert(before, window, option, flag, border, data);
	130	}
	131	void InsertSizer(int before, wxSizer *sizer, int option=0, int flag=0,
	132	int border=0, PyObject* userData=NULL) {
	133	wxPyUserData* data = NULL;
	134	if (userData) data = new wxPyUserData(userData);
	135	self->Insert(before, sizer, option, flag, border, data);
	136	}
	137	void InsertSpacer(int before, int width, int height, int option=0, int flag=0,
	138	int border=0, PyObject* userData=NULL) {
	139	wxPyUserData* data = NULL;
	140	if (userData) data = new wxPyUserData(userData);
	141	self->Insert(before, width, height, option, flag, border, data);
	142	}
	143
	144
2f90df85 RD	145	void PrependWindow(wxWindow *window, int option=0, int flag=0, int border=0,
	146	PyObject* userData=NULL) {
	147	wxPyUserData* data = NULL;
	148	if (userData) data = new wxPyUserData(userData);
	149	self->Prepend(window, option, flag, border, data);
	150	}
2f90df85 RD	151	void PrependSizer(wxSizer *sizer, int option=0, int flag=0, int border=0,
	152	PyObject* userData=NULL) {
	153	wxPyUserData* data = NULL;
	154	if (userData) data = new wxPyUserData(userData);
	155	self->Prepend(sizer, option, flag, border, data);
	156	}
2f90df85 RD	157	void PrependSpacer(int width, int height, int option=0, int flag=0,
	158	int border=0, PyObject* userData=NULL) {
	159	wxPyUserData* data = NULL;
	160	if (userData) data = new wxPyUserData(userData);
	161	self->Prepend(width, height, option, flag, border, data);
	162	}
	163	}
	164
	165	%name(RemoveWindow)bool Remove( wxWindow *window );
	166	%name(RemoveSizer)bool Remove( wxSizer *sizer );
	167	%name(RemovePos)bool Remove( int pos );
	168
	169
	170	%pragma(python) addtoclass = "
d1679124	171	def Add(self, args, *kw):
2f90df85	172	if type(args[0]) == type(1):
d1679124	173	apply(self.AddSpacer, args, kw)
2f90df85	174	elif string.find(args[0].this, 'Sizer') != -1:
d1679124	175	apply(self.AddSizer, args, kw)
2f90df85	176	else:
d1679124	177	apply(self.AddWindow, args, kw)
2f90df85	178
d1679124	179	def Insert(self, args, *kw):
c368d904	180	if type(args[1]) == type(1):
d1679124	181	apply(self.InsertSpacer, args, kw)
c368d904	182	elif string.find(args[1].this, 'Sizer') != -1:
d1679124	183	apply(self.InsertSizer, args, kw)
f6bcfd97	184	else:
d1679124	185	apply(self.InsertWindow, args, kw)
f6bcfd97	186
d1679124	187	def Prepend(self, args, *kw):
2f90df85	188	if type(args[0]) == type(1):
d1679124	189	apply(self.PrependSpacer, args, kw)
2f90df85	190	elif string.find(args[0].this, 'Sizer') != -1:
d1679124	191	apply(self.PrependSizer, args, kw)
2f90df85	192	else:
d1679124	193	apply(self.PrependWindow, args, kw)
2f90df85	194
d1679124	195	def Remove(self, args, *kw):
2f90df85	196	if type(args[0]) == type(1):
d1679124	197	apply(self.RemovePos, args, kw)
2f90df85	198	elif string.find(args[0].this, 'Sizer') != -1:
d1679124	199	apply(self.RemoveSizer, args, kw)
2f90df85	200	else:
d1679124	201	apply(self.RemoveWindow, args, kw)
2f90df85 RD	202
	203	def AddMany(self, widgets):
	204	for childinfo in widgets:
	205	if type(childinfo) != type(()):
	206	childinfo = (childinfo, )
	207	apply(self.Add, childinfo)
	208	"
	209
	210
	211	void SetDimension( int x, int y, int width, int height );
f6bcfd97 BP	212	void SetMinSize(wxSize size);
	213
	214	%name(SetItemMinSizeWindow) void SetItemMinSize(wxWindow* window, int width, int height);
	215	%name(SetItemMinSizeSizer) void SetItemMinSize(wxSizer* sizer, int width, int height);
	216	%name(SetItemMinSizePos) void SetItemMinSize(int pos, int width, int height);
	217
	218	%pragma(python) addtoclass = "
	219	def SetItemMinSize(self, *args):
	220	if type(args[0]) == type(1):
	221	apply(self.SetItemMinSizePos, args)
	222	elif string.find(args[0].this, 'Sizer') != -1:
	223	apply(self.SetItemMinSizeSizer, args)
	224	else:
	225	apply(self.SetItemMinSizeWindow, args)
	226	"
2f90df85 RD	227
	228	wxSize GetSize();
	229	wxPoint GetPosition();
	230	wxSize GetMinSize();
	231
	232	// void RecalcSizes() = 0;
	233	// wxSize CalcMin() = 0;
	234
	235	void Layout();
	236
	237	void Fit( wxWindow *window );
	238	void SetSizeHints( wxWindow *window );
	239
	240	// wxList& GetChildren();
	241	%addmethods {
	242	PyObject* GetChildren() {
	243	wxList& list = self->GetChildren();
	244	return wxPy_ConvertList(&list, "wxSizerItem");
	245	}
	246	}
	247	};
	248
	249
	250	//---------------------------------------------------------------------------
	251	// Use this one for deriving Python classes from
	252	%{
	253	class wxPySizer : public wxSizer {
	254	DECLARE_DYNAMIC_CLASS(wxPySizer);
	255	public:
	256	wxPySizer() : wxSizer() {};
	257
	258	DEC_PYCALLBACK___pure(RecalcSizes);
	259	DEC_PYCALLBACK_wxSize__pure(CalcMin);
	260	PYPRIVATE;
	261	};
	262
	263
	264	IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
	265	IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
	266
	267	IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
	268	%}
	269
	270
	271
	272	class wxPySizer : public wxSizer {
	273	public:
	274	wxPySizer();
0122b7e3 RD	275	void _setCallbackInfo(PyObject* self, PyObject* _class);
0122b7e3 RD	276	%pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxPySizer)"
2aab8f16	277	%pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
2f90df85 RD	278	};
	279
	280
	281	//---------------------------------------------------------------------------
	282
	283	class wxBoxSizer : public wxSizer {
	284	public:
	285	wxBoxSizer(int orient = wxHORIZONTAL);
2aab8f16	286	%pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
2f90df85	287	int GetOrientation();
f6bcfd97 BP	288	void RecalcSizes();
f6bcfd97 BP	289	wxSize CalcMin();
2f90df85 RD	290	};
	291
	292	//---------------------------------------------------------------------------
	293
	294	class wxStaticBoxSizer : public wxBoxSizer {
	295	public:
	296	wxStaticBoxSizer(wxStaticBox *box, int orient = wxHORIZONTAL);
2aab8f16	297	%pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
2f90df85	298	wxStaticBox *GetStaticBox();
f6bcfd97 BP	299	void RecalcSizes();
	300	wxSize CalcMin();
	301	};
	302
	303	//---------------------------------------------------------------------------
	304
	305	class wxNotebookSizer: public wxSizer {
	306	public:
	307	wxNotebookSizer( wxNotebook *nb );
2aab8f16	308	%pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
f6bcfd97 BP	309	void RecalcSizes();
f6bcfd97 BP	310	wxSize CalcMin();
f6bcfd97 BP	311	wxNotebook *GetNotebook();
	312	};
	313
	314	//---------------------------------------------------------------------------
	315
	316	class wxGridSizer: public wxSizer
	317	{
	318	public:
	319	wxGridSizer( int rows=1, int cols=0, int vgap=0, int hgap=0 );
2aab8f16	320	%pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
f6bcfd97 BP	321
	322	void RecalcSizes();
	323	wxSize CalcMin();
	324
	325	void SetCols( int cols );
	326	void SetRows( int rows );
	327	void SetVGap( int gap );
	328	void SetHGap( int gap );
	329	int GetCols();
	330	int GetRows();
	331	int GetVGap();
	332	int GetHGap();
	333	};
	334
	335	//---------------------------------------------------------------------------
	336
	337	class wxFlexGridSizer: public wxGridSizer
	338	{
	339	public:
	340	wxFlexGridSizer( int rows=1, int cols=0, int vgap=0, int hgap=0 );
2aab8f16	341	%pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
f6bcfd97 BP	342
	343	void RecalcSizes();
	344	wxSize CalcMin();
	345
	346	void AddGrowableRow( size_t idx );
	347	void RemoveGrowableRow( size_t idx );
	348	void AddGrowableCol( size_t idx );
	349	void RemoveGrowableCol( size_t idx );
	350
2f90df85 RD	351	};
	352
	353	//---------------------------------------------------------------------------