]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/_sizers.i
Don't use deprecated list methods
[wxWidgets.git] / wxPython / src / _sizers.i
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: _sizers.i
3 // Purpose: SWIG interface defs for the Sizers
4 //
5 // Author: Robin Dunn
6 //
7 // Created: 18-Sept-1999
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 %newgroup;
23
24
25 class wxSizerItem : public wxObject {
26 public:
27 wxSizerItem();
28
29 %name(SizerItemSpacer) wxSizerItem( int width, int height, int proportion, int flag, int border, wxObject* userData);
30 %name(SizerItemWindow) wxSizerItem( wxWindow *window, int proportion, int flag, int border, wxObject* userData );
31 %name(SizerItemSizer) wxSizerItem( wxSizer *sizer, int proportion, int flag, int border, wxObject* userData );
32
33 void DeleteWindows();
34 void DetachSizer();
35
36 wxSize GetSize();
37 wxSize CalcMin();
38 void SetDimension( wxPoint pos, wxSize size );
39
40 wxSize GetMinSize();
41 void SetInitSize( int x, int y );
42
43 %name(SetRatioWH) void SetRatio( int width, int height );
44 %name(SetRatioSize) void SetRatio( wxSize size );
45 void SetRatio( float ratio );
46 float GetRatio();
47
48 bool IsWindow();
49 bool IsSizer();
50 bool IsSpacer();
51
52 void SetProportion( int proportion );
53 int GetProportion();
54 %pythoncode { SetOption = SetProportion}
55 %pythoncode { GetOption = GetProportion}
56
57 void SetFlag( int flag );
58 int GetFlag();
59
60 void SetBorder( int border );
61 int GetBorder();
62
63 wxWindow *GetWindow();
64 void SetWindow( wxWindow *window );
65
66 wxSizer *GetSizer();
67 void SetSizer( wxSizer *sizer );
68
69 const wxSize& GetSpacer();
70 void SetSpacer( const wxSize &size );
71
72 void Show( bool show );
73 bool IsShown();
74
75 wxPoint GetPosition();
76
77 // wxObject* GetUserData();
78 %extend {
79 // Assume that the user data is a wxPyUserData object and return the contents
80 PyObject* GetUserData() {
81 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
82 if (data) {
83 Py_INCREF(data->m_obj);
84 return data->m_obj;
85 } else {
86 Py_INCREF(Py_None);
87 return Py_None;
88 }
89 }
90 }
91 };
92
93
94 //---------------------------------------------------------------------------
95
96 %{
97 // Figure out the type of the sizer item
98
99 struct wxPySizerItemInfo {
100 wxPySizerItemInfo()
101 : window(NULL), sizer(NULL), gotSize(False),
102 size(wxDefaultSize), gotPos(False), pos(-1)
103 {}
104
105 wxWindow* window;
106 wxSizer* sizer;
107 bool gotSize;
108 wxSize size;
109 bool gotPos;
110 int pos;
111 };
112
113 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
114
115 wxPySizerItemInfo info;
116 wxSize size;
117 wxSize* sizePtr = &size;
118
119 // Find out what the type of the item is
120 // try wxWindow
121 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
122 PyErr_Clear();
123 info.window = NULL;
124
125 // try wxSizer
126 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
127 PyErr_Clear();
128 info.sizer = NULL;
129
130 // try wxSize or (w,h)
131 if ( checkSize && wxSize_helper(item, &sizePtr)) {
132 info.size = *sizePtr;
133 info.gotSize = True;
134 }
135
136 // or a single int
137 if (checkIdx && PyInt_Check(item)) {
138 info.pos = PyInt_AsLong(item);
139 info.gotPos = True;
140 }
141 }
142 }
143
144 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
145 // no expected type, figure out what kind of error message to generate
146 if ( !checkSize && !checkIdx )
147 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
148 else if ( checkSize && !checkIdx )
149 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
150 else if ( !checkSize && checkIdx)
151 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
152 else
153 // can this one happen?
154 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
155 }
156
157 return info;
158 }
159 %}
160
161
162
163
164 class wxSizer : public wxObject {
165 public:
166 // wxSizer(); **** abstract, can't instantiate
167 // ~wxSizer();
168
169 %extend {
170 void _setOORInfo(PyObject* _self) {
171 self->SetClientObject(new wxPyOORClientData(_self));
172 }
173
174
175 void Add(PyObject* item, int proportion=0, int flag=0, int border=0,
176 PyObject* userData=NULL) {
177
178 wxPyUserData* data = NULL;
179 bool blocked = wxPyBeginBlockThreads();
180 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, True, False);
181 if ( userData && (info.window || info.sizer || info.gotSize) )
182 data = new wxPyUserData(userData);
183 wxPyEndBlockThreads(blocked);
184
185 // Now call the real Add method if a valid item type was found
186 if ( info.window )
187 self->Add(info.window, proportion, flag, border, data);
188 else if ( info.sizer )
189 self->Add(info.sizer, proportion, flag, border, data);
190 else if (info.gotSize)
191 self->Add(info.size.GetWidth(), info.size.GetHeight(),
192 proportion, flag, border, data);
193 }
194
195
196 void Insert(int before, PyObject* item, int proportion=0, int flag=0,
197 int border=0, PyObject* userData=NULL) {
198
199 wxPyUserData* data = NULL;
200 bool blocked = wxPyBeginBlockThreads();
201 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, True, False);
202 if ( userData && (info.window || info.sizer || info.gotSize) )
203 data = new wxPyUserData(userData);
204 wxPyEndBlockThreads(blocked);
205
206 // Now call the real Insert method if a valid item type was found
207 if ( info.window )
208 self->Insert(before, info.window, proportion, flag, border, data);
209 else if ( info.sizer )
210 self->Insert(before, info.sizer, proportion, flag, border, data);
211 else if (info.gotSize)
212 self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
213 proportion, flag, border, data);
214 }
215
216
217
218 void Prepend(PyObject* item, int proportion=0, int flag=0, int border=0,
219 PyObject* userData=NULL) {
220
221 wxPyUserData* data = NULL;
222 bool blocked = wxPyBeginBlockThreads();
223 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, True, False);
224 if ( userData && (info.window || info.sizer || info.gotSize) )
225 data = new wxPyUserData(userData);
226 wxPyEndBlockThreads(blocked);
227
228 // Now call the real Prepend method if a valid item type was found
229 if ( info.window )
230 self->Prepend(info.window, proportion, flag, border, data);
231 else if ( info.sizer )
232 self->Prepend(info.sizer, proportion, flag, border, data);
233 else if (info.gotSize)
234 self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
235 proportion, flag, border, data);
236 }
237
238
239 bool Remove(PyObject* item) {
240 bool blocked = wxPyBeginBlockThreads();
241 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, True);
242 wxPyEndBlockThreads(blocked);
243 if ( info.window )
244 return self->Remove(info.window);
245 else if ( info.sizer )
246 return self->Remove(info.sizer);
247 else if ( info.gotPos )
248 return self->Remove(info.pos);
249 else
250 return False;
251 }
252
253
254 void _SetItemMinSize(PyObject* item, const wxSize& size) {
255 bool blocked = wxPyBeginBlockThreads();
256 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, True);
257 wxPyEndBlockThreads(blocked);
258 if ( info.window )
259 self->SetItemMinSize(info.window, size);
260 else if ( info.sizer )
261 self->SetItemMinSize(info.sizer, size);
262 else if ( info.gotPos )
263 self->SetItemMinSize(info.pos, size);
264 }
265 }
266
267 %name(AddItem) void Add( wxSizerItem *item );
268 %name(InsertItem) void Insert( size_t index, wxSizerItem *item );
269 %name(PrependItem) void Prepend( wxSizerItem *item );
270
271
272 %pythoncode {
273 def AddMany(self, widgets):
274 """
275 AddMany is a convenience method for adding several items
276 to a sizer at one time. Simply pass it a list of tuples,
277 where each tuple consists of the parameters that you
278 would normally pass to the `Add` method.
279 """
280 for childinfo in widgets:
281 if type(childinfo) != type(()) or (len(childinfo) == 2 and type(childinfo[0]) == type(1)):
282 childinfo = (childinfo, )
283 self.Add(*childinfo)
284
285 %# for backwards compatibility only, please do not use in new code
286 AddWindow = wx._deprecated(Add, "AddWindow is deprecated, use `Add` instead.")
287 AddSizer = wx._deprecated(Add, "AddSizer is deprecated, use `Add` instead.")
288 AddSpacer = wx._deprecated(Add, "AddSpacer is deprecated, use `Add` instead.")
289 PrependWindow = wx._deprecated(Prepend, "PrependWindow is deprecated, use `Prepend` instead.")
290 PrependSizer = wx._deprecated(Prepend, "PrependSizer is deprecated, use `Prepend` instead.")
291 PrependSpacer = wx._deprecated(Prepend, "PrependSpacer is deprecated, use `Prepend` instead.")
292 InsertWindow = wx._deprecated(Insert, "InsertWindow is deprecated, use `Insert` instead.")
293 InsertSizer = wx._deprecated(Insert, "InsertSizer is deprecated, use `Insert` instead.")
294 InsertSpacer = wx._deprecated(Insert, "InsertSpacer is deprecated, use `Insert` instead.")
295 RemoveWindow = wx._deprecated(Remove, "RemoveWindow is deprecated, use `Remove` instead.")
296 RemoveSizer = wx._deprecated(Remove, "RemoveSizer is deprecated, use `Remove` instead.")
297 RemovePos = wx._deprecated(Remove, "RemovePos is deprecated, use `Remove` instead.")
298
299
300 def SetItemMinSize(self, item, *args):
301 if len(args) == 2:
302 return self._SetItemMinSize(item, args)
303 else:
304 return self._SetItemMinSize(item, args[0])
305 }
306
307
308 void SetDimension( int x, int y, int width, int height );
309 void SetMinSize( const wxSize &size );
310
311 wxSize GetSize();
312 wxPoint GetPosition();
313 wxSize GetMinSize();
314
315 %pythoncode {
316 def GetSizeTuple(self):
317 return self.GetSize().asTuple()
318 def GetPositionTuple(self):
319 return self.GetPosition().asTuple()
320 def GetMinSizeTuple(self):
321 return self.GetMinSize().asTuple()
322 }
323
324 virtual void RecalcSizes();
325 virtual wxSize CalcMin();
326
327 void Layout();
328
329 wxSize Fit( wxWindow *window );
330 void FitInside( wxWindow *window );
331
332 void SetSizeHints( wxWindow *window );
333 void SetVirtualSizeHints( wxWindow *window );
334
335 void Clear( bool delete_windows=False );
336 void DeleteWindows();
337
338
339 // wxList& GetChildren();
340 %extend {
341 PyObject* GetChildren() {
342 wxSizerItemList& list = self->GetChildren();
343 return wxPy_ConvertList(&list);
344 }
345 }
346
347
348 // Manage whether individual windows or sub-sizers are considered
349 // in the layout calculations or not.
350
351 %extend {
352 void Show(PyObject* item, bool show = True) {
353 bool blocked = wxPyBeginBlockThreads();
354 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, False);
355 wxPyEndBlockThreads(blocked);
356 if ( info.window )
357 self->Show(info.window, show);
358 else if ( info.sizer )
359 self->Show(info.sizer, show);
360 }
361
362
363 void Hide(PyObject* item) {
364 bool blocked = wxPyBeginBlockThreads();
365 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, False);
366 wxPyEndBlockThreads(blocked);
367 if ( info.window )
368 self->Hide(info.window);
369 else if ( info.sizer )
370 self->Hide(info.sizer);
371 }
372
373
374 bool IsShown(PyObject* item) {
375 bool blocked = wxPyBeginBlockThreads();
376 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, False);
377 wxPyEndBlockThreads(blocked);
378 if ( info.window )
379 return self->IsShown(info.window);
380 else if ( info.sizer )
381 return self->IsShown(info.sizer);
382 else
383 return False;
384 }
385 }
386
387
388 // Recursively call wxWindow::Show() on all sizer items.
389 void ShowItems(bool show);
390
391 };
392
393
394 //---------------------------------------------------------------------------
395 // Use this one for deriving Python classes from
396 %{
397 // See pyclasses.h
398 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
399 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
400 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
401 %}
402
403
404
405 class wxPySizer : public wxSizer {
406 public:
407 %pythonAppend wxPySizer "self._setCallbackInfo(self, PySizer);self._setOORInfo(self)"
408
409 wxPySizer();
410 void _setCallbackInfo(PyObject* self, PyObject* _class);
411 };
412
413
414 //---------------------------------------------------------------------------
415 %newgroup;
416
417 class wxBoxSizer : public wxSizer {
418 public:
419 %pythonAppend wxBoxSizer "self._setOORInfo(self)"
420
421 wxBoxSizer(int orient = wxHORIZONTAL);
422
423 int GetOrientation();
424 void SetOrientation(int orient);
425 void RecalcSizes();
426 wxSize CalcMin();
427 };
428
429 //---------------------------------------------------------------------------
430 %newgroup;
431
432 class wxStaticBoxSizer : public wxBoxSizer {
433 public:
434 %pythonAppend wxStaticBoxSizer "self._setOORInfo(self)"
435
436 wxStaticBoxSizer(wxStaticBox *box, int orient = wxHORIZONTAL);
437
438 wxStaticBox *GetStaticBox();
439 void RecalcSizes();
440 wxSize CalcMin();
441 };
442
443 //---------------------------------------------------------------------------
444 %newgroup;
445
446 class wxGridSizer: public wxSizer
447 {
448 public:
449 %pythonAppend wxGridSizer "self._setOORInfo(self)"
450
451 wxGridSizer( int rows=1, int cols=0, int vgap=0, int hgap=0 );
452
453 void RecalcSizes();
454 wxSize CalcMin();
455
456 void SetCols( int cols );
457 void SetRows( int rows );
458 void SetVGap( int gap );
459 void SetHGap( int gap );
460 int GetCols();
461 int GetRows();
462 int GetVGap();
463 int GetHGap();
464 };
465
466 //---------------------------------------------------------------------------
467 %newgroup;
468
469 enum wxFlexSizerGrowMode
470 {
471 // don't resize the cells in non-flexible direction at all
472 wxFLEX_GROWMODE_NONE,
473
474 // uniformly resize only the specified ones (default)
475 wxFLEX_GROWMODE_SPECIFIED,
476
477 // uniformly resize all cells
478 wxFLEX_GROWMODE_ALL
479 };
480
481
482 class wxFlexGridSizer: public wxGridSizer
483 {
484 public:
485 %pythonAppend wxFlexGridSizer "self._setOORInfo(self)"
486
487 wxFlexGridSizer( int rows=1, int cols=0, int vgap=0, int hgap=0 );
488
489 void RecalcSizes();
490 wxSize CalcMin();
491
492 void AddGrowableRow( size_t idx, int proportion = 0 );
493 void RemoveGrowableRow( size_t idx );
494 void AddGrowableCol( size_t idx, int proportion = 0 );
495 void RemoveGrowableCol( size_t idx );
496
497 // the sizer cells may grow in both directions, not grow at all or only
498 // grow in one direction but not the other
499
500 // the direction may be wxVERTICAL, wxHORIZONTAL or wxBOTH (default)
501 void SetFlexibleDirection(int direction);
502 int GetFlexibleDirection();
503
504 // note that the grow mode only applies to the direction which is not
505 // flexible
506 void SetNonFlexibleGrowMode(wxFlexSizerGrowMode mode);
507 wxFlexSizerGrowMode GetNonFlexibleGrowMode();
508
509 // Read-only access to the row heights and col widths arrays
510 const wxArrayInt& GetRowHeights() const;
511 const wxArrayInt& GetColWidths() const;
512 };
513
514 //---------------------------------------------------------------------------