wxPython/src/_gbsizer.i

/////////////////////////////////////////////////////////////////////////////
// Name:        _gbsizer.i
// Purpose:     SWIG interface stuff for wxGBGridBagSizer and etc.
//
// Author:      Robin Dunn
//
// Created:     05-Nov-2003
// RCS-ID:      $Id$
// Copyright:   (c) 2003 by Total Control Software
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////

// Not a %module


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

%{
%}

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

%typemap(in) wxGBPosition& (wxGBPosition temp) {
    $1 = &temp;
    if ( ! wxGBPosition_helper($input, &$1)) SWIG_fail;
}
%typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) wxGBPosition& {
    $1 = wxPySimple_typecheck($input, wxT("wxGBPosition"), 2);
}

%typemap(in) wxGBSpan& (wxGBSpan temp) {
    $1 = &temp;
    if ( ! wxGBSpan_helper($input, &$1)) SWIG_fail;
}
%typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) wxGBSpan& {
    $1 = wxPySimple_typecheck($input, wxT("wxGBSpan"), 2);
}


%{
bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
{
    if (source == Py_None) {
        **obj = wxGBPosition(-1,-1);
        return True;
    }
    return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
}

bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
{
    if (source == Py_None) {
        **obj = wxGBSpan(-1,-1);
        return True;
    }
    return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
}

%}


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


class wxGBPosition
{
public:
    wxGBPosition(int row=0, int col=0);

    int GetRow() const;
    int GetCol() const;
    void SetRow(int row);
    void SetCol(int col);

//     %extend {
//         bool __eq__(const wxGBPosition* other) { return other ? (*self == *other) : False; }
//         bool __ne__(const wxGBPosition* other) { return other ? (*self != *other) : True;  }
//     }

    bool operator==(const wxGBPosition& other);
    bool operator!=(const wxGBPosition& other);

    %extend {
        void Set(int row=0, int col=0) {
            self->SetRow(row);
            self->SetCol(col);
        }

        PyObject* Get() {
            bool blocked = wxPyBeginBlockThreads();
            PyObject* tup = PyTuple_New(2);
            PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
            PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
            wxPyEndBlockThreads(blocked);
            return tup;
        }
    }
    %pythoncode {
    asTuple = Get
    def __str__(self):                   return str(self.Get())
    def __repr__(self):                  return 'wx.GBPosition'+str(self.Get())
    def __len__(self):                   return len(self.Get())
    def __getitem__(self, index):        return self.Get()[index]
    def __setitem__(self, index, val):
        if index == 0: self.SetRow(val)
        elif index == 1: self.SetCol(val)
        else: raise IndexError
    def __nonzero__(self):               return self.Get() != (0,0)
    __safe_for_unpickling__ = True
    def __reduce__(self):                return (wx.GBPosition, self.Get())
    }

    %pythoncode {
    row = property(GetRow, SetRow)
    col = property(GetCol, SetCol)
    }
};


class wxGBSpan
{
public:
    wxGBSpan(int rowspan=1, int colspan=1);

    int GetRowspan() const;
    int GetColspan() const;
    void SetRowspan(int rowspan);
    void SetColspan(int colspan);

//     %extend {
//         bool __eq__(const wxGBSpan* other) { return other ? (*self == *other) : False; }
//         bool __ne__(const wxGBSpan* other) { return other ? (*self != *other) : True;  }
//     }
    bool operator==(const wxGBSpan& other);
    bool operator!=(const wxGBSpan& other);


