wxPython/src/_sizers.i

/////////////////////////////////////////////////////////////////////////////
// Name:        _sizers.i
// Purpose:     SWIG interface defs for the Sizers
//
// Author:      Robin Dunn
//
// Created:     18-Sept-1999
// RCS-ID:      $Id$
// Copyright:   (c) 2003 by Total Control Software
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////

// Not a %module


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

%{
%}

//---------------------------------------------------------------------------
%newgroup;


class wxSizerItem : public wxObject {
public:
    wxSizerItem();

    %name(SizerItemSpacer) wxSizerItem( int width, int height, int proportion, int flag, int border, wxObject* userData);
    %name(SizerItemWindow) wxSizerItem( wxWindow *window, int proportion, int flag, int border, wxObject* userData );
    %name(SizerItemSizer) wxSizerItem( wxSizer *sizer, int proportion, int flag, int border, wxObject* userData );

    void DeleteWindows();
    void DetachSizer();

    wxSize GetSize();
    wxSize CalcMin();
    void SetDimension( wxPoint pos, wxSize size );

    wxSize GetMinSize();
    void SetInitSize( int x, int y );

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

    void SetProportion( int proportion );
    int GetProportion();

    void SetFlag( int flag );
    int GetFlag();

    void SetBorder( int border );
    int GetBorder();

    wxWindow *GetWindow();
    void SetWindow( wxWindow *window );

    wxSizer *GetSizer();
    void SetSizer( wxSizer *sizer );

    const wxSize& GetSpacer();
    void SetSpacer( const wxSize &size );

    void Show( bool show );
    bool IsShown();

    wxPoint GetPosition();

    // wxObject* GetUserData();
    %extend {
        // 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;
            }
        }
    }
};


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

