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

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

    %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)
    def __getinitargs__(self):           return ()
    def __getstate__(self):              return self.Get()
    def __setstate__(self, state):       self.Set(*state)
    }

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

    bool operator==(const wxGBSpan& o) const;
    bool operator!=(const wxGBSpan& o) const;

    %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)
    def __getinitargs__(self):           return ()
    def __getstate__(self):              return self.Get()
    def __setstate__(self, state):       self.Set(*state)
    }

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