[wxWidgets.git] / 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)
{
    return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
}

bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
{
    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;  }
    }

    %extend {
        void Set(int row=0, int col=0) {
            self->SetRow(row);
            self->SetCol(col);
        }
        
        PyObject* Get() {
            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();
            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;  }
    }

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