%{
// Figure out the type of the sizer item

struct wxPySizerItemInfo {
    wxPySizerItemInfo()
        : window(NULL), sizer(NULL), gotSize(False),
          size(wxDefaultSize), gotPos(False), pos(-1)
    {}

    wxWindow* window;
    wxSizer*  sizer;
    bool      gotSize;
    wxSize    size;
    bool      gotPos;
    int       pos;
};

static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {

    wxPySizerItemInfo info;
    wxSize  size;
    wxSize* sizePtr = &size;

    // Find out what the type of the item is
    // try wxWindow
    if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
        PyErr_Clear();
        info.window = NULL;

        // try wxSizer
        if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
            PyErr_Clear();
            info.sizer = NULL;

            // try wxSize or (w,h)
            if ( checkSize && wxSize_helper(item, &sizePtr)) {
                info.size = *sizePtr;
                info.gotSize = True;
            }

            // or a single int
            if (checkIdx && PyInt_Check(item)) {
                info.pos = PyInt_AsLong(item);
                info.gotPos = True;
            }
        }
    }

    if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
        // no expected type, figure out what kind of error message to generate
        if ( !checkSize && !checkIdx )
            PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
        else if ( checkSize && !checkIdx )
            PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
        else if ( !checkSize && checkIdx)
            PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
        else
            // can this one happen?
            PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
    }

    return info;
}
%}


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

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


        void Add(PyObject* item, int proportion=0, int flag=0, int border=0,
                  PyObject* userData=NULL) {

            wxPyUserData* data = NULL;
            wxPyBeginBlockThreads();
            wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, True, False);
            if ( userData && (info.window || info.sizer || info.gotSize) )
                data = new wxPyUserData(userData);
            wxPyEndBlockThreads();

            // Now call the real Add method if a valid item type was found
            if ( info.window )
                self->Add(info.window, proportion, flag, border, data);
            else if ( info.sizer )
                self->Add(info.sizer, proportion, flag, border, data);
            else if (info.gotSize)
                self->Add(info.size.GetWidth(), info.size.GetHeight(),
                          proportion, flag, border, data);
        }


        void Insert(int before, PyObject* item, int proportion=0, int flag=0,
                     int border=0, PyObject* userData=NULL) {

            wxPyUserData* data = NULL;
            wxPyBeginBlockThreads();
            wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, True, False);
            if ( userData && (info.window || info.sizer || info.gotSize) )
                data = new wxPyUserData(userData);
            wxPyEndBlockThreads();

            // Now call the real Insert method if a valid item type was found
            if ( info.window )
                self->Insert(before, info.window, proportion, flag, border, data);
            else if ( info.sizer )
                self->Insert(before, info.sizer, proportion, flag, border, data);
            else if (info.gotSize)
                self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
                             proportion, flag, border, data);
        }


        void Prepend(PyObject* item, int proportion=0, int flag=0, int border=0,
                     PyObject* userData=NULL) {

            wxPyUserData* data = NULL;
            wxPyBeginBlockThreads();
            wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, True, False);
            if ( userData && (info.window || info.sizer || info.gotSize) )
                data = new wxPyUserData(userData);
            wxPyEndBlockThreads();

            // Now call the real Prepend method if a valid item type was found
            if ( info.window )
                self->Prepend(info.window, proportion, flag, border, data);
            else if ( info.sizer )
                self->Prepend(info.sizer, proportion, flag, border, data);
            else if (info.gotSize)
                self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
                              proportion, flag, border, data);
        }


        bool Remove(PyObject* item) {
            wxPyBeginBlockThreads();
            wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, True);
            wxPyEndBlockThreads();
            if ( info.window )
                return self->Remove(info.window);
            else if ( info.sizer )
                return self->Remove(info.sizer);
            else if ( info.gotPos )
                return self->Remove(info.pos);
            else
                return False;
        }


        void _SetItemMinSize(PyObject* item, const wxSize& size) {
            wxPyBeginBlockThreads();
            wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, True);
            wxPyEndBlockThreads();
            if ( info.window )
                self->SetItemMinSize(info.window, size);
            else if ( info.sizer )
                self->SetItemMinSize(info.sizer, size);
            else if ( info.gotPos )
                self->SetItemMinSize(info.pos, size);
        }
    }

    %name(AddItem) void Add( wxSizerItem *item );
    %name(InsertItem) void Insert( size_t index, wxSizerItem *item );
    %name(PrependItem) void Prepend( wxSizerItem *item );


    %pythoncode {
    def AddMany(self, widgets):
        for childinfo in widgets:
            if type(childinfo) != type(()) or (len(childinfo) == 2 and type(childinfo[0]) == type(1)):
                childinfo = (childinfo, )
            self.Add(*childinfo)

    %# for backwards compatibility only, please do not use in new code
    AddWindow = AddSizer = AddSpacer = Add
    PrependWindow = PrependSizer = PrependSpacer = Prepend
    InsertWindow = InsertSizer = InsertSpacer = Insert
    RemoveWindow = RemoveSizer = RemovePos = Remove


    def SetItemMinSize(self, item, *args):
        if len(args) == 2:
            return self._SetItemMinSize(item, args)
        else:
            return self._SetItemMinSize(item, args[0])
    }


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

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

    %pythoncode {
    def GetSizeTuple(self):
        return self.GetSize().asTuple()
    def GetPositionTuple(self):
        return self.GetPosition().asTuple()
    def GetMinSizeTuple(self):
        return self.GetMinSize().asTuple()
    }

    virtual void RecalcSizes();
    virtual wxSize CalcMin();

    void Layout();

    wxSize Fit( wxWindow *window );
    void FitInside( wxWindow *window );

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

    void Clear( bool delete_windows=False );
    void DeleteWindows();


    // wxList& GetChildren();
    %extend {
        PyObject* GetChildren() {
            wxSizerItemList& list = self->GetChildren();
            return wxPy_ConvertList(&list);
        }
    }


    // Manage whether individual windows or sub-sizers are considered
    // in the layout calculations or not.

    %extend {
        void Show(PyObject* item, bool show = True) {
            wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, False);
            if ( info.window )
                self->Show(info.window, show);
            else if ( info.sizer )
                self->Show(info.sizer, show);
        }


        void Hide(PyObject* item) {
            wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, False);
            if ( info.window )
                self->Hide(info.window);
            else if ( info.sizer )
                self->Hide(info.sizer);
        }


        bool IsShown(PyObject* item) {
            wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, False);
            if ( info.window )
                return self->IsShown(info.window);
            else if ( info.sizer )
                return self->IsShown(info.sizer);
            else
                return False;
        }
    }


    // Recursively call wxWindow::Show() on all sizer items.
    void ShowItems(bool show);

};


