1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: SWIG interface stuff for wxGBGridBagSizer and etc.
7 // Created: 05-Nov-2003
9 // Copyright: (c) 2003 by Total Control Software
10 // Licence: wxWindows license
11 /////////////////////////////////////////////////////////////////////////////
16 //---------------------------------------------------------------------------
21 //---------------------------------------------------------------------------
23 %typemap(in) wxGBPosition& (wxGBPosition temp) {
25 if ( ! wxGBPosition_helper($input, &$1)) SWIG_fail;
27 %typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) wxGBPosition& {
28 $1 = wxPySimple_typecheck($input, wxT("wxGBPosition"), 2);
31 %typemap(in) wxGBSpan& (wxGBSpan temp) {
33 if ( ! wxGBSpan_helper($input, &$1)) SWIG_fail;
35 %typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) wxGBSpan& {
36 $1 = wxPySimple_typecheck($input, wxT("wxGBSpan"), 2);
41 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
43 if (source == Py_None) {
44 **obj = wxGBPosition(-1,-1);
47 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
50 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
52 if (source == Py_None) {
53 **obj = wxGBSpan(-1,-1);
56 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
62 //---------------------------------------------------------------------------
66 "This class represents the position of an item in a virtual grid of
67 rows and columns managed by a `wx.GridBagSizer`. wxPython has
68 typemaps that will automatically convert from a 2-element sequence of
69 integers to a wx.GBPosition, so you can use the more pythonic
70 representation of the position nearly transparently in Python code.", "");
75 wxGBPosition(int row=0, int col=0);
83 // bool __eq__(const wxGBPosition* other) { return other ? (*self == *other) : false; }
84 // bool __ne__(const wxGBPosition* other) { return other ? (*self != *other) : true; }
87 bool operator==(const wxGBPosition& other);
88 bool operator!=(const wxGBPosition& other);
91 void Set(int row=0, int col=0) {
97 bool blocked = wxPyBeginBlockThreads();
98 PyObject* tup = PyTuple_New(2);
99 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
100 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
101 wxPyEndBlockThreads(blocked);
106 asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
107 def __str__(self): return str(self.Get())
108 def __repr__(self): return 'wx.GBPosition'+str(self.Get())
109 def __len__(self): return len(self.Get())
110 def __getitem__(self, index): return self.Get()[index]
111 def __setitem__(self, index, val):
112 if index == 0: self.SetRow(val)
113 elif index == 1: self.SetCol(val)
114 else: raise IndexError
115 def __nonzero__(self): return self.Get() != (0,0)
116 __safe_for_unpickling__ = True
117 def __reduce__(self): return (wx.GBPosition, self.Get())
121 row = property(GetRow, SetRow)
122 col = property(GetCol, SetCol)
130 "This class is used to hold the row and column spanning attributes of
131 items in a `wx.GridBagSizer`. wxPython has typemaps that will
132 automatically convert from a 2-element sequence of integers to a
133 wx.GBSpan, so you can use the more pythonic representation of the span
134 nearly transparently in Python code.
141 wxGBSpan(int rowspan=1, int colspan=1),
142 "Construct a new wxGBSpan, optionally setting the rowspan and
143 colspan. The default is (1,1). (Meaning that the item occupies one
144 cell in each direction.", "");
146 int GetRowspan() const;
147 int GetColspan() const;
148 void SetRowspan(int rowspan);
149 void SetColspan(int colspan);
152 // bool __eq__(const wxGBSpan* other) { return other ? (*self == *other) : false; }
153 // bool __ne__(const wxGBSpan* other) { return other ? (*self != *other) : true; }
155 bool operator==(const wxGBSpan& other);
156 bool operator!=(const wxGBSpan& other);
160 void Set(int rowspan=1, int colspan=1) {
161 self->SetRowspan(rowspan);
162 self->SetColspan(colspan);
166 bool blocked = wxPyBeginBlockThreads();
167 PyObject* tup = PyTuple_New(2);
168 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
169 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
170 wxPyEndBlockThreads(blocked);
175 asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
176 def __str__(self): return str(self.Get())
177 def __repr__(self): return 'wx.GBSpan'+str(self.Get())
178 def __len__(self): return len(self.Get())
179 def __getitem__(self, index): return self.Get()[index]
180 def __setitem__(self, index, val):
181 if index == 0: self.SetRowspan(val)
182 elif index == 1: self.SetColspan(val)
183 else: raise IndexError
184 def __nonzero__(self): return self.Get() != (0,0)
185 __safe_for_unpickling__ = True
186 def __reduce__(self): return (wx.GBSpan, self.Get())
190 rowspan = property(GetRowspan, SetRowspan)
191 colspan = property(GetColspan, SetColspan)
197 const wxGBSpan wxDefaultSpan;
201 //---------------------------------------------------------------------------
204 DocStr(wxGBSizerItem,
205 "The wx.GBSizerItem class is used to track the additional data about
206 items in a `wx.GridBagSizer` such as the item's position in the grid
207 and how many rows or columns it spans.
209 class wxGBSizerItem : public wxSizerItem
214 "Constructs an empty wx.GBSizerItem. Either a window, sizer or spacer
215 size will need to be set, as well as a position and span before this
216 item can be used in a Sizer.
218 You will probably never need to create a wx.GBSizerItem directly as they
219 are created automatically when the sizer's Add method is called.", "");
222 DocStr(wxGBSizerItem( wxWindow *window, const wxGBPosition& pos,const wxGBSpan& span,int flag,int border,PyObject* userData=NULL ),
223 "Construct a `wx.GBSizerItem` for a window.", "");
224 %name(GBSizerItemWindow) wxGBSizerItem( wxWindow *window,
225 const wxGBPosition& pos,
226 const wxGBSpan& span,
229 PyObject* userData=NULL )
231 wxPyUserData* data = NULL;
233 bool blocked = wxPyBeginBlockThreads();
234 data = new wxPyUserData(userData);
235 wxPyEndBlockThreads(blocked);
237 return new wxGBSizerItem(window, pos, span, flag, border, data);
241 DocStr(wxGBSizerItem( wxSizer *sizer,const wxGBPosition& pos,const wxGBSpan& span,int flag,int border,PyObject* userData=NULL ),
242 "Construct a `wx.GBSizerItem` for a sizer", "");
243 %name(GBSizerItemSizer) wxGBSizerItem( wxSizer *sizer,
244 const wxGBPosition& pos,
245 const wxGBSpan& span,
248 PyObject* userData=NULL )
250 wxPyUserData* data = NULL;
252 bool blocked = wxPyBeginBlockThreads();
253 data = new wxPyUserData(userData);
254 wxPyEndBlockThreads(blocked);
256 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
260 DocStr(wxGBSizerItem( int width,int height,const wxGBPosition& pos,const wxGBSpan& span,int flag,int border,PyObject* userData=NULL),
261 "Construct a `wx.GBSizerItem` for a spacer.", "");
262 %name(GBSizerItemSpacer) wxGBSizerItem( int width,
264 const wxGBPosition& pos,
265 const wxGBSpan& span,
268 PyObject* userData=NULL)
270 wxPyUserData* data = NULL;
272 bool blocked = wxPyBeginBlockThreads();
273 data = new wxPyUserData(userData);
274 wxPyEndBlockThreads(blocked);
276 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
282 wxGBPosition , GetPos() const,
283 "Get the grid position of the item", "");
285 %pythoncode { def GetPosTuple(self): return self.GetPos().Get() }
290 wxGBSpan , GetSpan() const,
291 "Get the row and column spanning of the item", "");
293 %pythoncode { def GetSpanTuple(self): return self.GetSpan().Get() }
298 bool , SetPos( const wxGBPosition& pos ),
299 "If the item is already a member of a sizer then first ensure that
300 there is no other item that would intersect with this one at the new
301 position, then set the new position. Returns True if the change is
302 successful and after the next Layout() the item will be moved.", "");
306 bool , SetSpan( const wxGBSpan& span ),
307 "If the item is already a member of a sizer then first ensure that
308 there is no other item that would intersect with this one with its new
309 spanning size, then set the new spanning. Returns True if the change
310 is successful and after the next Layout() the item will be resized.
316 bool , Intersects(const wxGBSizerItem& other),
317 "Returns True if this item and the other item instersect.", "");
321 bool , Intersects(const wxGBPosition& pos, const wxGBSpan& span),
322 "Returns True if the given pos/span would intersect with this item.", "",
328 "Get the row and column of the endpoint of this item.", "");
329 wxGBPosition GetEndPos() {
331 self->GetEndPos(row, col);
332 return wxGBPosition(row, col);
338 wxGridBagSizer* , GetGBSizer() const,
339 "Get the sizer this item is a member of.", "");
342 void , SetGBSizer(wxGridBagSizer* sizer),
343 "Set the sizer this item is a member of.", "");
348 //---------------------------------------------------------------------------
350 DocStr(wxGridBagSizer,
351 "A `wx.Sizer` that can lay out items in a virtual grid like a
352 `wx.FlexGridSizer` but in this case explicit positioning of the items
353 is allowed using `wx.GBPosition`, and items can optionally span more
354 than one row and/or column using `wx.GBSpan`. The total size of the
355 virtual grid is determined by the largest row and column that items are
356 positioned at, adjusted for spanning.
359 class wxGridBagSizer : public wxFlexGridSizer
363 wxGridBagSizer(int vgap = 0, int hgap = 0 ),
364 "Constructor, with optional parameters to specify the gap between the
365 rows and columns.", "");
370 "Add(self, item, GBPosition pos, GBSpan span=DefaultSpan, int flag=0,
371 int border=0, userData=None)",
373 "Adds an item to the sizer at the grid cell *pos*, optionally spanning
374 more than one row or column as specified with *span*. The remaining
375 args behave similarly to `wx.Sizer.Add`.
377 Returns True if the item was successfully placed at the given cell
378 position, False if something was already there.
380 bool Add( PyObject* item,
381 const wxGBPosition& pos,
382 const wxGBSpan& span = wxDefaultSpan,
385 PyObject* userData = NULL ) {
387 wxPyUserData* data = NULL;
388 bool blocked = wxPyBeginBlockThreads();
389 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
390 if ( userData && (info.window || info.sizer || info.gotSize) )
391 data = new wxPyUserData(userData);
392 wxPyEndBlockThreads(blocked);
394 // Now call the real Add method if a valid item type was found
396 return self->Add(info.window, pos, span, flag, border, data);
397 else if ( info.sizer )
398 return self->Add(info.sizer, pos, span, flag, border, data);
399 else if (info.gotSize)
400 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
401 pos, span, flag, border, data);
407 bool , Add( wxGBSizerItem *item ),
408 "Add(self, GBSizerItem item) -> bool",
409 "Add an item to the sizer using a `wx.GBSizerItem`. Returns True if
410 the item was successfully placed at its given cell position, False if
411 something was already there.", "",
415 wxSize , GetCellSize(int row, int col) const,
416 "Get the size of the specified cell, including hgap and
417 vgap. Only valid after a Layout.", "");
420 wxSize , GetEmptyCellSize() const,
421 "Get the size used for cells in the grid with no item.", "");
424 void , SetEmptyCellSize(const wxSize& sz),
425 "Set the size used for cells in the grid with no item.", "");
429 %nokwargs GetItemPosition;
430 %noautodoc GetItemPosition;
431 DocStr(GetItemPosition,
432 "GetItemPosition(self, item) -> GBPosition
434 Get the grid position of the specified *item* where *item* is either a
435 window or subsizer that is a member of this sizer, or a zero-based
436 index of an item.", "");
437 wxGBPosition GetItemPosition(wxWindow *window);
438 wxGBPosition GetItemPosition(wxSizer *sizer);
439 wxGBPosition GetItemPosition(size_t index);
442 %nokwargs SetItemPosition;
443 %noautodoc SetItemPosition;
444 DocStr(SetItemPosition,
445 "SetItemPosition(self, item, GBPosition pos) -> bool
447 Set the grid position of the specified *item* where *item* is either a
448 window or subsizer that is a member of this sizer, or a zero-based
449 index of an item. Returns True on success. If the move is not
450 allowed (because an item is already there) then False is returned.
452 bool SetItemPosition(wxWindow *window, const wxGBPosition& pos);
453 bool SetItemPosition(wxSizer *sizer, const wxGBPosition& pos);
454 bool SetItemPosition(size_t index, const wxGBPosition& pos);
458 %nokwargs GetItemSpan;
459 %noautodoc GetItemSpan;
461 "GetItemSpan(self, item) -> GBSpan
463 Get the row/col spanning of the specified *item* where *item* is
464 either a window or subsizer that is a member of this sizer, or a
465 zero-based index of an item.", "");
466 wxGBSpan GetItemSpan(wxWindow *window);
467 wxGBSpan GetItemSpan(wxSizer *sizer);
468 wxGBSpan GetItemSpan(size_t index);
472 %nokwargs SetItemSpan;
473 %noautodoc SetItemSpan;
475 "SetItemSpan(self, item, GBSpan span) -> bool
477 Set the row/col spanning of the specified *item* where *item* is
478 either a window or subsizer that is a member of this sizer, or a
479 zero-based index of an item. Returns True on success. If the move is
480 not allowed (because an item is already there) then False is returned.", "");
481 bool SetItemSpan(wxWindow *window, const wxGBSpan& span);
482 bool SetItemSpan(wxSizer *sizer, const wxGBSpan& span);
483 bool SetItemSpan(size_t index, const wxGBSpan& span);
490 "FindItem(self, item) -> GBSizerItem
492 Find the sizer item for the given window or subsizer, returns None if
493 not found. (non-recursive)", "");
494 wxGBSizerItem* FindItem(wxWindow* window);
495 wxGBSizerItem* FindItem(wxSizer* sizer);
499 wxGBSizerItem* , FindItemAtPosition(const wxGBPosition& pos),
500 "Return the sizer item for the given grid cell, or None if there is no
501 item at that position. (non-recursive)", "");
506 wxGBSizerItem* , FindItemAtPoint(const wxPoint& pt),
507 "Return the sizer item located at the point given in *pt*, or None if
508 there is no item at that point. The (x,y) coordinates in pt correspond
509 to the client coordinates of the window using the sizer for
510 layout. (non-recursive)", "");
515 // wxGBSizerItem* , FindItemWithData(const wxObject* userData),
516 // "Return the sizer item that has a matching user data (it only compares
517 // pointer values) or None if not found. (non-recursive)", "");
521 // Look at all items and see if any intersect (or would overlap) the given
522 // item. Returns True if so, False if there would be no overlap. If an
523 // excludeItem is given then it will not be checked for intersection, for
524 // example it may be the item we are checking the position of.
528 bool , CheckForIntersection(wxGBSizerItem* item, wxGBSizerItem* excludeItem = NULL),
529 "Look at all items and see if any intersect (or would overlap) the
530 given *item*. Returns True if so, False if there would be no overlap.
531 If an *excludeItem* is given then it will not be checked for
532 intersection, for example it may be the item we are checking the
537 bool , CheckForIntersection(const wxGBPosition& pos, const wxGBSpan& span, wxGBSizerItem* excludeItem = NULL),
538 "Look at all items and see if any intersect (or would overlap) the
539 given position and span. Returns True if so, False if there would be
540 no overlap. If an *excludeItem* is given then it will not be checked
541 for intersection, for example it may be the item we are checking the
543 CheckForIntersectionPos);
549 //---------------------------------------------------------------------------