]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/_sizers.i
reSWIGged
[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 DocStr(wxSizerItem,
25 "The wx.SizerItem class is used to track the position, size and other
26 attributes of each item managed by a `wx.Sizer`. In normal usage user
27 code should never need to deal directly with a wx.SizerItem, but
28 custom classes derived from `wx.PySizer` will probably need to use the
29 collection of wx.SizerItems held by wx.Sizer when calculating layout.
30
31 :see: `wx.Sizer`, `wx.GBSizerItem`", "");
32
33 class wxSizerItem : public wxObject {
34 public:
35 DocCtorStr(
36 wxSizerItem(),
37 "Constructs an empty wx.SizerItem. Either a window, sizer or spacer
38 size will need to be set before this item can be used in a Sizer.
39
40 You will probably never need to create a wx.SizerItem directly as they
41 are created automatically when the sizer's Add, Insert or Prepend
42 methods are called.
43
44 :see: `wx.SizerItemSpacer`, `wx.SizerItemWindow`, `wx.SizerItemSizer`", "");
45
46
47
48 %extend {
49 DocStr(
50 wxSizerItem( wxWindow *window, int proportion, int flag,
51 int border, PyObject* userData=NULL ),
52 "Constructs a `wx.SizerItem` for tracking a window.", "");
53
54 %name(SizerItemWindow) wxSizerItem( wxWindow *window, int proportion, int flag,
55 int border, PyObject* userData=NULL ) {
56 wxPyUserData* data = NULL;
57 if ( userData ) {
58 bool blocked = wxPyBeginBlockThreads();
59 data = new wxPyUserData(userData);
60 wxPyEndBlockThreads(blocked);
61 }
62 return new wxSizerItem(window, proportion, flag, border, data);
63 }
64
65
66 DocStr(
67 wxSizerItem( int width, int height, int proportion, int flag,
68 int border, PyObject* userData=NULL),
69 "Constructs a `wx.SizerItem` for tracking a spacer.", "");
70 %name(SizerItemSpacer) wxSizerItem( int width, int height, int proportion, int flag,
71 int border, PyObject* userData=NULL) {
72 wxPyUserData* data = NULL;
73 if ( userData ) {
74 bool blocked = wxPyBeginBlockThreads();
75 data = new wxPyUserData(userData);
76 wxPyEndBlockThreads(blocked);
77 }
78 return new wxSizerItem(width, height, proportion, flag, border, data);
79 }
80
81 DocStr(
82 wxSizerItem( wxSizer *sizer, int proportion, int flag,
83 int border, PyObject* userData=NULL ),
84 "Constructs a `wx.SizerItem` for tracking a subsizer", "");
85 %name(SizerItemSizer) wxSizerItem( wxSizer *sizer, int proportion, int flag,
86 int border, PyObject* userData=NULL ) {
87 wxPyUserData* data = NULL;
88 if ( userData ) {
89 bool blocked = wxPyBeginBlockThreads();
90 data = new wxPyUserData(userData);
91 wxPyEndBlockThreads(blocked);
92 }
93 return new wxSizerItem(sizer, proportion, flag, border, data);
94 }
95 }
96
97
98
99 DocDeclStr(
100 void , DeleteWindows(),
101 "Destroy the window or the windows in a subsizer, depending on the type
102 of item.", "");
103
104 DocDeclStr(
105 void , DetachSizer(),
106 "Enable deleting the SizerItem without destroying the contained sizer.", "");
107
108
109 DocDeclStr(
110 wxSize , GetSize(),
111 "Get the current size of the item, as set in the last Layout.", "");
112
113 DocDeclStr(
114 wxSize , CalcMin(),
115 "Calculates the minimum desired size for the item, including any space
116 needed by borders.", "");
117
118 DocDeclStr(
119 void , SetDimension( wxPoint pos, wxSize size ),
120 "Set the position and size of the space allocated for this item by the
121 sizer, and adjust the position and size of the item (window or
122 subsizer) to be within that space taking alignment and borders into
123 account.", "");
124
125
126 DocDeclStr(
127 wxSize , GetMinSize(),
128 "Get the minimum size needed for the item.", "");
129
130 DocDeclStr(
131 wxSize , GetMinSizeWithBorder() const,
132 "Get the minimum size needed for the item with space for the borders
133 added, if needed.", "");
134
135 DocDeclStr(
136 void , SetInitSize( int x, int y ),
137 "", "");
138
139
140 DocStr(SetRatio,
141 "Set the ratio item attribute.", "");
142 %name(SetRatioWH) void SetRatio( int width, int height );
143 %name(SetRatioSize) void SetRatio( wxSize size );
144 void SetRatio( float ratio );
145
146 DocDeclStr(
147 float , GetRatio(),
148 "Set the ratio item attribute.", "");
149
150
151 DocDeclStr(
152 bool , IsWindow(),
153 "Is this sizer item a window?", "");
154
155 DocDeclStr(
156 bool , IsSizer(),
157 "Is this sizer item a subsizer?", "");
158
159 DocDeclStr(
160 bool , IsSpacer(),
161 "Is this sizer item a spacer?", "");
162
163
164 DocDeclStr(
165 void , SetProportion( int proportion ),
166 "Set the proportion value for this item.", "");
167
168 DocDeclStr(
169 int , GetProportion(),
170 "Get the proportion value for this item.", "");
171
172 %pythoncode { SetOption = wx._deprecated(SetProportion, "Please use `SetProportion` instead.") }
173 %pythoncode { GetOption = wx._deprecated(GetProportion, "Please use `GetProportion` instead.") }
174
175
176 DocDeclStr(
177 void , SetFlag( int flag ),
178 "Set the flag value for this item.", "");
179
180 DocDeclStr(
181 int , GetFlag(),
182 "Get the flag value for this item.", "");
183
184
185 DocDeclStr(
186 void , SetBorder( int border ),
187 "Set the border value for this item.", "");
188
189 DocDeclStr(
190 int , GetBorder(),
191 "Get the border value for this item.", "");
192
193
194
195 DocDeclStr(
196 wxWindow *, GetWindow(),
197 "Get the window (if any) that is managed by this sizer item.", "");
198
199 DocDeclStr(
200 void , SetWindow( wxWindow *window ),
201 "Set the window to be managed by this sizer item.", "");
202
203
204 DocDeclStr(
205 wxSizer *, GetSizer(),
206 "Get the subsizer (if any) that is managed by this sizer item.", "");
207
208 DocDeclStr(
209 void , SetSizer( wxSizer *sizer ),
210 "Set the subsizer to be managed by this sizer item.", "");
211
212
213 DocDeclStr(
214 const wxSize& , GetSpacer(),
215 "Get the size of the spacer managed by this sizer item.", "");
216
217 DocDeclStr(
218 void , SetSpacer( const wxSize &size ),
219 "Set the size of the spacer to be managed by this sizer item.", "");
220
221
222 DocDeclStr(
223 void , Show( bool show ),
224 "Set the show item attribute, which sizers use to determine if the item
225 is to be made part of the layout or not. If the item is tracking a
226 window then it is shown or hidden as needed.", "");
227
228 DocDeclStr(
229 bool , IsShown(),
230 "Is the item to be shown in the layout?", "");
231
232
233 DocDeclStr(
234 wxPoint , GetPosition(),
235 "Returns the current position of the item, as set in the last Layout.", "");
236
237
238 // wxObject* GetUserData();
239 %extend {
240 // Assume that the user data is a wxPyUserData object and return the contents
241
242 DocStr(GetUserData,
243 "Returns the userData associated with this sizer item, or None if there
244 isn't any.", "");
245 PyObject* GetUserData() {
246 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
247 if (data) {
248 Py_INCREF(data->m_obj);
249 return data->m_obj;
250 } else {
251 Py_INCREF(Py_None);
252 return Py_None;
253 }
254 }
255 }
256 };
257
258
259 //---------------------------------------------------------------------------
260
261 %{
262 // Figure out the type of the sizer item
263
264 struct wxPySizerItemInfo {
265 wxPySizerItemInfo()
266 : window(NULL), sizer(NULL), gotSize(False),
267 size(wxDefaultSize), gotPos(False), pos(-1)
268 {}
269
270 wxWindow* window;
271 wxSizer* sizer;
272 bool gotSize;
273 wxSize size;
274 bool gotPos;
275 int pos;
276 };
277
278 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
279
280 wxPySizerItemInfo info;
281 wxSize size;
282 wxSize* sizePtr = &size;
283
284 // Find out what the type of the item is
285 // try wxWindow
286 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
287 PyErr_Clear();
288 info.window = NULL;
289
290 // try wxSizer
291 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
292 PyErr_Clear();
293 info.sizer = NULL;
294
295 // try wxSize or (w,h)
296 if ( checkSize && wxSize_helper(item, &sizePtr)) {
297 info.size = *sizePtr;
298 info.gotSize = True;
299 }
300
301 // or a single int
302 if (checkIdx && PyInt_Check(item)) {
303 info.pos = PyInt_AsLong(item);
304 info.gotPos = True;
305 }
306 }
307 }
308
309 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
310 // no expected type, figure out what kind of error message to generate
311 if ( !checkSize && !checkIdx )
312 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
313 else if ( checkSize && !checkIdx )
314 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
315 else if ( !checkSize && checkIdx)
316 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
317 else
318 // can this one happen?
319 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
320 }
321
322 return info;
323 }
324 %}
325
326
327
328
329 DocStr(wxSizer,
330 "wx.Sizer is the abstract base class used for laying out subwindows in
331 a window. You cannot use wx.Sizer directly; instead, you will have to
332 use one of the sizer classes derived from it such as `wx.BoxSizer`,
333 `wx.StaticBoxSizer`, `wx.NotebookSizer`, `wx.GridSizer`, `wx.FlexGridSizer`
334 and `wx.GridBagSizer`.
335
336 The concept implemented by sizers in wxWidgets is closely related to
337 layout tools in other GUI toolkits, such as Java's AWT, the GTK
338 toolkit or the Qt toolkit. It is based upon the idea of the individual
339 subwindows reporting their minimal required size and their ability to
340 get stretched if the size of the parent window has changed. This will
341 most often mean that the programmer does not set the original size of
342 a dialog in the beginning, rather the dialog will assigned a sizer and
343 this sizer will be queried about the recommended size. The sizer in
344 turn will query its children, which can be normal windows or contorls,
345 empty space or other sizers, so that a hierarchy of sizers can be
346 constructed. Note that wxSizer does not derive from wxWindow and thus
347 do not interfere with tab ordering and requires very little resources
348 compared to a real window on screen.
349
350 What makes sizers so well fitted for use in wxWidgets is the fact that
351 every control reports its own minimal size and the algorithm can
352 handle differences in font sizes or different window (dialog item)
353 sizes on different platforms without problems. If for example the
354 standard font as well as the overall design of Mac widgets requires
355 more space than on Windows, then the initial size of a dialog using a
356 sizer will automatically be bigger on Mac than on Windows.", "
357
358 :note: If you wish to create a custom sizer class in wxPython you
359 should derive the class from `wx.PySizer` in order to get
360 Python-aware capabilities for the various virtual methods.
361
362 :see: `wx.SizerItem`
363
364 :todo: More dscriptive text here along with some pictures...
365
366 ");
367
368 class wxSizer : public wxObject {
369 public:
370 // wxSizer(); **** abstract, can't instantiate
371 // ~wxSizer();
372
373 %extend {
374 void _setOORInfo(PyObject* _self) {
375 if (!self->GetClientObject())
376 self->SetClientObject(new wxPyOORClientData(_self));
377 }
378
379 DocAStr(Add,
380 "Add(self, item, int proportion=0, int flag=0, int border=0,
381 PyObject userData=None)",
382
383 "Appends a child item to the sizer.", "
384
385 :param item: The item can be one of three kinds of objects:
386
387 - **window**: A `wx.Window` to be managed by the sizer. Its
388 minimal size (either set explicitly by the user or
389 calculated internally when constructed with wx.DefaultSize)
390 is interpreted as the minimal size to use when laying out
391 item in the sizer. This is particularly useful in
392 connection with `wx.Window.SetSizeHints`.
393
394 - **sizer**: The (child-)sizer to be added to the sizer. This
395 allows placing a child sizer in a sizer and thus to create
396 hierarchies of sizers (typically a vertical box as the top
397 sizer and several horizontal boxes on the level beneath).
398
399 - **size**: A `wx.Size` or a 2-element sequence of integers
400 that represents the width and height of a spacer to be added
401 to the sizer. Adding spacers to sizers gives more
402 flexibility in the design of dialogs; imagine for example a
403 horizontal box with two buttons at the bottom of a dialog:
404 you might want to insert a space between the two buttons and
405 make that space stretchable using the *proportion* value and
406 the result will be that the left button will be aligned with
407 the left side of the dialog and the right button with the
408 right side - the space in between will shrink and grow with
409 the dialog.
410
411 :param proportion: Although the meaning of this parameter is
412 undefined in wx.Sizer, it is used in `wx.BoxSizer` to indicate
413 if a child of a sizer can change its size in the main
414 orientation of the wx.BoxSizer - where 0 stands for not
415 changeable and a value of more than zero is interpreted
416 relative (a proportion of the total) to the value of other
417 children of the same wx.BoxSizer. For example, you might have
418 a horizontal wx.BoxSizer with three children, two of which are
419 supposed to change their size with the sizer. Then the two
420 stretchable windows should each be given *proportion* value of
421 1 to make them grow and shrink equally with the sizer's
422 horizontal dimension. But if one of them had a *proportion*
423 value of 2 then it would get a double share of the space
424 available after the fixed size items are positioned.
425
426 :param flag: This parameter can be used to set a number of flags
427 which can be combined using the binary OR operator ``|``. Two
428 main behaviours are defined using these flags. One is the
429 border around a window: the *border* parameter determines the
430 border width whereas the flags given here determine which
431 side(s) of the item that the border will be added. The other
432 flags determine how the sizer item behaves when the space
433 allotted to the sizer changes, and is somewhat dependent on
434 the specific kind of sizer used.
435
436 +----------------------------+------------------------------------------+
437 |- wx.TOP |These flags are used to specify |
438 |- wx.BOTTOM |which side(s) of the sizer item that |
439 |- wx.LEFT |the *border* width will apply to. |
440 |- wx.RIGHT | |
441 |- wx.ALL | |
442 | | |
443 +----------------------------+------------------------------------------+
444 |- wx.EXAPAND |The item will be expanded to fill |
445 | |the space allotted to the item. |
446 +----------------------------+------------------------------------------+
447 |- wx.SHAPED |The item will be expanded as much as |
448 | |possible while also maintaining its |
449 | |aspect ratio |
450 +----------------------------+------------------------------------------+
451 |- wx.FIXED_MINSIZE |Normally wx.Sizers will use |
452 | |`wx.Window.GetMinSize` or |
453 | |`wx.Window.GetBestSize` to determine what |
454 | |the minimal size of window items should |
455 | |be, and will use that size to calculate |
456 | |the layout. This allows layouts to adjust |
457 | |when an item changes and it's best size |
458 | |becomes different. If you would rather |
459 | |have a window item stay the size it |
460 | |started with then use wx.FIXED_MINSIZE. |
461 +----------------------------+------------------------------------------+
462 |- wx.ALIGN_CENTER |The wx.ALIGN flags allow you to specify |
463 |- wx.ALIGN_LEFT |the alignment of the item within the space|
464 |- wx.ALIGN_RIGHT |allotted to it by the sizer, ajusted for |
465 |- wx.ALIGN_TOP |the border if any. |
466 |- wx.ALIGN_BOTTOM | |
467 |- wx.ALIGN_CENTER_VERTICAL | |
468 |- wx.ALIGN_CENTER_HORIZONTAL| |
469 +----------------------------+------------------------------------------+
470
471
472 :param border: Determines the border width, if the *flag*
473 parameter is set to include any border flag.
474
475 :param userData: Allows an extra object to be attached to the
476 sizer item, for use in derived classes when sizing information
477 is more complex than the *proportion* and *flag* will allow for.
478 ");
479
480 void Add(PyObject* item, int proportion=0, int flag=0, int border=0,
481 PyObject* userData=NULL) {
482
483 wxPyUserData* data = NULL;
484 bool blocked = wxPyBeginBlockThreads();
485 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, True, False);
486 if ( userData && (info.window || info.sizer || info.gotSize) )
487 data = new wxPyUserData(userData);
488 wxPyEndBlockThreads(blocked);
489
490 // Now call the real Add method if a valid item type was found
491 if ( info.window )
492 self->Add(info.window, proportion, flag, border, data);
493 else if ( info.sizer )
494 self->Add(info.sizer, proportion, flag, border, data);
495 else if (info.gotSize)
496 self->Add(info.size.GetWidth(), info.size.GetHeight(),
497 proportion, flag, border, data);
498 }
499
500 // virtual void AddSpacer(int size);
501 // virtual void AddStretchSpacer(int prop = 1);
502
503 DocAStr(Insert,
504 "Insert(self, int before, item, int proportion=0, int flag=0, int border=0,
505 PyObject userData=None)",
506
507 "Inserts a new item into the list of items managed by this sizer before
508 the item at index *before*. See `Add` for a description of the parameters.", "");
509 void Insert(int before, PyObject* item, int proportion=0, int flag=0,
510 int border=0, PyObject* userData=NULL) {
511
512 wxPyUserData* data = NULL;
513 bool blocked = wxPyBeginBlockThreads();
514 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, True, False);
515 if ( userData && (info.window || info.sizer || info.gotSize) )
516 data = new wxPyUserData(userData);
517 wxPyEndBlockThreads(blocked);
518
519 // Now call the real Insert method if a valid item type was found
520 if ( info.window )
521 self->Insert(before, info.window, proportion, flag, border, data);
522 else if ( info.sizer )
523 self->Insert(before, info.sizer, proportion, flag, border, data);
524 else if (info.gotSize)
525 self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
526 proportion, flag, border, data);
527 }
528
529
530 // virtual void InsertSpacer(size_t index, int size);
531 // virtual void InsertStretchSpacer(size_t index, int prop = 1);
532
533 DocAStr(Prepend,
534 "Prepend(self, item, int proportion=0, int flag=0, int border=0,
535 PyObject userData=None)",
536
537 "Adds a new item to the begining of the list of sizer items managed by
538 this sizer. See `Add` for a description of the parameters.", "");
539 void Prepend(PyObject* item, int proportion=0, int flag=0, int border=0,
540 PyObject* userData=NULL) {
541
542 wxPyUserData* data = NULL;
543 bool blocked = wxPyBeginBlockThreads();
544 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, True, False);
545 if ( userData && (info.window || info.sizer || info.gotSize) )
546 data = new wxPyUserData(userData);
547 wxPyEndBlockThreads(blocked);
548
549 // Now call the real Prepend method if a valid item type was found
550 if ( info.window )
551 self->Prepend(info.window, proportion, flag, border, data);
552 else if ( info.sizer )
553 self->Prepend(info.sizer, proportion, flag, border, data);
554 else if (info.gotSize)
555 self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
556 proportion, flag, border, data);
557 }
558
559 // virtual void PrependSpacer(int size);
560 // virtual void PrependStretchSpacer(int prop = 1);
561
562 DocAStr(Remove,
563 "Remove(self, item) -> bool",
564 "Removes an item from the sizer and destroys it. This method does not
565 cause any layout or resizing to take place, call `Layout` to update
566 the layout on screen after removing a child from the sizer. The
567 *item* parameter can be either a window, a sizer, or the zero-based
568 index of an item to remove. Returns True if the child item was found
569 and removed.", "
570
571 :note: For historical reasons calling this method with a `wx.Window`
572 parameter is depreacted, as it will not be able to destroy the
573 window since it is owned by its parent. You should use `Detach`
574 instead.
575 ");
576 bool Remove(PyObject* item) {
577 bool blocked = wxPyBeginBlockThreads();
578 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, True);
579 wxPyEndBlockThreads(blocked);
580 if ( info.window )
581 return self->Remove(info.window);
582 else if ( info.sizer )
583 return self->Remove(info.sizer);
584 else if ( info.gotPos )
585 return self->Remove(info.pos);
586 else
587 return False;
588 }
589
590
591 DocAStr(Detach,
592 "Detach(self, item) -> bool",
593 "Detaches an item from the sizer without destroying it. This method
594 does not cause any layout or resizing to take place, call `Layout` to
595 do so. The *item* parameter can be either a window, a sizer, or the
596 zero-based index of the item to be detached. Returns True if the child item
597 was found and detached.", "");
598 bool Detach(PyObject* item) {
599 bool blocked = wxPyBeginBlockThreads();
600 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, True);
601 wxPyEndBlockThreads(blocked);
602 if ( info.window )
603 return self->Detach(info.window);
604 else if ( info.sizer )
605 return self->Detach(info.sizer);
606 else if ( info.gotPos )
607 return self->Detach(info.pos);
608 else
609 return False;
610 }
611
612
613 void _SetItemMinSize(PyObject* item, const wxSize& size) {
614 bool blocked = wxPyBeginBlockThreads();
615 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, True);
616 wxPyEndBlockThreads(blocked);
617 if ( info.window )
618 self->SetItemMinSize(info.window, size);
619 else if ( info.sizer )
620 self->SetItemMinSize(info.sizer, size);
621 else if ( info.gotPos )
622 self->SetItemMinSize(info.pos, size);
623 }
624 }
625
626 %pythoncode {
627 def SetItemMinSize(self, item, *args):
628 """
629 SetItemMinSize(self, item, Size size)
630
631 Sets the minimum size that will be allocated for an item in the sizer.
632 The *item* parameter can be either a window, a sizer, or the
633 zero-based index of the item. If a window or sizer is given then it
634 will be searched for recursivly in subsizers if neccessary.
635 """
636 if len(args) == 2:
637 %# for backward compatibility accept separate width,height args too
638 return self._SetItemMinSize(item, args)
639 else:
640 return self._SetItemMinSize(item, args[0])
641 }
642
643 DocDeclAStrName(
644 void , Add( wxSizerItem *item ),
645 "AddItem(self, SizerItem item)",
646 "Adds a `wx.SizerItem` to the sizer.", "",
647 AddItem);
648
649 DocDeclAStrName(
650 void , Insert( size_t index, wxSizerItem *item ),
651 "InsertItem(self, int index, SizerItem item)",
652 "Inserts a `wx.SizerItem` to the sizer at the position given by *index*.", "",
653 InsertItem);
654
655 DocDeclAStrName(
656 void , Prepend( wxSizerItem *item ),
657 "PrependItem(self, SizerItem item)",
658 "Prepends a `wx.SizerItem` to the sizer.", "",
659 PrependItem);
660
661
662
663 %pythoncode {
664 def AddMany(self, items):
665 """
666 AddMany is a convenience method for adding several items
667 to a sizer at one time. Simply pass it a list of tuples,
668 where each tuple consists of the parameters that you
669 would normally pass to the `Add` method.
670 """
671 for item in items:
672 if type(item) != type(()) or (len(item) == 2 and type(item[0]) == type(1)):
673 item = (item, )
674 self.Add(*item)
675
676 %# for backwards compatibility only, please do not use in new code
677 AddWindow = wx._deprecated(Add, "AddWindow is deprecated, use `Add` instead.")
678 AddSizer = wx._deprecated(Add, "AddSizer is deprecated, use `Add` instead.")
679 AddSpacer = wx._deprecated(Add, "AddSpacer is deprecated, use `Add` instead.")
680 PrependWindow = wx._deprecated(Prepend, "PrependWindow is deprecated, use `Prepend` instead.")
681 PrependSizer = wx._deprecated(Prepend, "PrependSizer is deprecated, use `Prepend` instead.")
682 PrependSpacer = wx._deprecated(Prepend, "PrependSpacer is deprecated, use `Prepend` instead.")
683 InsertWindow = wx._deprecated(Insert, "InsertWindow is deprecated, use `Insert` instead.")
684 InsertSizer = wx._deprecated(Insert, "InsertSizer is deprecated, use `Insert` instead.")
685 InsertSpacer = wx._deprecated(Insert, "InsertSpacer is deprecated, use `Insert` instead.")
686 RemoveWindow = wx._deprecated(Remove, "RemoveWindow is deprecated, use `Remove` instead.")
687 RemoveSizer = wx._deprecated(Remove, "RemoveSizer is deprecated, use `Remove` instead.")
688 RemovePos = wx._deprecated(Remove, "RemovePos is deprecated, use `Remove` instead.")
689
690 }
691
692
693 DocDeclStr(
694 void , SetDimension( int x, int y, int width, int height ),
695 "Call this to force the sizer to take the given dimension and thus
696 force the items owned by the sizer to resize themselves according to
697 the rules defined by the parameter in the `Add`, `Insert` or `Prepend`
698 methods.", "");
699
700 DocDeclStr(
701 void , SetMinSize( const wxSize &size ),
702 "Call this to give the sizer a minimal size. Normally, the sizer will
703 calculate its minimal size based purely on how much space its children
704 need. After calling this method `GetMinSize` will return either the
705 minimal size as requested by its children or the minimal size set
706 here, depending on which is bigger.", "");
707
708
709 DocDeclStr(
710 wxSize , GetSize(),
711 "Returns the current size of the space managed by the sizer.", "");
712
713 DocDeclStr(
714 wxPoint , GetPosition(),
715 "Returns the current position of the sizer's managed space.", "");
716
717 DocDeclStr(
718 wxSize , GetMinSize(),
719 "Returns the minimal size of the sizer. This is either the combined
720 minimal size of all the children and their borders or the minimal size
721 set by SetMinSize, depending on which is bigger.", "");
722
723
724 %pythoncode {
725 def GetSizeTuple(self):
726 return self.GetSize().Get()
727 def GetPositionTuple(self):
728 return self.GetPosition().Get()
729 def GetMinSizeTuple(self):
730 return self.GetMinSize().Get()
731 }
732
733 DocDeclStr(
734 virtual void , RecalcSizes(),
735 "Using the sizes calculated by `CalcMin` reposition and resize all the
736 items managed by this sizer. You should not need to call this directly as
737 it is called by `Layout`.", "");
738
739 DocDeclStr(
740 virtual wxSize , CalcMin(),
741 "This method is where the sizer will do the actual calculation of its
742 children's minimal sizes. You should not need to call this directly as
743 it is called by `Layout`.", "");
744
745
746 DocDeclStr(
747 void , Layout(),
748 "This method will force the recalculation and layout of the items
749 controlled by the sizer using the current space allocated to the
750 sizer. Normally this is called automatically from the owning window's
751 EVT_SIZE handler, but it is also useful to call it from user code when
752 one of the items in a sizer change size, or items are added or
753 removed.", "");
754
755
756 DocDeclStr(
757 wxSize , Fit( wxWindow *window ),
758 "Tell the sizer to resize the *window* to match the sizer's minimal
759 size. This is commonly done in the constructor of the window itself in
760 order to set its initial size to match the needs of the children as
761 determined by the sizer. Returns the new size.
762
763 For a top level window this is the total window size, not the client size.", "");
764
765 DocDeclStr(
766 void , FitInside( wxWindow *window ),
767 "Tell the sizer to resize the *virtual size* of the *window* to match the
768 sizer's minimal size. This will not alter the on screen size of the
769 window, but may cause the addition/removal/alteration of scrollbars
770 required to view the virtual area in windows which manage it.
771
772 :see: `wx.ScrolledWindow.SetScrollbars`, `SetVirtualSizeHints`
773 ", "");
774
775
776 DocDeclStr(
777 void , SetSizeHints( wxWindow *window ),
778 "Tell the sizer to set (and `Fit`) the minimal size of the *window* to
779 match the sizer's minimal size. This is commonly done in the
780 constructor of the window itself if the window is resizable (as are
781 many dialogs under Unix and frames on probably all platforms) in order
782 to prevent the window from being sized smaller than the minimal size
783 required by the sizer.", "");
784
785 DocDeclStr(
786 void , SetVirtualSizeHints( wxWindow *window ),
787 "Tell the sizer to set the minimal size of the window virtual area to
788 match the sizer's minimal size. For windows with managed scrollbars
789 this will set them appropriately.
790
791 :see: `wx.ScrolledWindow.SetScrollbars`
792 ", "");
793
794
795 DocDeclStr(
796 void , Clear( bool deleteWindows=False ),
797 "Clear all items from the sizer, optionally destroying the window items
798 as well.", "");
799
800 DocDeclStr(
801 void , DeleteWindows(),
802 "Destroy all windows managed by the sizer.", "");
803
804
805
806 // wxList& GetChildren();
807 %extend {
808 DocAStr(GetChildren,
809 "GetChildren(sefl) -> list",
810 "Returns a list of all the `wx.SizerItem` objects managed by the sizer.", "");
811 PyObject* GetChildren() {
812 wxSizerItemList& list = self->GetChildren();
813 return wxPy_ConvertList(&list);
814 }
815 }
816
817
818 // Manage whether individual windows or subsizers are considered
819 // in the layout calculations or not.
820
821 %extend {
822 DocAStr(Show,
823 "Show(self, item, bool show=True)",
824 "Shows or hides an item managed by the sizer. To make a sizer item
825 disappear or reappear, use Show followed by `Layout`. The *item*
826 parameter can be either a window, a sizer, or the zero-based index of
827 the item.", "");
828 void Show(PyObject* item, bool show = True) {
829 bool blocked = wxPyBeginBlockThreads();
830 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, True);
831 wxPyEndBlockThreads(blocked);
832 if ( info.window )
833 self->Show(info.window, show);
834 else if ( info.sizer )
835 self->Show(info.sizer, show);
836 else if ( info.gotPos )
837 self->Show(info.pos, show);
838 }
839
840 DocAStr(IsShown,
841 "IsShown(self, item)",
842 "Determines if the item is currently shown. sizer. To make a sizer
843 item disappear or reappear, use Show followed by `Layout`. The *item*
844 parameter can be either a window, a sizer, or the zero-based index of
845 the item.", "");
846 bool IsShown(PyObject* item) {
847 bool blocked = wxPyBeginBlockThreads();
848 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, False);
849 wxPyEndBlockThreads(blocked);
850 if ( info.window )
851 return self->IsShown(info.window);
852 else if ( info.sizer )
853 return self->IsShown(info.sizer);
854 else if ( info.gotPos )
855 return self->IsShown(info.pos);
856 else
857 return False;
858 }
859 }
860
861 %pythoncode {
862 def Hide(self, item):
863 """
864 A convenience method for Show(item, False).
865 """
866 self.Show(item, False)
867 }
868
869
870 DocDeclStr(
871 void , ShowItems(bool show),
872 "Recursively call `wx.Window.Show` on all sizer items.", "");
873
874 };
875
876
877 //---------------------------------------------------------------------------
878 // Use this one for deriving Python classes from
879 %{
880 // See pyclasses.h
881 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
882 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
883 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
884 %}
885
886
887 DocStr(wxPySizer,
888 "wx.PySizer is a special version of `wx.Sizer` that has been
889 instrumented to allow the C++ virtual methods to be overloaded in
890 Python derived classes. You would derive from this class if you are
891 wanting to implement a custom sizer in Python code. Simply implement
892 `CalcMin` and `RecalcSizes` in the derived class and you're all set.
893 For example::
894
895 class MySizer(wx.PySizer):
896 def __init__(self):
897 wx.PySizer.__init__(self)
898
899 def CalcMin(self):
900 for item in self.GetChildren():
901 # calculate the total minimum width and height needed
902 # by all items in the sizer according to this sizer's
903 # layout algorithm.
904 ...
905 return wx.Size(width, height)
906
907 def RecalcSizes(self):
908 # find the space allotted to this sizer
909 pos = self.GetPosition()
910 size = self.GetSize()
911 for item in self.GetChildren():
912 # Recalculate (if necessary) the position and size of
913 # each item and then call item.SetDimension to do the
914 # actual positioning and sizing of the items within the
915 # space alloted to this sizer.
916 ...
917 item.SetDimension(itemPos, itemSize)
918
919
920 When `Layout` is called it first calls `CalcMin` followed by
921 `RecalcSizes` so you can optimize a bit by saving the results of
922 `CalcMin` and resuing them in `RecalcSizes`.
923
924 :see: `wx.SizerItem`, `wx.Sizer.GetChildren`
925
926 ", "");
927 class wxPySizer : public wxSizer {
928 public:
929 %pythonAppend wxPySizer "self._setCallbackInfo(self, PySizer);self._setOORInfo(self)"
930
931 DocCtorStr(
932 wxPySizer(),
933 "Creates a wx.PySizer. Must be called from the __init__ in the derived
934 class.", "");
935
936 void _setCallbackInfo(PyObject* self, PyObject* _class);
937 };
938
939
940 //---------------------------------------------------------------------------
941 %newgroup;
942
943
944 DocStr(wxBoxSizer,
945 "The basic idea behind a box sizer is that windows will most often be
946 laid out in rather simple basic geometry, typically in a row or a
947 column or nested hierarchies of either. A wx.BoxSizer will lay out
948 its items in a simple row or column, depending on the orientation
949 parameter passed to the constructor.", "
950
951 It is the unique feature of a box sizer, that it can grow in both
952 directions (height and width) but can distribute its growth in the
953 main direction (horizontal for a row) *unevenly* among its children.
954 This is determined by the proportion parameter give to items when they
955 are added to the sizer. It is interpreted as a weight factor, i.e. it
956 can be zero, indicating that the window may not be resized at all, or
957 above zero. If several windows have a value above zero, the value is
958 interpreted relative to the sum of all weight factors of the sizer, so
959 when adding two windows with a value of 1, they will both get resized
960 equally and each will receive half of the available space after the
961 fixed size items have been sized. If the items have unequal
962 proportion settings then they will receive a coresondingly unequal
963 allotment of the free space.
964
965 :see: `wx.StaticBoxSizer`
966 ");
967
968 class wxBoxSizer : public wxSizer {
969 public:
970 %pythonAppend wxBoxSizer "self._setOORInfo(self)"
971
972 DocCtorStr(
973 wxBoxSizer(int orient = wxHORIZONTAL),
974 "Constructor for a wx.BoxSizer. *orient* may be one of ``wx.VERTICAL``
975 or ``wx.HORIZONTAL`` for creating either a column sizer or a row
976 sizer.", "");
977
978
979 DocDeclStr(
980 int , GetOrientation(),
981 "Returns the current orientation of the sizer.", "");
982
983 DocDeclStr(
984 void , SetOrientation(int orient),
985 "Resets the orientation of the sizer.", "");
986
987 };
988
989 //---------------------------------------------------------------------------
990 %newgroup;
991
992
993 DocStr(wxStaticBoxSizer,
994 "wx.StaticBoxSizer derives from and functions identically to the
995 `wx.BoxSizer` and adds a `wx.StaticBox` around the items that the sizer
996 manages. Note that this static box must be created separately and
997 passed to the sizer constructor.", "");
998
999 class wxStaticBoxSizer : public wxBoxSizer {
1000 public:
1001 %pythonAppend wxStaticBoxSizer "self._setOORInfo(self)"
1002
1003 DocCtorStr(
1004 wxStaticBoxSizer(wxStaticBox *box, int orient = wxHORIZONTAL),
1005 "Constructor. It takes an associated static box and the orientation
1006 *orient* as parameters - orient can be either of ``wx.VERTICAL`` or
1007 ``wx.HORIZONTAL``.", "");
1008
1009 DocDeclStr(
1010 wxStaticBox *, GetStaticBox(),
1011 "Returns the static box associated with this sizer.", "");
1012
1013 };
1014
1015 //---------------------------------------------------------------------------
1016 %newgroup;
1017
1018
1019 DocStr(wxGridSizer,
1020 "A grid sizer is a sizer which lays out its children in a
1021 two-dimensional table with all cells having the same size. In other
1022 words, the width of each cell within the grid is the width of the
1023 widest item added to the sizer and the height of each grid cell is the
1024 height of the tallest item. An optional vertical and/or horizontal
1025 gap between items can also be specified (in pixels.)
1026
1027 Items are placed in the cells of the grid in the order they are added,
1028 in row-major order. In other words, the first row is filled first,
1029 then the second, and so on until all items have been added. (If
1030 neccessary, additional rows will be added as items are added.) If you
1031 need to have greater control over the cells that items are placed in
1032 then use the `wx.GridBagSizer`.
1033 ", "");
1034
1035 class wxGridSizer: public wxSizer
1036 {
1037 public:
1038 %pythonAppend wxGridSizer "self._setOORInfo(self)"
1039
1040 DocCtorStr(
1041 wxGridSizer( int rows=1, int cols=0, int vgap=0, int hgap=0 ),
1042 "Constructor for a wx.GridSizer. *rows* and *cols* determine the number
1043 of columns and rows in the sizer - if either of the parameters is
1044 zero, it will be calculated to from the total number of children in
1045 the sizer, thus making the sizer grow dynamically. *vgap* and *hgap*
1046 define extra space between all children.", "");
1047
1048 DocDeclStr(
1049 void , SetCols( int cols ),
1050 "Sets the number of columns in the sizer.", "");
1051
1052 DocDeclStr(
1053 void , SetRows( int rows ),
1054 "Sets the number of rows in the sizer.", "");
1055
1056 DocDeclStr(
1057 void , SetVGap( int gap ),
1058 "Sets the vertical gap (in pixels) between the cells in the sizer.", "");
1059
1060 DocDeclStr(
1061 void , SetHGap( int gap ),
1062 "Sets the horizontal gap (in pixels) between cells in the sizer", "");
1063
1064 DocDeclStr(
1065 int , GetCols(),
1066 "Returns the number of columns in the sizer.", "");
1067
1068 DocDeclStr(
1069 int , GetRows(),
1070 "Returns the number of rows in the sizer.", "");
1071
1072 DocDeclStr(
1073 int , GetVGap(),
1074 "Returns the vertical gap (in pixels) between the cells in the sizer.", "");
1075
1076 DocDeclStr(
1077 int , GetHGap(),
1078 "Returns the horizontal gap (in pixels) between cells in the sizer.", "");
1079
1080 };
1081
1082 //---------------------------------------------------------------------------
1083 %newgroup;
1084
1085 enum wxFlexSizerGrowMode
1086 {
1087 // don't resize the cells in non-flexible direction at all
1088 wxFLEX_GROWMODE_NONE,
1089
1090 // uniformly resize only the specified ones (default)
1091 wxFLEX_GROWMODE_SPECIFIED,
1092
1093 // uniformly resize all cells
1094 wxFLEX_GROWMODE_ALL
1095 };
1096
1097
1098
1099
1100
1101 DocStr(wxFlexGridSizer,
1102 "A flex grid sizer is a sizer which lays out its children in a
1103 two-dimensional table with all table cells in one row having the same
1104 height and all cells in one column having the same width, but all
1105 rows or all columns are not necessarily the same height or width as in
1106 the `wx.GridSizer`.
1107
1108 wx.FlexGridSizer can also size items equally in one direction but
1109 unequally (\"flexibly\") in the other. If the sizer is only flexible
1110 in one direction (this can be changed using `SetFlexibleDirection`), it
1111 needs to be decided how the sizer should grow in the other (\"non
1112 flexible\") direction in order to fill the available space. The
1113 `SetNonFlexibleGrowMode` method serves this purpose.
1114
1115 ", "");
1116
1117 class wxFlexGridSizer: public wxGridSizer
1118 {
1119 public:
1120 %pythonAppend wxFlexGridSizer "self._setOORInfo(self)"
1121
1122 DocCtorStr(
1123 wxFlexGridSizer( int rows=1, int cols=0, int vgap=0, int hgap=0 ),
1124 "Constructor for a wx.FlexGridSizer. *rows* and *cols* determine the
1125 number of columns and rows in the sizer - if either of the parameters
1126 is zero, it will be calculated to from the total number of children in
1127 the sizer, thus making the sizer grow dynamically. *vgap* and *hgap*
1128 define extra space between all children.", "");
1129
1130
1131 DocDeclStr(
1132 void , AddGrowableRow( size_t idx, int proportion = 0 ),
1133 "Specifies that row *idx* (starting from zero) should be grown if there
1134 is extra space available to the sizer.
1135
1136 The *proportion* parameter has the same meaning as the stretch factor
1137 for the box sizers except that if all proportions are 0, then all
1138 columns are resized equally (instead of not being resized at all).", "");
1139
1140 DocDeclStr(
1141 void , RemoveGrowableRow( size_t idx ),
1142 "Specifies that row *idx* is no longer growable.", "");
1143
1144 DocDeclStr(
1145 void , AddGrowableCol( size_t idx, int proportion = 0 ),
1146 "Specifies that column *idx* (starting from zero) should be grown if
1147 there is extra space available to the sizer.
1148
1149 The *proportion* parameter has the same meaning as the stretch factor
1150 for the box sizers except that if all proportions are 0, then all
1151 columns are resized equally (instead of not being resized at all).", "");
1152
1153 DocDeclStr(
1154 void , RemoveGrowableCol( size_t idx ),
1155 "Specifies that column *idx* is no longer growable.", "");
1156
1157
1158 DocDeclStr(
1159 void , SetFlexibleDirection(int direction),
1160 "Specifies whether the sizer should flexibly resize its columns, rows,
1161 or both. Argument *direction* can be one of the following values. Any
1162 other value is ignored.
1163
1164 ============== =======================================
1165 wx.VERTICAL Rows are flexibly sized.
1166 wx.HORIZONTAL Columns are flexibly sized.
1167 wx.BOTH Both rows and columns are flexibly sized
1168 (this is the default value).
1169 ============== =======================================
1170
1171 Note that this method does not trigger relayout.
1172 ", "");
1173
1174 DocDeclStr(
1175 int , GetFlexibleDirection(),
1176 "Returns a value that specifies whether the sizer
1177 flexibly resizes its columns, rows, or both (default).
1178
1179 :see: `SetFlexibleDirection`", "");
1180
1181
1182
1183 DocDeclStr(
1184 void , SetNonFlexibleGrowMode(wxFlexSizerGrowMode mode),
1185 "Specifies how the sizer should grow in the non-flexible direction if
1186 there is one (so `SetFlexibleDirection` must have been called
1187 previously). Argument *mode* can be one of the following values:
1188
1189 ========================== =================================================
1190 wx.FLEX_GROWMODE_NONE Sizer doesn't grow in the non flexible direction.
1191 wx.FLEX_GROWMODE_SPECIFIED Sizer honors growable columns/rows set with
1192 `AddGrowableCol` and `AddGrowableRow`. In this
1193 case equal sizing applies to minimum sizes of
1194 columns or rows (this is the default value).
1195 wx.FLEX_GROWMODE_ALL Sizer equally stretches all columns or rows in
1196 the non flexible direction, whether they are
1197 growable or not in the flexbile direction.
1198 ========================== =================================================
1199
1200 Note that this method does not trigger relayout.
1201
1202 ", "");
1203
1204 DocDeclStr(
1205 wxFlexSizerGrowMode , GetNonFlexibleGrowMode(),
1206 "Returns the value that specifies how the sizer grows in the
1207 non-flexible direction if there is one.
1208
1209 :see: `SetNonFlexibleGrowMode`", "");
1210
1211
1212 // Read-only access to the row heights and col widths arrays
1213 DocDeclAStr(
1214 const wxArrayInt& , GetRowHeights() const,
1215 "GetRowHeights(self) -> list",
1216 "Returns a list of integers representing the heights of each of the
1217 rows in the sizer.", "");
1218
1219 DocDeclAStr(
1220 const wxArrayInt& , GetColWidths() const,
1221 "GetColWidths(self) -> list",
1222 "Returns a list of integers representing the widths of each of the
1223 columns in the sizer.", "");
1224
1225 };
1226
1227 //---------------------------------------------------------------------------