//---------------------------------------------------------------------------
// Use this one for deriving Python classes from
%{
// See pyclasses.h
IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
%}


class wxPySizer : public wxSizer {
public:
    %pythonAppend wxPySizer "self._setCallbackInfo(self, PySizer);self._setOORInfo(self)"

    wxPySizer();
    void _setCallbackInfo(PyObject* self, PyObject* _class);
};


//---------------------------------------------------------------------------
%newgroup;

class  wxBoxSizer : public wxSizer {
public:
    %pythonAppend wxBoxSizer "self._setOORInfo(self)"

    wxBoxSizer(int orient = wxHORIZONTAL);

    int GetOrientation();
    void SetOrientation(int orient);
    void RecalcSizes();
    wxSize CalcMin();
};

//---------------------------------------------------------------------------
%newgroup;

class  wxStaticBoxSizer : public wxBoxSizer {
public:
    %pythonAppend wxStaticBoxSizer "self._setOORInfo(self)"

    wxStaticBoxSizer(wxStaticBox *box, int orient = wxHORIZONTAL);

    wxStaticBox *GetStaticBox();
    void RecalcSizes();
    wxSize CalcMin();
};

//---------------------------------------------------------------------------
%newgroup;

class wxGridSizer: public wxSizer
{
public:
    %pythonAppend wxGridSizer "self._setOORInfo(self)"

    wxGridSizer( int rows=1, int cols=0, int vgap=0, int hgap=0 );

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

//---------------------------------------------------------------------------
%newgroup;

enum wxFlexSizerGrowMode
{
    // don't resize the cells in non-flexible direction at all
    wxFLEX_GROWMODE_NONE,

    // uniformly resize only the specified ones (default)
    wxFLEX_GROWMODE_SPECIFIED,

    // uniformly resize all cells
    wxFLEX_GROWMODE_ALL
};


class wxFlexGridSizer: public wxGridSizer
{
public:
    %pythonAppend wxFlexGridSizer "self._setOORInfo(self)"

    wxFlexGridSizer( int rows=1, int cols=0, int vgap=0, int hgap=0 );

    void RecalcSizes();
    wxSize CalcMin();

    void AddGrowableRow( size_t idx, int proportion = 0  );
    void RemoveGrowableRow( size_t idx );
    void AddGrowableCol( size_t idx, int proportion = 0  );
    void RemoveGrowableCol( size_t idx );

    // the sizer cells may grow in both directions, not grow at all or only
    // grow in one direction but not the other

    // the direction may be wxVERTICAL, wxHORIZONTAL or wxBOTH (default)
    void SetFlexibleDirection(int direction);
    int GetFlexibleDirection();

    // note that the grow mode only applies to the direction which is not
    // flexible
    void SetNonFlexibleGrowMode(wxFlexSizerGrowMode mode);
    wxFlexSizerGrowMode GetNonFlexibleGrowMode();

