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

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