]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/_sizers.i
Docstring updates
[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
501 DocAStr(Insert,
502 "Insert(self, int before, item, int proportion=0, int flag=0, int border=0,
503 PyObject userData=None)",
504
505 "Inserts a new item into the list of items managed by this sizer before
506 the item at index *before*. See `Add` for a description of the parameters.", "");
507 void Insert(int before, PyObject* item, int proportion=0, int flag=0,
508 int border=0, PyObject* userData=NULL) {
509
510 wxPyUserData* data = NULL;
511 bool blocked = wxPyBeginBlockThreads();
512 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, True, False);
513 if ( userData && (info.window || info.sizer || info.gotSize) )
514 data = new wxPyUserData(userData);
515 wxPyEndBlockThreads(blocked);
516
517 // Now call the real Insert method if a valid item type was found
518 if ( info.window )
519 self->Insert(before, info.window, proportion, flag, border, data);
520 else if ( info.sizer )
521 self->Insert(before, info.sizer, proportion, flag, border, data);
522 else if (info.gotSize)
523 self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
524 proportion, flag, border, data);
525 }
526
527
528
529 DocAStr(Prepend,
530 "Prepend(self, item, int proportion=0, int flag=0, int border=0,
531 PyObject userData=None)",
532
533 "Adds a new item to the begining of the list of sizer items managed by
534 this sizer. See `Add` for a description of the parameters.", "");
535 void Prepend(PyObject* item, int proportion=0, int flag=0, int border=0,
536 PyObject* userData=NULL) {
537
538 wxPyUserData* data = NULL;
539 bool blocked = wxPyBeginBlockThreads();
540 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, True, False);
541 if ( userData && (info.window || info.sizer || info.gotSize) )
542 data = new wxPyUserData(userData);
543 wxPyEndBlockThreads(blocked);
544
545 // Now call the real Prepend method if a valid item type was found
546 if ( info.window )
547 self->Prepend(info.window, proportion, flag, border, data);
548 else if ( info.sizer )
549 self->Prepend(info.sizer, proportion, flag, border, data);
550 else if (info.gotSize)
551 self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
552 proportion, flag, border, data);
553 }
554
555
556 DocAStr(Remove,
557 "Remove(self, item) -> bool",
558 "Removes an item from the sizer and destroys it. This method does not
559 cause any layout or resizing to take place, call `Layout` to update
560 the layout on screen after removing a child from the sizer. The
561 *item* parameter can be either a window, a sizer, or the zero-based
562 index of an item to remove. Returns True if the child item was found
563 and removed.", "
564
565 :note: For historical reasons calling this method with a `wx.Window`
566 parameter is depreacted, as it will not be able to destroy the
567 window since it is owned by its parent. You should use `Detach`
568 instead.
569 ");
570 bool Remove(PyObject* item) {
571 bool blocked = wxPyBeginBlockThreads();
572 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, True);
573 wxPyEndBlockThreads(blocked);
574 if ( info.window )
575 return self->Remove(info.window);
576 else if ( info.sizer )
577 return self->Remove(info.sizer);
578 else if ( info.gotPos )
579 return self->Remove(info.pos);
580 else
581 return False;
582 }
583
584
585 DocAStr(Detach,
586 "Detach(self, item) -> bool",
587 "Detaches an item from the sizer without destroying it. This method
588 does not cause any layout or resizing to take place, call `Layout` to
589 do so. The *item* parameter can be either a window, a sizer, or the
590 zero-based index of the item to be detached. Returns True if the child item
591 was found and detached.", "");
592 bool Detach(PyObject* item) {
593 bool blocked = wxPyBeginBlockThreads();
594 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, True);
595 wxPyEndBlockThreads(blocked);
596 if ( info.window )
597 return self->Detach(info.window);
598 else if ( info.sizer )
599 return self->Detach(info.sizer);
600 else if ( info.gotPos )
601 return self->Detach(info.pos);
602 else
603 return False;
604 }
605
606
607 void _SetItemMinSize(PyObject* item, const wxSize& size) {
608 bool blocked = wxPyBeginBlockThreads();
609 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, True);
610 wxPyEndBlockThreads(blocked);
611 if ( info.window )
612 self->SetItemMinSize(info.window, size);
613 else if ( info.sizer )
614 self->SetItemMinSize(info.sizer, size);
615 else if ( info.gotPos )
616 self->SetItemMinSize(info.pos, size);
617 }
618 }
619
620 %pythoncode {
621 def SetItemMinSize(self, item, *args):
622 """
623 SetItemMinSize(self, item, Size size)
624
625 Sets the minimum size that will be allocated for an item in the sizer.
626 The *item* parameter can be either a window, a sizer, or the
627 zero-based index of the item. If a window or sizer is given then it
628 will be searched for recursivly in subsizers if neccessary.
629 """
630 if len(args) == 2:
631 %# for backward compatibility accept separate width,height args too
632 return self._SetItemMinSize(item, args)
633 else:
634 return self._SetItemMinSize(item, args[0])
635 }
636
637 DocDeclAStrName(
638 void , Add( wxSizerItem *item ),
639 "AddItem(self, SizerItem item)",
640 "Adds a `wx.SizerItem` to the sizer.", "",
641 AddItem);
642
643 DocDeclAStrName(
644 void , Insert( size_t index, wxSizerItem *item ),
645 "InsertItem(self, int index, SizerItem item)",
646 "Inserts a `wx.SizerItem` to the sizer at the position given by *index*.", "",
647 InsertItem);
648
649 DocDeclAStrName(
650 void , Prepend( wxSizerItem *item ),
651 "PrependItem(self, SizerItem item)",
652 "Prepends a `wx.SizerItem` to the sizer.", "",
653 PrependItem);
654
655
656
657 %pythoncode {
658 def AddMany(self, items):
659 """
660 AddMany is a convenience method for adding several items
661 to a sizer at one time. Simply pass it a list of tuples,
662 where each tuple consists of the parameters that you
663 would normally pass to the `Add` method.
664 """
665 for item in items:
666 if type(item) != type(()) or (len(item) == 2 and type(item[0]) == type(1)):
667 item = (item, )
668 self.Add(*item)
669
670 %# for backwards compatibility only, please do not use in new code
671 AddWindow = wx._deprecated(Add, "AddWindow is deprecated, use `Add` instead.")
672 AddSizer = wx._deprecated(Add, "AddSizer is deprecated, use `Add` instead.")
673 AddSpacer = wx._deprecated(Add, "AddSpacer is deprecated, use `Add` instead.")
674 PrependWindow = wx._deprecated(Prepend, "PrependWindow is deprecated, use `Prepend` instead.")
675 PrependSizer = wx._deprecated(Prepend, "PrependSizer is deprecated, use `Prepend` instead.")
676 PrependSpacer = wx._deprecated(Prepend, "PrependSpacer is deprecated, use `Prepend` instead.")
677 InsertWindow = wx._deprecated(Insert, "InsertWindow is deprecated, use `Insert` instead.")
678 InsertSizer = wx._deprecated(Insert, "InsertSizer is deprecated, use `Insert` instead.")
679 InsertSpacer = wx._deprecated(Insert, "InsertSpacer is deprecated, use `Insert` instead.")
680 RemoveWindow = wx._deprecated(Remove, "RemoveWindow is deprecated, use `Remove` instead.")
681 RemoveSizer = wx._deprecated(Remove, "RemoveSizer is deprecated, use `Remove` instead.")
682 RemovePos = wx._deprecated(Remove, "RemovePos is deprecated, use `Remove` instead.")
683
684 }
685
686
687 DocDeclStr(
688 void , SetDimension( int x, int y, int width, int height ),
689 "Call this to force the sizer to take the given dimension and thus
690 force the items owned by the sizer to resize themselves according to
691 the rules defined by the parameter in the `Add`, `Insert` or `Prepend`
692 methods.", "");
693
694 DocDeclStr(
695 void , SetMinSize( const wxSize &size ),
696 "Call this to give the sizer a minimal size. Normally, the sizer will
697 calculate its minimal size based purely on how much space its children
698 need. After calling this method `GetMinSize` will return either the
699 minimal size as requested by its children or the minimal size set
700 here, depending on which is bigger.", "");
701
702
703 DocDeclStr(
704 wxSize , GetSize(),
705 "Returns the current size of the space managed by the sizer.", "");
706
707 DocDeclStr(
708 wxPoint , GetPosition(),
709 "Returns the current position of the sizer's managed space.", "");
710
711 DocDeclStr(
712 wxSize , GetMinSize(),
713 "Returns the minimal size of the sizer. This is either the combined
714 minimal size of all the children and their borders or the minimal size
715 set by SetMinSize, depending on which is bigger.", "");
716
717
718 %pythoncode {
719 def GetSizeTuple(self):
720 return self.GetSize().Get()
721 def GetPositionTuple(self):
722 return self.GetPosition().Get()
723 def GetMinSizeTuple(self):
724 return self.GetMinSize().Get()
725 }
726
727 DocDeclStr(
728 virtual void , RecalcSizes(),
729 "Using the sizes calculated by `CalcMin` reposition and resize all the
730 items managed by this sizer. You should not need to call this directly as
731 it is called by `Layout`.", "");
732
733 DocDeclStr(
734 virtual wxSize , CalcMin(),
735 "This method is where the sizer will do the actual calculation of its
736 children's minimal sizes. You should not need to call this directly as
737 it is called by `Layout`.", "");
738
739
740 DocDeclStr(
741 void , Layout(),
742 "This method will force the recalculation and layout of the items
743 controlled by the sizer using the current space allocated to the
744 sizer. Normally this is called automatically from the owning window's
745 EVT_SIZE handler, but it is also useful to call it from user code when
746 one of the items in a sizer change size, or items are added or
747 removed.", "");
748
749
750 DocDeclStr(
751 wxSize , Fit( wxWindow *window ),
752 "Tell the sizer to resize the *window* to match the sizer's minimal
753 size. This is commonly done in the constructor of the window itself in
754 order to set its initial size to match the needs of the children as
755 determined by the sizer. Returns the new size.
756
757 For a top level window this is the total window size, not the client size.", "");
758
759 DocDeclStr(
760 void , FitInside( wxWindow *window ),
761 "Tell the sizer to resize the *virtual size* of the *window* to match the
762 sizer's minimal size. This will not alter the on screen size of the
763 window, but may cause the addition/removal/alteration of scrollbars
764 required to view the virtual area in windows which manage it.
765
766 :see: `wx.ScrolledWindow.SetScrollbars`, `SetVirtualSizeHints`
767 ", "");
768
769
770 DocDeclStr(
771 void , SetSizeHints( wxWindow *window ),
772 "Tell the sizer to set (and `Fit`) the minimal size of the *window* to
773 match the sizer's minimal size. This is commonly done in the
774 constructor of the window itself if the window is resizable (as are
775 many dialogs under Unix and frames on probably all platforms) in order
776 to prevent the window from being sized smaller than the minimal size
777 required by the sizer.", "");
778
779 DocDeclStr(
780 void , SetVirtualSizeHints( wxWindow *window ),
781 "Tell the sizer to set the minimal size of the window virtual area to
782 match the sizer's minimal size. For windows with managed scrollbars
783 this will set them appropriately.
784
785 :see: `wx.ScrolledWindow.SetScrollbars`
786 ", "");
787
788
789 DocDeclStr(
790 void , Clear( bool deleteWindows=False ),
791 "Clear all items from the sizer, optionally destroying the window items
792 as well.", "");
793
794 DocDeclStr(
795 void , DeleteWindows(),
796 "Destroy all windows managed by the sizer.", "");
797
798
799
800 // wxList& GetChildren();
801 %extend {
802 DocAStr(GetChildren,
803 "GetChildren(sefl) -> list",
804 "Returns a list of all the `wx.SizerItem` objects managed by the sizer.", "");
805 PyObject* GetChildren() {
806 wxSizerItemList& list = self->GetChildren();
807 return wxPy_ConvertList(&list);
808 }
809 }
810
811
812 // Manage whether individual windows or subsizers are considered
813 // in the layout calculations or not.
814
815 %extend {
816 DocAStr(Show,
817 "Show(self, item, bool show=True)",
818 "Shows or hides an item managed by the sizer. To make a sizer item
819 disappear or reappear, use Show followed by `Layout`. The *item*
820 parameter can be either a window, a sizer, or the zero-based index of
821 the item.", "");
822 void Show(PyObject* item, bool show = True) {
823 bool blocked = wxPyBeginBlockThreads();
824 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, True);
825 wxPyEndBlockThreads(blocked);
826 if ( info.window )
827 self->Show(info.window, show);
828 else if ( info.sizer )
829 self->Show(info.sizer, show);
830 else if ( info.gotPos )
831 self->Show(info.pos, show);
832 }
833
834 DocAStr(IsShown,
835 "IsShown(self, item)",
836 "Determines if the item is currently shown. sizer. To make a sizer
837 item disappear or reappear, use Show followed by `Layout`. The *item*
838 parameter can be either a window, a sizer, or the zero-based index of
839 the item.", "");
840 bool IsShown(PyObject* item) {
841 bool blocked = wxPyBeginBlockThreads();
842 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, False);
843 wxPyEndBlockThreads(blocked);
844 if ( info.window )
845 return self->IsShown(info.window);
846 else if ( info.sizer )
847 return self->IsShown(info.sizer);
848 else if ( info.gotPos )
849 return self->IsShown(info.pos);
850 else
851 return False;
852 }
853 }
854
855 %pythoncode {
856 def Hide(self, item):
857 """
858 A convenience method for Show(item, False).
859 """
860 self.Show(item, False)
861 }
862
863
864 DocDeclStr(
865 void , ShowItems(bool show),
866 "Recursively call `wx.Window.Show` on all sizer items.", "");
867
868 };
869
870
871 //---------------------------------------------------------------------------
872 // Use this one for deriving Python classes from
873 %{
874 // See pyclasses.h
875 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
876 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
877 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
878 %}
879
880
881 DocStr(wxPySizer,
882 "wx.PySizer is a special version of `wx.Sizer` that has been
883 instrumented to allow the C++ virtual methods to be overloaded in
884 Python derived classes. You would derive from this class if you are
885 wanting to implement a custom sizer in Python code. Simply implement
886 `CalcMin` and `RecalcSizes` in the derived class and you're all set.
887 For example::
888
889 class MySizer(wx.PySizer):
890 def __init__(self):
891 wx.PySizer.__init__(self)
892
893 def CalcMin(self):
894 for item in self.GetChildren():
895 # calculate the total minimum width and height needed
896 # by all items in the sizer according to this sizer's
897 # layout algorithm.
898 ...
899 return wx.Size(width, height)
900
901 def RecalcSizes(self):
902 # find the space allotted to this sizer
903 pos = self.GetPosition()
904 size = self.GetSize()
905 for item in self.GetChildren():
906 # Recalculate (if necessary) the position and size of
907 # each item and then call item.SetDimension to do the
908 # actual positioning and sizing of the items within the
909 # space alloted to this sizer.
910 ...
911 item.SetDimension(itemPos, itemSize)
912
913
914 When `Layout` is called it first calls `CalcMin` followed by
915 `RecalcSizes` so you can optimize a bit by saving the results of
916 `CalcMin` and resuing them in `RecalcSizes`.
917
918 :see: `wx.SizerItem`, `wx.Sizer.GetChildren`
919
920 ", "");
921 class wxPySizer : public wxSizer {
922 public:
923 %pythonAppend wxPySizer "self._setCallbackInfo(self, PySizer);self._setOORInfo(self)"
924
925 DocCtorStr(
926 wxPySizer(),
927 "Creates a wx.PySizer. Must be called from the __init__ in the derived
928 class.", "");
929
930 void _setCallbackInfo(PyObject* self, PyObject* _class);
931 };
932
933
934 //---------------------------------------------------------------------------
935 %newgroup;
936
937
938 DocStr(wxBoxSizer,
939 "The basic idea behind a box sizer is that windows will most often be
940 laid out in rather simple basic geometry, typically in a row or a
941 column or nested hierarchies of either. A wx.BoxSizer will lay out
942 its items in a simple row or column, depending on the orientation
943 parameter passed to the constructor.", "
944
945 It is the unique feature of a box sizer, that it can grow in both
946 directions (height and width) but can distribute its growth in the
947 main direction (horizontal for a row) *unevenly* among its children.
948 This is determined by the proportion parameter give to items when they
949 are added to the sizer. It is interpreted as a weight factor, i.e. it
950 can be zero, indicating that the window may not be resized at all, or
951 above zero. If several windows have a value above zero, the value is
952 interpreted relative to the sum of all weight factors of the sizer, so
953 when adding two windows with a value of 1, they will both get resized
954 equally and each will receive half of the available space after the
955 fixed size items have been sized. If the items have unequal
956 proportion settings then they will receive a coresondingly unequal
957 allotment of the free space.
958
959 :see: `wx.StaticBoxSizer`
960 ");
961
962 class wxBoxSizer : public wxSizer {
963 public:
964 %pythonAppend wxBoxSizer "self._setOORInfo(self)"
965
966 DocCtorStr(
967 wxBoxSizer(int orient = wxHORIZONTAL),
968 "Constructor for a wx.BoxSizer. *orient* may be one of ``wx.VERTICAL``
969 or ``wx.HORIZONTAL`` for creating either a column sizer or a row
970 sizer.", "");
971
972
973 DocDeclStr(
974 int , GetOrientation(),
975 "Returns the current orientation of the sizer.", "");
976
977 DocDeclStr(
978 void , SetOrientation(int orient),
979 "Resets the orientation of the sizer.", "");
980
981 };
982
983 //---------------------------------------------------------------------------
984 %newgroup;
985
986
987 DocStr(wxStaticBoxSizer,
988 "wx.StaticBoxSizer derives from and functions identically to the
989 `wx.BoxSizer` and adds a `wx.StaticBox` around the items that the sizer
990 manages. Note that this static box must be created separately and
991 passed to the sizer constructor.", "");
992
993 class wxStaticBoxSizer : public wxBoxSizer {
994 public:
995 %pythonAppend wxStaticBoxSizer "self._setOORInfo(self)"
996
997 DocCtorStr(
998 wxStaticBoxSizer(wxStaticBox *box, int orient = wxHORIZONTAL),
999 "Constructor. It takes an associated static box and the orientation
1000 *orient* as parameters - orient can be either of ``wx.VERTICAL`` or
1001 ``wx.HORIZONTAL``.", "");
1002
1003 DocDeclStr(
1004 wxStaticBox *, GetStaticBox(),
1005 "Returns the static box associated with this sizer.", "");
1006
1007 };
1008
1009 //---------------------------------------------------------------------------
1010 %newgroup;
1011
1012
1013 DocStr(wxGridSizer,
1014 "A grid sizer is a sizer which lays out its children in a
1015 two-dimensional table with all cells having the same size. In other
1016 words, the width of each cell within the grid is the width of the
1017 widest item added to the sizer and the height of each grid cell is the
1018 height of the tallest item. An optional vertical and/or horizontal
1019 gap between items can also be specified (in pixels.)
1020
1021 Items are placed in the cells of the grid in the order they are added,
1022 in row-major order. In other words, the first row is filled first,
1023 then the second, and so on until all items have been added. (If
1024 neccessary, additional rows will be added as items are added.) If you
1025 need to have greater control over the cells that items are placed in
1026 then use the `wx.GridBagSizer`.
1027 ", "");
1028
1029 class wxGridSizer: public wxSizer
1030 {
1031 public:
1032 %pythonAppend wxGridSizer "self._setOORInfo(self)"
1033
1034 DocCtorStr(
1035 wxGridSizer( int rows=1, int cols=0, int vgap=0, int hgap=0 ),
1036 "Constructor for a wx.GridSizer. *rows* and *cols* determine the number
1037 of columns and rows in the sizer - if either of the parameters is
1038 zero, it will be calculated to from the total number of children in
1039 the sizer, thus making the sizer grow dynamically. *vgap* and *hgap*
1040 define extra space between all children.", "");
1041
1042 DocDeclStr(
1043 void , SetCols( int cols ),
1044 "Sets the number of columns in the sizer.", "");
1045
1046 DocDeclStr(
1047 void , SetRows( int rows ),
1048 "Sets the number of rows in the sizer.", "");
1049
1050 DocDeclStr(
1051 void , SetVGap( int gap ),
1052 "Sets the vertical gap (in pixels) between the cells in the sizer.", "");
1053
1054 DocDeclStr(
1055 void , SetHGap( int gap ),
1056 "Sets the horizontal gap (in pixels) between cells in the sizer", "");
1057
1058 DocDeclStr(
1059 int , GetCols(),
1060 "Returns the number of columns in the sizer.", "");
1061
1062 DocDeclStr(
1063 int , GetRows(),
1064 "Returns the number of rows in the sizer.", "");
1065
1066 DocDeclStr(
1067 int , GetVGap(),
1068 "Returns the vertical gap (in pixels) between the cells in the sizer.", "");
1069
1070 DocDeclStr(
1071 int , GetHGap(),
1072 "Returns the horizontal gap (in pixels) between cells in the sizer.", "");
1073
1074 };
1075
1076 //---------------------------------------------------------------------------
1077 %newgroup;
1078
1079 enum wxFlexSizerGrowMode
1080 {
1081 // don't resize the cells in non-flexible direction at all
1082 wxFLEX_GROWMODE_NONE,
1083
1084 // uniformly resize only the specified ones (default)
1085 wxFLEX_GROWMODE_SPECIFIED,
1086
1087 // uniformly resize all cells
1088 wxFLEX_GROWMODE_ALL
1089 };
1090
1091
1092
1093
1094
1095 DocStr(wxFlexGridSizer,
1096 "A flex grid sizer is a sizer which lays out its children in a
1097 two-dimensional table with all table cells in one row having the same
1098 height and all cells in one column having the same width, but all
1099 rows or all columns are not necessarily the same height or width as in
1100 the `wx.GridSizer`.
1101
1102 wx.FlexGridSizer can also size items equally in one direction but
1103 unequally (\"flexibly\") in the other. If the sizer is only flexible
1104 in one direction (this can be changed using `SetFlexibleDirection`), it
1105 needs to be decided how the sizer should grow in the other (\"non
1106 flexible\") direction in order to fill the available space. The
1107 `SetNonFlexibleGrowMode` method serves this purpose.
1108
1109 ", "");
1110
1111 class wxFlexGridSizer: public wxGridSizer
1112 {
1113 public:
1114 %pythonAppend wxFlexGridSizer "self._setOORInfo(self)"
1115
1116 DocCtorStr(
1117 wxFlexGridSizer( int rows=1, int cols=0, int vgap=0, int hgap=0 ),
1118 "Constructor for a wx.FlexGridSizer. *rows* and *cols* determine the
1119 number of columns and rows in the sizer - if either of the parameters
1120 is zero, it will be calculated to from the total number of children in
1121 the sizer, thus making the sizer grow dynamically. *vgap* and *hgap*
1122 define extra space between all children.", "");
1123
1124
1125 DocDeclStr(
1126 void , AddGrowableRow( size_t idx, int proportion = 0 ),
1127 "Specifies that row *idx* (starting from zero) should be grown if there
1128 is extra space available to the sizer.
1129
1130 The *proportion* parameter has the same meaning as the stretch factor
1131 for the box sizers except that if all proportions are 0, then all
1132 columns are resized equally (instead of not being resized at all).", "");
1133
1134 DocDeclStr(
1135 void , RemoveGrowableRow( size_t idx ),
1136 "Specifies that row *idx* is no longer growable.", "");
1137
1138 DocDeclStr(
1139 void , AddGrowableCol( size_t idx, int proportion = 0 ),
1140 "Specifies that column *idx* (starting from zero) should be grown if
1141 there is extra space available to the sizer.
1142
1143 The *proportion* parameter has the same meaning as the stretch factor
1144 for the box sizers except that if all proportions are 0, then all
1145 columns are resized equally (instead of not being resized at all).", "");
1146
1147 DocDeclStr(
1148 void , RemoveGrowableCol( size_t idx ),
1149 "Specifies that column *idx* is no longer growable.", "");
1150
1151
1152 DocDeclStr(
1153 void , SetFlexibleDirection(int direction),
1154 "Specifies whether the sizer should flexibly resize its columns, rows,
1155 or both. Argument *direction* can be one of the following values. Any
1156 other value is ignored.
1157
1158 ============== =======================================
1159 wx.VERTICAL Rows are flexibly sized.
1160 wx.HORIZONTAL Columns are flexibly sized.
1161 wx.BOTH Both rows and columns are flexibly sized
1162 (this is the default value).
1163 ============== =======================================
1164
1165 Note that this method does not trigger relayout.
1166 ", "");
1167
1168 DocDeclStr(
1169 int , GetFlexibleDirection(),
1170 "Returns a value that specifies whether the sizer
1171 flexibly resizes its columns, rows, or both (default).
1172
1173 :see: `SetFlexibleDirection`", "");
1174
1175
1176
1177 DocDeclStr(
1178 void , SetNonFlexibleGrowMode(wxFlexSizerGrowMode mode),
1179 "Specifies how the sizer should grow in the non-flexible direction if
1180 there is one (so `SetFlexibleDirection` must have been called
1181 previously). Argument *mode* can be one of the following values:
1182
1183 ========================== =================================================
1184 wx.FLEX_GROWMODE_NONE Sizer doesn't grow in the non flexible direction.
1185 wx.FLEX_GROWMODE_SPECIFIED Sizer honors growable columns/rows set with
1186 `AddGrowableCol` and `AddGrowableRow`. In this
1187 case equal sizing applies to minimum sizes of
1188 columns or rows (this is the default value).
1189 wx.FLEX_GROWMODE_ALL Sizer equally stretches all columns or rows in
1190 the non flexible direction, whether they are
1191 growable or not in the flexbile direction.
1192 ========================== =================================================
1193
1194 Note that this method does not trigger relayout.
1195
1196 ", "");
1197
1198 DocDeclStr(
1199 wxFlexSizerGrowMode , GetNonFlexibleGrowMode(),
1200 "Returns the value that specifies how the sizer grows in the
1201 non-flexible direction if there is one.
1202
1203 :see: `SetNonFlexibleGrowMode`", "");
1204
1205
1206 // Read-only access to the row heights and col widths arrays
1207 DocDeclAStr(
1208 const wxArrayInt& , GetRowHeights() const,
1209 "GetRowHeights(self) -> list",
1210 "Returns a list of integers representing the heights of each of the
1211 rows in the sizer.", "");
1212
1213 DocDeclAStr(
1214 const wxArrayInt& , GetColWidths() const,
1215 "GetColWidths(self) -> list",
1216 "Returns a list of integers representing the widths of each of the
1217 columns in the sizer.", "");
1218
1219 };
1220
1221 //---------------------------------------------------------------------------