    // Read-only access to the row heights and col widths arrays
    const wxArrayInt& GetRowHeights() const;
    const wxArrayInt& GetColWidths() const;
};

//---------------------------------------------------------------------------
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: _sizers.i
	3	// Purpose: SWIG interface defs for the Sizers
	4	//
	5	// Author: Robin Dunn
	6	//
	7	// Created: 18-Sept-1999
	8	// RCS-ID: $Id$
	9	// Copyright: (c) 2003 by Total Control Software
	10	// Licence: wxWindows license
	11	/////////////////////////////////////////////////////////////////////////////
	12
	13	// Not a %module
	14
	15
	16	//---------------------------------------------------------------------------
	17
	18	%{
	19	%}
	20
	21	//---------------------------------------------------------------------------
	22	%newgroup;
	23
	24
	25	class wxSizerItem : public wxObject {
	26	public:
	27	wxSizerItem();
	28
	29	%name(SizerItemSpacer) wxSizerItem( int width, int height, int proportion, int flag, int border, wxObject* userData);
	30	%name(SizerItemWindow) wxSizerItem( wxWindow window, int proportion, int flag, int border, wxObject userData );
	31	%name(SizerItemSizer) wxSizerItem( wxSizer sizer, int proportion, int flag, int border, wxObject userData );
	32
	33	void DeleteWindows();
	34	void DetachSizer();
	35
	36	wxSize GetSize();
	37	wxSize CalcMin();
	38	void SetDimension( wxPoint pos, wxSize size );
	39
	40	wxSize GetMinSize();
	41	void SetInitSize( int x, int y );
	42
	43	%name(SetRatioWH) void SetRatio( int width, int height );
	44	%name(SetRatioSize) void SetRatio( wxSize size );
	45	void SetRatio( float ratio );
	46	float GetRatio();
	47
	48	bool IsWindow();
	49	bool IsSizer();
	50	bool IsSpacer();
	51
	52	void SetProportion( int proportion );
	53	int GetProportion();
	54
	55	void SetFlag( int flag );
	56	int GetFlag();
	57
	58	void SetBorder( int border );
	59	int GetBorder();
	60
	61	wxWindow *GetWindow();
	62	void SetWindow( wxWindow *window );
	63
	64	wxSizer *GetSizer();
	65	void SetSizer( wxSizer *sizer );
	66
	67	const wxSize& GetSpacer();
	68	void SetSpacer( const wxSize &size );
	69
	70	void Show( bool show );
	71	bool IsShown();
	72
	73	wxPoint GetPosition();
	74
	75	// wxObject* GetUserData();
	76	%extend {
	77	// Assume that the user data is a wxPyUserData object and return the contents
	78	PyObject* GetUserData() {
	79	wxPyUserData* data = (wxPyUserData*)self->GetUserData();
	80	if (data) {
	81	Py_INCREF(data->m_obj);
	82	return data->m_obj;
	83	} else {
	84	Py_INCREF(Py_None);
	85	return Py_None;
	86	}
	87	}
	88	}
	89	};
	90
	91
	92	//---------------------------------------------------------------------------
	93
	94	%{
	95	// Figure out the type of the sizer item
	96
	97	struct wxPySizerItemInfo {
	98	wxPySizerItemInfo()
	99	: window(NULL), sizer(NULL), gotSize(False),
	100	size(wxDefaultSize), gotPos(False), pos(-1)
	101	{}
	102
	103	wxWindow* window;
	104	wxSizer* sizer;
	105	bool gotSize;
	106	wxSize size;
	107	bool gotPos;
	108	int pos;
	109	};
	110
	111	static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
	112
	113	wxPySizerItemInfo info;
	114	wxSize size;
	115	wxSize* sizePtr = &size;
	116
	117	// Find out what the type of the item is
	118	// try wxWindow
	119	if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
	120	PyErr_Clear();
	121	info.window = NULL;
	122
	123	// try wxSizer
	124	if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
	125	PyErr_Clear();
	126	info.sizer = NULL;
	127
	128	// try wxSize or (w,h)
	129	if ( checkSize && wxSize_helper(item, &sizePtr)) {
	130	info.size = *sizePtr;
	131	info.gotSize = True;
	132	}
	133
	134	// or a single int
	135	if (checkIdx && PyInt_Check(item)) {
	136	info.pos = PyInt_AsLong(item);
	137	info.gotPos = True;
	138	}
	139	}
	140	}
	141
	142	if ( !(info.window \|\| info.sizer \|\| (checkSize && info.gotSize) \|\| (checkIdx && info.gotPos)) ) {
	143	// no expected type, figure out what kind of error message to generate
	144	if ( !checkSize && !checkIdx )
	145	PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
	146	else if ( checkSize && !checkIdx )
	147	PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
	148	else if ( !checkSize && checkIdx)
	149	PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
	150	else
	151	// can this one happen?
	152	PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
	153	}
	154
	155	return info;
	156	}
	157	%}
	158
	159
	160
	161
	162	class wxSizer : public wxObject {
	163	public:
	164	// wxSizer(); **** abstract, can't instantiate
	165	// ~wxSizer();
	166
	167	%extend {
	168	void _setOORInfo(PyObject* _self) {
	169	self->SetClientObject(new wxPyOORClientData(_self));
	170	}
	171
	172
	173	void Add(PyObject* item, int proportion=0, int flag=0, int border=0,
	174	PyObject* userData=NULL) {
	175
	176	wxPyUserData* data = NULL;
	177	wxPyBeginBlockThreads();
	178	wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, True, False);
	179	if ( userData && (info.window \|\| info.sizer \|\| info.gotSize) )
	180	data = new wxPyUserData(userData);
	181	wxPyEndBlockThreads();
	182
	183	// Now call the real Add method if a valid item type was found
	184	if ( info.window )
	185	self->Add(info.window, proportion, flag, border, data);
	186	else if ( info.sizer )
	187	self->Add(info.sizer, proportion, flag, border, data);
	188	else if (info.gotSize)
	189	self->Add(info.size.GetWidth(), info.size.GetHeight(),
	190	proportion, flag, border, data);
	191	}
	192
	193
	194	void Insert(int before, PyObject* item, int proportion=0, int flag=0,
	195	int border=0, PyObject* userData=NULL) {
	196
	197	wxPyUserData* data = NULL;
	198	wxPyBeginBlockThreads();
	199	wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, True, False);
	200	if ( userData && (info.window \|\| info.sizer \|\| info.gotSize) )
	201	data = new wxPyUserData(userData);
	202	wxPyEndBlockThreads();
	203
	204	// Now call the real Insert method if a valid item type was found
	205	if ( info.window )
	206	self->Insert(before, info.window, proportion, flag, border, data);
	207	else if ( info.sizer )
	208	self->Insert(before, info.sizer, proportion, flag, border, data);
	209	else if (info.gotSize)
	210	self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
	211	proportion, flag, border, data);
	212	}
	213
	214
	215
	216	void Prepend(PyObject* item, int proportion=0, int flag=0, int border=0,
	217	PyObject* userData=NULL) {
	218
	219	wxPyUserData* data = NULL;
	220	wxPyBeginBlockThreads();
	221	wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, True, False);
	222	if ( userData && (info.window \|\| info.sizer \|\| info.gotSize) )
	223	data = new wxPyUserData(userData);
	224	wxPyEndBlockThreads();
	225
	226	// Now call the real Prepend method if a valid item type was found
	227	if ( info.window )
	228	self->Prepend(info.window, proportion, flag, border, data);
	229	else if ( info.sizer )
	230	self->Prepend(info.sizer, proportion, flag, border, data);
	231	else if (info.gotSize)
	232	self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
	233	proportion, flag, border, data);
	234	}
	235
	236
	237	bool Remove(PyObject* item) {
	238	wxPyBeginBlockThreads();
	239	wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, True);
	240	wxPyEndBlockThreads();
	241	if ( info.window )
	242	return self->Remove(info.window);
	243	else if ( info.sizer )
	244	return self->Remove(info.sizer);
	245	else if ( info.gotPos )
	246	return self->Remove(info.pos);
	247	else
	248	return False;
	249	}
	250
	251
	252	void _SetItemMinSize(PyObject* item, const wxSize& size) {
	253	wxPyBeginBlockThreads();
	254	wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, True);
	255	wxPyEndBlockThreads();
	256	if ( info.window )
	257	self->SetItemMinSize(info.window, size);
	258	else if ( info.sizer )
	259	self->SetItemMinSize(info.sizer, size);
	260	else if ( info.gotPos )
	261	self->SetItemMinSize(info.pos, size);
	262	}
	263	}
	264
	265	%name(AddItem) void Add( wxSizerItem *item );
	266	%name(InsertItem) void Insert( size_t index, wxSizerItem *item );
	267	%name(PrependItem) void Prepend( wxSizerItem *item );
	268
	269
	270	%pythoncode {
	271	def AddMany(self, widgets):
	272	for childinfo in widgets:
	273	if type(childinfo) != type(()) or (len(childinfo) == 2 and type(childinfo[0]) == type(1)):
	274	childinfo = (childinfo, )
	275	self.Add(*childinfo)
	276
	277	%# for backwards compatibility only, please do not use in new code
	278	AddWindow = AddSizer = AddSpacer = Add
	279	PrependWindow = PrependSizer = PrependSpacer = Prepend
	280	InsertWindow = InsertSizer = InsertSpacer = Insert
	281	RemoveWindow = RemoveSizer = RemovePos = Remove
	282
	283
	284	def SetItemMinSize(self, item, *args):
	285	if len(args) == 2:
	286	return self._SetItemMinSize(item, args)
	287	else:
	288	return self._SetItemMinSize(item, args[0])
	289	}
	290
	291
	292	void SetDimension( int x, int y, int width, int height );
	293	void SetMinSize( const wxSize &size );
	294
	295	wxSize GetSize();
	296	wxPoint GetPosition();
	297	wxSize GetMinSize();
	298
	299	%pythoncode {
	300	def GetSizeTuple(self):
	301	return self.GetSize().asTuple()
	302	def GetPositionTuple(self):
	303	return self.GetPosition().asTuple()
	304	def GetMinSizeTuple(self):
	305	return self.GetMinSize().asTuple()
	306	}
	307
	308	virtual void RecalcSizes();
	309	virtual wxSize CalcMin();
	310
	311	void Layout();
	312
	313	wxSize Fit( wxWindow *window );
	314	void FitInside( wxWindow *window );
	315
	316	void SetSizeHints( wxWindow *window );
	317	void SetVirtualSizeHints( wxWindow *window );
	318
	319	void Clear( bool delete_windows=False );
	320	void DeleteWindows();
	321
	322
	323	// wxList& GetChildren();
	324	%extend {
	325	PyObject* GetChildren() {
	326	wxSizerItemList& list = self->GetChildren();
	327	return wxPy_ConvertList(&list);
	328	}
	329	}
	330
	331
	332	// Manage whether individual windows or sub-sizers are considered
	333	// in the layout calculations or not.
	334
	335	%extend {
	336	void Show(PyObject* item, bool show = True) {
	337	wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, False);
	338	if ( info.window )
	339	self->Show(info.window, show);
	340	else if ( info.sizer )
	341	self->Show(info.sizer, show);
	342	}
	343
	344
	345	void Hide(PyObject* item) {
	346	wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, False);
	347	if ( info.window )
	348	self->Hide(info.window);
	349	else if ( info.sizer )
	350	self->Hide(info.sizer);
	351	}
	352
	353
	354	bool IsShown(PyObject* item) {
	355	wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, False);
	356	if ( info.window )
	357	return self->IsShown(info.window);
	358	else if ( info.sizer )
	359	return self->IsShown(info.sizer);
	360	else
	361	return False;
	362	}
	363	}
	364
	365
	366	// Recursively call wxWindow::Show() on all sizer items.
	367	void ShowItems(bool show);
	368
	369	};
	370
	371
	372	//---------------------------------------------------------------------------
	373	// Use this one for deriving Python classes from
	374	%{
	375	// See pyclasses.h
	376	IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
	377	IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
	378	IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
	379	%}
	380
	381
	382
	383	class wxPySizer : public wxSizer {
	384	public:
	385	%pythonAppend wxPySizer "self._setCallbackInfo(self, PySizer);self._setOORInfo(self)"
	386
	387	wxPySizer();
	388	void _setCallbackInfo(PyObject* self, PyObject* _class);
	389	};
	390
	391
	392	//---------------------------------------------------------------------------
	393	%newgroup;
	394
	395	class wxBoxSizer : public wxSizer {
	396	public:
	397	%pythonAppend wxBoxSizer "self._setOORInfo(self)"
	398
	399	wxBoxSizer(int orient = wxHORIZONTAL);
	400
	401	int GetOrientation();
	402	void SetOrientation(int orient);
	403	void RecalcSizes();
	404	wxSize CalcMin();
	405	};
	406
	407	//---------------------------------------------------------------------------
	408	%newgroup;
	409
	410	class wxStaticBoxSizer : public wxBoxSizer {
	411	public:
	412	%pythonAppend wxStaticBoxSizer "self._setOORInfo(self)"
	413
	414	wxStaticBoxSizer(wxStaticBox *box, int orient = wxHORIZONTAL);
	415
	416	wxStaticBox *GetStaticBox();
	417	void RecalcSizes();
	418	wxSize CalcMin();
	419	};
	420
	421	//---------------------------------------------------------------------------
	422	%newgroup;
	423
	424	class wxGridSizer: public wxSizer
	425	{
	426	public:
	427	%pythonAppend wxGridSizer "self._setOORInfo(self)"
	428
	429	wxGridSizer( int rows=1, int cols=0, int vgap=0, int hgap=0 );
	430
	431	void RecalcSizes();
	432	wxSize CalcMin();
	433
	434	void SetCols( int cols );
	435	void SetRows( int rows );
	436	void SetVGap( int gap );
	437	void SetHGap( int gap );
	438	int GetCols();
	439	int GetRows();
	440	int GetVGap();
	441	int GetHGap();
	442	};
	443
	444	//---------------------------------------------------------------------------
	445	%newgroup;
	446
	447	enum wxFlexSizerGrowMode
	448	{
	449	// don't resize the cells in non-flexible direction at all
	450	wxFLEX_GROWMODE_NONE,
	451
	452	// uniformly resize only the specified ones (default)
	453	wxFLEX_GROWMODE_SPECIFIED,
	454
	455	// uniformly resize all cells
	456	wxFLEX_GROWMODE_ALL
	457	};
	458
	459
	460	class wxFlexGridSizer: public wxGridSizer
	461	{
	462	public:
	463	%pythonAppend wxFlexGridSizer "self._setOORInfo(self)"
	464
	465	wxFlexGridSizer( int rows=1, int cols=0, int vgap=0, int hgap=0 );
	466
	467	void RecalcSizes();
	468	wxSize CalcMin();
	469
	470	void AddGrowableRow( size_t idx, int proportion = 0 );
	471	void RemoveGrowableRow( size_t idx );
	472	void AddGrowableCol( size_t idx, int proportion = 0 );
	473	void RemoveGrowableCol( size_t idx );
	474
	475	// the sizer cells may grow in both directions, not grow at all or only
	476	// grow in one direction but not the other
	477
	478	// the direction may be wxVERTICAL, wxHORIZONTAL or wxBOTH (default)
	479	void SetFlexibleDirection(int direction);
	480	int GetFlexibleDirection();
	481
	482	// note that the grow mode only applies to the direction which is not
	483	// flexible
	484	void SetNonFlexibleGrowMode(wxFlexSizerGrowMode mode);
	485	wxFlexSizerGrowMode GetNonFlexibleGrowMode();
	486
	487	// Read-only access to the row heights and col widths arrays
	488	const wxArrayInt& GetRowHeights() const;
	489	const wxArrayInt& GetColWidths() const;
	490	};
	491
	492	//---------------------------------------------------------------------------