    %extend {
        void Set(int rowspan=1, int colspan=1) {
            self->SetRowspan(rowspan);
            self->SetColspan(colspan);
        }

        PyObject* Get() {
            bool blocked = wxPyBeginBlockThreads();
            PyObject* tup = PyTuple_New(2);
            PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
            PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
            wxPyEndBlockThreads(blocked);
            return tup;
        }
    }
    %pythoncode {
    asTuple = Get
    def __str__(self):                   return str(self.Get())
    def __repr__(self):                  return 'wx.GBSpan'+str(self.Get())
    def __len__(self):                   return len(self.Get())
    def __getitem__(self, index):        return self.Get()[index]
    def __setitem__(self, index, val):
        if index == 0: self.SetRowspan(val)
        elif index == 1: self.SetColspan(val)
        else: raise IndexError
    def __nonzero__(self):               return self.Get() != (0,0)
    __safe_for_unpickling__ = True
    def __reduce__(self):                return (wx.GBSpan, self.Get())
    }

    %pythoncode {
    rowspan = property(GetRowspan, SetRowspan)
    colspan = property(GetColspan, SetColspan)
    }
};


%immutable;
const wxGBSpan wxDefaultSpan;
%mutable;


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


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

    %name(GBSizerItemWindow) wxGBSizerItem( wxWindow *window,
                   const wxGBPosition& pos,
                   const wxGBSpan& span,
                   int flag,
                   int border,
                   wxObject* userData );

    %name(GBSizerItemSizer) wxGBSizerItem( wxSizer *sizer,
                   const wxGBPosition& pos,
                   const wxGBSpan& span,
                   int flag,
                   int border,
                   wxObject* userData );

    %name(GBSizerItemSpacer) wxGBSizerItem( int width,
                   int height,
                   const wxGBPosition& pos,
                   const wxGBSpan& span,
                   int flag,
                   int border,
                   wxObject* userData);


    // Get the grid position of the item
    wxGBPosition GetPos() const;
    %pythoncode { def GetPosTuple(self): return self.GetPos().Get() }

    // Get the row and column spanning of the item
    wxGBSpan GetSpan() const;
    %pythoncode { def GetSpanTuple(self): return self.GetSpan().Get() }

    // If the item is already a member of a sizer then first ensure that there
    // is no other item that would intersect with this one at the new
    // position, then set the new position.  Returns True if the change is
    // successful and after the next Layout the item will be moved.
    bool SetPos( const wxGBPosition& pos );

    // If the item is already a member of a sizer then first ensure that there
    // is no other item that would intersect with this one with its new
    // spanning size, then set the new spanning.  Returns True if the change
    // is successful and after the next Layout the item will be resized.
    bool SetSpan( const wxGBSpan& span );

    %nokwargs Intersects;

    // Returns True if this item and the other item instersect
    bool Intersects(const wxGBSizerItem& other);

    // Returns True if the given pos/span would intersect with this item.
    bool Intersects(const wxGBPosition& pos, const wxGBSpan& span);

    // Get the row and column of the endpoint of this item
    void GetEndPos(int& row, int& col);


    wxGridBagSizer* GetGBSizer() const;
    void SetGBSizer(wxGridBagSizer* sizer);

};


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


class wxGridBagSizer : public wxFlexGridSizer
{
public:
    wxGridBagSizer(int vgap = 0, int hgap = 0 );

    // The Add method returns True if the item was successfully placed at the
    // given cell position, False if something was already there.
    %extend {
        bool Add( PyObject* item,
                  const wxGBPosition& pos,
                  const wxGBSpan& span = wxDefaultSpan,
                  int flag = 0,
                  int border = 0,
                  PyObject* userData = NULL ) {

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

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

    %name(AddItem) bool Add( wxGBSizerItem *item );


    // Get/Set the size used for cells in the grid with no item.
    wxSize GetEmptyCellSize() const;
    void SetEmptyCellSize(const wxSize& sz);

    // Get the grid position of the specified item
    %nokwargs GetItemPosition;
    wxGBPosition GetItemPosition(wxWindow *window);
    wxGBPosition GetItemPosition(wxSizer *sizer);
    wxGBPosition GetItemPosition(size_t index);

    // Set the grid position of the specified item.  Returns True on success.
    // If the move is not allowed (because an item is already there) then
    // False is returned.
    %nokwargs SetItemPosition;
    bool SetItemPosition(wxWindow *window, const wxGBPosition& pos);
    bool SetItemPosition(wxSizer *sizer, const wxGBPosition& pos);
    bool SetItemPosition(size_t index, const wxGBPosition& pos);

    // Get the row/col spanning of the specified item
    %nokwargs GetItemSpan;
    wxGBSpan GetItemSpan(wxWindow *window);
    wxGBSpan GetItemSpan(wxSizer *sizer);
    wxGBSpan GetItemSpan(size_t index);

    // Set the row/col spanning of the specified item. Returns True on
    // success.  If the move is not allowed (because an item is already there)
    // then False is returned.
    %nokwargs SetItemSpan;
    bool SetItemSpan(wxWindow *window, const wxGBSpan& span);
    bool SetItemSpan(wxSizer *sizer, const wxGBSpan& span);
    bool SetItemSpan(size_t index, const wxGBSpan& span);


    // Find the sizer item for the given window or subsizer, returns NULL if
    // not found. (non-recursive)
    %nokwargs FindItem;
    wxGBSizerItem* FindItem(wxWindow* window);
    wxGBSizerItem* FindItem(wxSizer* sizer);


    // Return the sizer item for the given grid cell, or NULL if there is no
    // item at that position. (non-recursive)
    wxGBSizerItem* FindItemAtPosition(const wxGBPosition& pos);


    // Return the sizer item located at the point given in pt, or NULL if
    // there is no item at that point. The (x,y) coordinates in pt correspond
    // to the client coordinates of the window using the sizer for
    // layout. (non-recursive)
    wxGBSizerItem* FindItemAtPoint(const wxPoint& pt);


    // Return the sizer item that has a matching user data (it only compares
    // pointer values) or NULL if not found. (non-recursive)
    wxGBSizerItem* FindItemWithData(const wxObject* userData);


    // These are what make the sizer do size calculations and layout
    virtual void RecalcSizes();
    virtual wxSize CalcMin();


    // Look at all items and see if any intersect (or would overlap) the given
    // item.  Returns True if so, False if there would be no overlap.  If an
    // excludeItem is given then it will not be checked for intersection, for
    // example it may be the item we are checking the position of.
    %nokwargs CheckForIntersection;
    bool CheckForIntersection(wxGBSizerItem* item, wxGBSizerItem* excludeItem = NULL);
    bool CheckForIntersection(const wxGBPosition& pos, const wxGBSpan& span, wxGBSizerItem* excludeItem = NULL);

};


//---------------------------------------------------------------------------
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: _gbsizer.i
	3	// Purpose: SWIG interface stuff for wxGBGridBagSizer and etc.
	4	//
	5	// Author: Robin Dunn
	6	//
	7	// Created: 05-Nov-2003
	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
	23	%typemap(in) wxGBPosition& (wxGBPosition temp) {
	24	$1 = &temp;
	25	if ( ! wxGBPosition_helper($input, &$1)) SWIG_fail;
	26	}
	27	%typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) wxGBPosition& {
	28	$1 = wxPySimple_typecheck($input, wxT("wxGBPosition"), 2);
	29	}
	30
	31	%typemap(in) wxGBSpan& (wxGBSpan temp) {
	32	$1 = &temp;
	33	if ( ! wxGBSpan_helper($input, &$1)) SWIG_fail;
	34	}
	35	%typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) wxGBSpan& {
	36	$1 = wxPySimple_typecheck($input, wxT("wxGBSpan"), 2);
	37	}
	38
	39
	40	%{
	41	bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
	42	{
	43	if (source == Py_None) {
	44	**obj = wxGBPosition(-1,-1);
	45	return True;
	46	}
	47	return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
	48	}
	49
	50	bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
	51	{
	52	if (source == Py_None) {
	53	**obj = wxGBSpan(-1,-1);
	54	return True;
	55	}
	56	return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
	57	}
	58
	59	%}
	60
	61
	62	//---------------------------------------------------------------------------
	63	%newgroup;
	64
	65
	66	class wxGBPosition
	67	{
	68	public:
	69	wxGBPosition(int row=0, int col=0);
	70
	71	int GetRow() const;
	72	int GetCol() const;
	73	void SetRow(int row);
	74	void SetCol(int col);
	75
	76	// %extend {
	77	// bool __eq__(const wxGBPosition* other) { return other ? (self == other) : False; }
	78	// bool __ne__(const wxGBPosition* other) { return other ? (self != other) : True; }
	79	// }
	80
	81	bool operator==(const wxGBPosition& other);
	82	bool operator!=(const wxGBPosition& other);
	83
	84	%extend {
	85	void Set(int row=0, int col=0) {
	86	self->SetRow(row);
	87	self->SetCol(col);
	88	}
	89
	90	PyObject* Get() {
	91	bool blocked = wxPyBeginBlockThreads();
	92	PyObject* tup = PyTuple_New(2);
	93	PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
	94	PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
	95	wxPyEndBlockThreads(blocked);
	96	return tup;
	97	}
	98	}
	99	%pythoncode {
	100	asTuple = Get
	101	def __str__(self): return str(self.Get())
	102	def __repr__(self): return 'wx.GBPosition'+str(self.Get())
	103	def __len__(self): return len(self.Get())
	104	def __getitem__(self, index): return self.Get()[index]
	105	def __setitem__(self, index, val):
	106	if index == 0: self.SetRow(val)
	107	elif index == 1: self.SetCol(val)
	108	else: raise IndexError
	109	def __nonzero__(self): return self.Get() != (0,0)
	110	__safe_for_unpickling__ = True
	111	def __reduce__(self): return (wx.GBPosition, self.Get())
	112	}
	113
	114	%pythoncode {
	115	row = property(GetRow, SetRow)
	116	col = property(GetCol, SetCol)
	117	}
	118	};
	119
	120
	121
	122
	123	class wxGBSpan
	124	{
	125	public:
	126	wxGBSpan(int rowspan=1, int colspan=1);
	127
	128	int GetRowspan() const;
	129	int GetColspan() const;
	130	void SetRowspan(int rowspan);
	131	void SetColspan(int colspan);
	132
	133	// %extend {
	134	// bool __eq__(const wxGBSpan* other) { return other ? (self == other) : False; }
	135	// bool __ne__(const wxGBSpan* other) { return other ? (self != other) : True; }
	136	// }
	137	bool operator==(const wxGBSpan& other);
	138	bool operator!=(const wxGBSpan& other);
	139
	140
	141	%extend {
	142	void Set(int rowspan=1, int colspan=1) {
	143	self->SetRowspan(rowspan);
	144	self->SetColspan(colspan);
	145	}
	146
	147	PyObject* Get() {
	148	bool blocked = wxPyBeginBlockThreads();
	149	PyObject* tup = PyTuple_New(2);
	150	PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
	151	PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
	152	wxPyEndBlockThreads(blocked);
	153	return tup;
	154	}
	155	}
	156	%pythoncode {
	157	asTuple = Get
	158	def __str__(self): return str(self.Get())
	159	def __repr__(self): return 'wx.GBSpan'+str(self.Get())
	160	def __len__(self): return len(self.Get())
	161	def __getitem__(self, index): return self.Get()[index]
	162	def __setitem__(self, index, val):
	163	if index == 0: self.SetRowspan(val)
	164	elif index == 1: self.SetColspan(val)
	165	else: raise IndexError
	166	def __nonzero__(self): return self.Get() != (0,0)
	167	__safe_for_unpickling__ = True
	168	def __reduce__(self): return (wx.GBSpan, self.Get())
	169	}
	170
	171	%pythoncode {
	172	rowspan = property(GetRowspan, SetRowspan)
	173	colspan = property(GetColspan, SetColspan)
	174	}
	175	};
	176
	177
	178	%immutable;
	179	const wxGBSpan wxDefaultSpan;
	180	%mutable;
	181
	182
	183	//---------------------------------------------------------------------------
	184
	185
	186	class wxGBSizerItem : public wxSizerItem
	187	{
	188	public:
	189	wxGBSizerItem();
	190
	191	%name(GBSizerItemWindow) wxGBSizerItem( wxWindow *window,
	192	const wxGBPosition& pos,
	193	const wxGBSpan& span,
	194	int flag,
	195	int border,
	196	wxObject* userData );
	197
	198	%name(GBSizerItemSizer) wxGBSizerItem( wxSizer *sizer,
	199	const wxGBPosition& pos,
	200	const wxGBSpan& span,
	201	int flag,
	202	int border,
	203	wxObject* userData );
	204
	205	%name(GBSizerItemSpacer) wxGBSizerItem( int width,
	206	int height,
	207	const wxGBPosition& pos,
	208	const wxGBSpan& span,
	209	int flag,
	210	int border,
	211	wxObject* userData);
	212
	213
	214	// Get the grid position of the item
	215	wxGBPosition GetPos() const;
	216	%pythoncode { def GetPosTuple(self): return self.GetPos().Get() }
	217
	218	// Get the row and column spanning of the item
	219	wxGBSpan GetSpan() const;
	220	%pythoncode { def GetSpanTuple(self): return self.GetSpan().Get() }
	221
	222	// If the item is already a member of a sizer then first ensure that there
	223	// is no other item that would intersect with this one at the new
	224	// position, then set the new position. Returns True if the change is
	225	// successful and after the next Layout the item will be moved.
	226	bool SetPos( const wxGBPosition& pos );
	227
	228	// If the item is already a member of a sizer then first ensure that there
	229	// is no other item that would intersect with this one with its new
	230	// spanning size, then set the new spanning. Returns True if the change
	231	// is successful and after the next Layout the item will be resized.
	232	bool SetSpan( const wxGBSpan& span );
	233
	234	%nokwargs Intersects;
	235
	236	// Returns True if this item and the other item instersect
	237	bool Intersects(const wxGBSizerItem& other);
	238
	239	// Returns True if the given pos/span would intersect with this item.
	240	bool Intersects(const wxGBPosition& pos, const wxGBSpan& span);
	241
	242	// Get the row and column of the endpoint of this item
	243	void GetEndPos(int& row, int& col);
	244
	245
	246	wxGridBagSizer* GetGBSizer() const;
	247	void SetGBSizer(wxGridBagSizer* sizer);
	248
	249	};
	250
	251
	252	//---------------------------------------------------------------------------
	253
	254
	255	class wxGridBagSizer : public wxFlexGridSizer
	256	{
	257	public:
	258	wxGridBagSizer(int vgap = 0, int hgap = 0 );
	259
	260	// The Add method returns True if the item was successfully placed at the
	261	// given cell position, False if something was already there.
	262	%extend {
	263	bool Add( PyObject* item,
	264	const wxGBPosition& pos,
	265	const wxGBSpan& span = wxDefaultSpan,
	266	int flag = 0,
	267	int border = 0,
	268	PyObject* userData = NULL ) {
	269
	270	wxPyUserData* data = NULL;
	271	bool blocked = wxPyBeginBlockThreads();
	272	wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, True, False);
	273	if ( userData && (info.window \|\| info.sizer \|\| info.gotSize) )
	274	data = new wxPyUserData(userData);
	275	wxPyEndBlockThreads(blocked);
	276
	277	// Now call the real Add method if a valid item type was found
	278	if ( info.window )
	279	return self->Add(info.window, pos, span, flag, border, data);
	280	else if ( info.sizer )
	281	return self->Add(info.sizer, pos, span, flag, border, data);
	282	else if (info.gotSize)
	283	return self->Add(info.size.GetWidth(), info.size.GetHeight(),
	284	pos, span, flag, border, data);
	285	return False;
	286	}
	287	}
	288
	289	%name(AddItem) bool Add( wxGBSizerItem *item );
	290
	291
	292	// Get/Set the size used for cells in the grid with no item.
	293	wxSize GetEmptyCellSize() const;
	294	void SetEmptyCellSize(const wxSize& sz);
	295
	296	// Get the grid position of the specified item
	297	%nokwargs GetItemPosition;
	298	wxGBPosition GetItemPosition(wxWindow *window);
	299	wxGBPosition GetItemPosition(wxSizer *sizer);
	300	wxGBPosition GetItemPosition(size_t index);
	301
	302	// Set the grid position of the specified item. Returns True on success.
	303	// If the move is not allowed (because an item is already there) then
	304	// False is returned.
	305	%nokwargs SetItemPosition;
	306	bool SetItemPosition(wxWindow *window, const wxGBPosition& pos);
	307	bool SetItemPosition(wxSizer *sizer, const wxGBPosition& pos);
	308	bool SetItemPosition(size_t index, const wxGBPosition& pos);
	309
	310	// Get the row/col spanning of the specified item
	311	%nokwargs GetItemSpan;
	312	wxGBSpan GetItemSpan(wxWindow *window);
	313	wxGBSpan GetItemSpan(wxSizer *sizer);
	314	wxGBSpan GetItemSpan(size_t index);
	315
	316	// Set the row/col spanning of the specified item. Returns True on
	317	// success. If the move is not allowed (because an item is already there)
	318	// then False is returned.
	319	%nokwargs SetItemSpan;
	320	bool SetItemSpan(wxWindow *window, const wxGBSpan& span);
	321	bool SetItemSpan(wxSizer *sizer, const wxGBSpan& span);
	322	bool SetItemSpan(size_t index, const wxGBSpan& span);
	323
	324
	325	// Find the sizer item for the given window or subsizer, returns NULL if
	326	// not found. (non-recursive)
	327	%nokwargs FindItem;
	328	wxGBSizerItem* FindItem(wxWindow* window);
	329	wxGBSizerItem* FindItem(wxSizer* sizer);
	330
	331
	332	// Return the sizer item for the given grid cell, or NULL if there is no
	333	// item at that position. (non-recursive)
	334	wxGBSizerItem* FindItemAtPosition(const wxGBPosition& pos);
	335
	336
	337	// Return the sizer item located at the point given in pt, or NULL if
	338	// there is no item at that point. The (x,y) coordinates in pt correspond
	339	// to the client coordinates of the window using the sizer for
	340	// layout. (non-recursive)
	341	wxGBSizerItem* FindItemAtPoint(const wxPoint& pt);
	342
	343
	344	// Return the sizer item that has a matching user data (it only compares
	345	// pointer values) or NULL if not found. (non-recursive)
	346	wxGBSizerItem* FindItemWithData(const wxObject* userData);
	347
	348
	349	// These are what make the sizer do size calculations and layout
	350	virtual void RecalcSizes();
	351	virtual wxSize CalcMin();
	352
	353
	354	// Look at all items and see if any intersect (or would overlap) the given
	355	// item. Returns True if so, False if there would be no overlap. If an
	356	// excludeItem is given then it will not be checked for intersection, for
	357	// example it may be the item we are checking the position of.
	358	%nokwargs CheckForIntersection;
	359	bool CheckForIntersection(wxGBSizerItem* item, wxGBSizerItem* excludeItem = NULL);
	360	bool CheckForIntersection(const wxGBPosition& pos, const wxGBSpan& span, wxGBSizerItem* excludeItem = NULL);
	361
	362	};
	363
	364
	365	//---------------------------------------------------------------------------