]>
Commit | Line | Data |
---|---|---|
27e45892 RD |
1 | # This file was created automatically by SWIG 1.3.29. |
2 | # Don't modify this file, modify the SWIG interface instead. | |
3 | ||
4 | """ | |
5 | The wx.aui moduleis an Advanced User Interface library that aims to | |
6 | implement "cutting-edge" interface usability and design features so | |
7 | developers can quickly and easily create beautiful and usable | |
8 | application interfaces. | |
9 | ||
10 | **Vision and Design Principles** | |
11 | ||
12 | wx.aui attempts to encapsulate the following aspects of the user | |
13 | interface: | |
14 | ||
15 | * Frame Management: Frame management provides the means to open, | |
16 | move and hide common controls that are needed to interact with the | |
17 | document, and allow these configurations to be saved into | |
18 | different perspectives and loaded at a later time. | |
19 | ||
20 | * Toolbars: Toolbars are a specialized subset of the frame | |
21 | management system and should behave similarly to other docked | |
22 | components. However, they also require additional functionality, | |
23 | such as "spring-loaded" rebar support, "chevron" buttons and | |
24 | end-user customizability. | |
25 | ||
26 | * Modeless Controls: Modeless controls expose a tool palette or set | |
27 | of options that float above the application content while allowing | |
28 | it to be accessed. Usually accessed by the toolbar, these controls | |
29 | disappear when an option is selected, but may also be "torn off" | |
30 | the toolbar into a floating frame of their own. | |
31 | ||
32 | * Look and Feel: Look and feel encompasses the way controls are | |
33 | drawn, both when shown statically as well as when they are being | |
34 | moved. This aspect of user interface design incorporates "special | |
35 | effects" such as transparent window dragging as well as frame | |
36 | animation. | |
37 | ||
38 | **PyAUI adheres to the following principles** | |
39 | ||
40 | - Use native floating frames to obtain a native look and feel for | |
41 | all platforms; | |
42 | ||
43 | - Use existing wxPython code where possible, such as sizer | |
44 | implementation for frame management; | |
45 | ||
46 | - Use standard wxPython coding conventions. | |
47 | ||
48 | ||
49 | **Usage** | |
50 | ||
51 | The following example shows a simple implementation that utilizes | |
52 | `wx.aui.FrameManager` to manage three text controls in a frame window:: | |
53 | ||
54 | import wx | |
55 | import wx.aui | |
56 | ||
57 | class MyFrame(wx.Frame): | |
58 | ||
59 | def __init__(self, parent, id=-1, title='wx.aui Test', | |
60 | size=(800, 600), style=wx.DEFAULT_FRAME_STYLE): | |
61 | wx.Frame.__init__(self, parent, id, title, pos, size, style) | |
62 | ||
63 | self._mgr = wx.aui.FrameManager(self) | |
64 | ||
65 | # create several text controls | |
66 | text1 = wx.TextCtrl(self, -1, 'Pane 1 - sample text', | |
67 | wx.DefaultPosition, wx.Size(200,150), | |
68 | wx.NO_BORDER | wx.TE_MULTILINE) | |
69 | ||
70 | text2 = wx.TextCtrl(self, -1, 'Pane 2 - sample text', | |
71 | wx.DefaultPosition, wx.Size(200,150), | |
72 | wx.NO_BORDER | wx.TE_MULTILINE) | |
73 | ||
74 | text3 = wx.TextCtrl(self, -1, 'Main content window', | |
75 | wx.DefaultPosition, wx.Size(200,150), | |
76 | wx.NO_BORDER | wx.TE_MULTILINE) | |
77 | ||
78 | # add the panes to the manager | |
79 | self._mgr.AddPane(text1, wx.LEFT, 'Pane Number One') | |
80 | self._mgr.AddPane(text2, wx.BOTTOM, 'Pane Number Two') | |
81 | self._mgr.AddPane(text3, wx.CENTER) | |
82 | ||
83 | # tell the manager to 'commit' all the changes just made | |
84 | self._mgr.Update() | |
85 | ||
86 | self.Bind(wx.EVT_CLOSE, self.OnClose) | |
87 | ||
88 | ||
89 | def OnClose(self, event): | |
90 | # deinitialize the frame manager | |
91 | self._mgr.UnInit() | |
92 | # delete the frame | |
93 | self.Destroy() | |
94 | ||
95 | ||
96 | app = wx.App() | |
97 | frame = MyFrame(None) | |
98 | frame.Show() | |
99 | app.MainLoop() | |
100 | ||
101 | """ | |
102 | ||
103 | import _aui | |
104 | import new | |
105 | new_instancemethod = new.instancemethod | |
106 | def _swig_setattr_nondynamic(self,class_type,name,value,static=1): | |
107 | if (name == "thisown"): return self.this.own(value) | |
108 | if (name == "this"): | |
109 | if type(value).__name__ == 'PySwigObject': | |
110 | self.__dict__[name] = value | |
111 | return | |
112 | method = class_type.__swig_setmethods__.get(name,None) | |
113 | if method: return method(self,value) | |
114 | if (not static) or hasattr(self,name): | |
115 | self.__dict__[name] = value | |
116 | else: | |
117 | raise AttributeError("You cannot add attributes to %s" % self) | |
118 | ||
119 | def _swig_setattr(self,class_type,name,value): | |
120 | return _swig_setattr_nondynamic(self,class_type,name,value,0) | |
121 | ||
122 | def _swig_getattr(self,class_type,name): | |
123 | if (name == "thisown"): return self.this.own() | |
124 | method = class_type.__swig_getmethods__.get(name,None) | |
125 | if method: return method(self) | |
126 | raise AttributeError,name | |
127 | ||
128 | def _swig_repr(self): | |
129 | try: strthis = "proxy of " + self.this.__repr__() | |
130 | except: strthis = "" | |
131 | return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) | |
132 | ||
133 | import types | |
134 | try: | |
135 | _object = types.ObjectType | |
136 | _newclass = 1 | |
137 | except AttributeError: | |
138 | class _object : pass | |
139 | _newclass = 0 | |
140 | del types | |
141 | ||
142 | ||
143 | def _swig_setattr_nondynamic_method(set): | |
144 | def set_attr(self,name,value): | |
145 | if (name == "thisown"): return self.this.own(value) | |
146 | if hasattr(self,name) or (name == "this"): | |
147 | set(self,name,value) | |
148 | else: | |
149 | raise AttributeError("You cannot add attributes to %s" % self) | |
150 | return set_attr | |
151 | ||
152 | ||
153 | import _core | |
154 | import _windows | |
155 | wx = _core | |
156 | __docfilter__ = wx.__DocFilter(globals()) | |
157 | USE_AUI = _aui.USE_AUI | |
158 | AUI_DOCK_NONE = _aui.AUI_DOCK_NONE | |
159 | AUI_DOCK_TOP = _aui.AUI_DOCK_TOP | |
160 | AUI_DOCK_RIGHT = _aui.AUI_DOCK_RIGHT | |
161 | AUI_DOCK_BOTTOM = _aui.AUI_DOCK_BOTTOM | |
162 | AUI_DOCK_LEFT = _aui.AUI_DOCK_LEFT | |
163 | AUI_DOCK_CENTER = _aui.AUI_DOCK_CENTER | |
164 | AUI_DOCK_CENTRE = _aui.AUI_DOCK_CENTRE | |
165 | AUI_MGR_ALLOW_FLOATING = _aui.AUI_MGR_ALLOW_FLOATING | |
166 | AUI_MGR_ALLOW_ACTIVE_PANE = _aui.AUI_MGR_ALLOW_ACTIVE_PANE | |
167 | AUI_MGR_TRANSPARENT_DRAG = _aui.AUI_MGR_TRANSPARENT_DRAG | |
168 | AUI_MGR_TRANSPARENT_HINT = _aui.AUI_MGR_TRANSPARENT_HINT | |
169 | AUI_MGR_TRANSPARENT_HINT_FADE = _aui.AUI_MGR_TRANSPARENT_HINT_FADE | |
10044bf1 RD |
170 | AUI_MGR_DISABLE_VENETIAN_BLINDS = _aui.AUI_MGR_DISABLE_VENETIAN_BLINDS |
171 | AUI_MGR_DISABLE_VENETIAN_BLINDS_FADE = _aui.AUI_MGR_DISABLE_VENETIAN_BLINDS_FADE | |
27e45892 RD |
172 | AUI_MGR_DEFAULT = _aui.AUI_MGR_DEFAULT |
173 | AUI_ART_SASH_SIZE = _aui.AUI_ART_SASH_SIZE | |
174 | AUI_ART_CAPTION_SIZE = _aui.AUI_ART_CAPTION_SIZE | |
175 | AUI_ART_GRIPPER_SIZE = _aui.AUI_ART_GRIPPER_SIZE | |
176 | AUI_ART_PANE_BORDER_SIZE = _aui.AUI_ART_PANE_BORDER_SIZE | |
177 | AUI_ART_PANE_BUTTON_SIZE = _aui.AUI_ART_PANE_BUTTON_SIZE | |
178 | AUI_ART_BACKGROUND_COLOUR = _aui.AUI_ART_BACKGROUND_COLOUR | |
179 | AUI_ART_SASH_COLOUR = _aui.AUI_ART_SASH_COLOUR | |
180 | AUI_ART_ACTIVE_CAPTION_COLOUR = _aui.AUI_ART_ACTIVE_CAPTION_COLOUR | |
181 | AUI_ART_ACTIVE_CAPTION_GRADIENT_COLOUR = _aui.AUI_ART_ACTIVE_CAPTION_GRADIENT_COLOUR | |
182 | AUI_ART_INACTIVE_CAPTION_COLOUR = _aui.AUI_ART_INACTIVE_CAPTION_COLOUR | |
183 | AUI_ART_INACTIVE_CAPTION_GRADIENT_COLOUR = _aui.AUI_ART_INACTIVE_CAPTION_GRADIENT_COLOUR | |
184 | AUI_ART_ACTIVE_CAPTION_TEXT_COLOUR = _aui.AUI_ART_ACTIVE_CAPTION_TEXT_COLOUR | |
185 | AUI_ART_INACTIVE_CAPTION_TEXT_COLOUR = _aui.AUI_ART_INACTIVE_CAPTION_TEXT_COLOUR | |
186 | AUI_ART_BORDER_COLOUR = _aui.AUI_ART_BORDER_COLOUR | |
187 | AUI_ART_GRIPPER_COLOUR = _aui.AUI_ART_GRIPPER_COLOUR | |
188 | AUI_ART_CAPTION_FONT = _aui.AUI_ART_CAPTION_FONT | |
189 | AUI_ART_GRADIENT_TYPE = _aui.AUI_ART_GRADIENT_TYPE | |
190 | AUI_GRADIENT_NONE = _aui.AUI_GRADIENT_NONE | |
191 | AUI_GRADIENT_VERTICAL = _aui.AUI_GRADIENT_VERTICAL | |
192 | AUI_GRADIENT_HORIZONTAL = _aui.AUI_GRADIENT_HORIZONTAL | |
193 | AUI_BUTTON_STATE_NORMAL = _aui.AUI_BUTTON_STATE_NORMAL | |
194 | AUI_BUTTON_STATE_HOVER = _aui.AUI_BUTTON_STATE_HOVER | |
195 | AUI_BUTTON_STATE_PRESSED = _aui.AUI_BUTTON_STATE_PRESSED | |
196 | AUI_INSERT_PANE = _aui.AUI_INSERT_PANE | |
197 | AUI_INSERT_ROW = _aui.AUI_INSERT_ROW | |
198 | AUI_INSERT_DOCK = _aui.AUI_INSERT_DOCK | |
199 | class PaneInfo(object): | |
200 | """ | |
201 | PaneInfo specifies all the parameters for a pane for the | |
202 | `FrameManager`. These parameters specify where the pane is on the | |
203 | screen, whether it is docked or floating, or hidden. In addition, | |
204 | these parameters specify the pane's docked position, floating | |
205 | position, preferred size, minimum size, caption text among many other | |
206 | parameters. | |
207 | ||
208 | """ | |
209 | thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') | |
210 | __repr__ = _swig_repr | |
211 | def __init__(self, *args, **kwargs): | |
212 | """ | |
213 | __init__(self) -> PaneInfo | |
214 | ||
215 | PaneInfo specifies all the parameters for a pane for the | |
216 | `FrameManager`. These parameters specify where the pane is on the | |
217 | screen, whether it is docked or floating, or hidden. In addition, | |
218 | these parameters specify the pane's docked position, floating | |
219 | position, preferred size, minimum size, caption text among many other | |
220 | parameters. | |
221 | ||
222 | """ | |
223 | _aui.PaneInfo_swiginit(self,_aui.new_PaneInfo(*args, **kwargs)) | |
224 | __swig_destroy__ = _aui.delete_PaneInfo | |
225 | __del__ = lambda self : None; | |
10044bf1 RD |
226 | def SafeSet(*args, **kwargs): |
227 | """SafeSet(self, PaneInfo source)""" | |
228 | return _aui.PaneInfo_SafeSet(*args, **kwargs) | |
229 | ||
27e45892 RD |
230 | def IsOk(*args, **kwargs): |
231 | """ | |
232 | IsOk(self) -> bool | |
233 | ||
234 | IsOk returns ``True`` if the PaneInfo structure is valid. | |
235 | ||
236 | """ | |
237 | return _aui.PaneInfo_IsOk(*args, **kwargs) | |
238 | ||
239 | def IsFixed(*args, **kwargs): | |
240 | """ | |
241 | IsFixed(self) -> bool | |
242 | ||
243 | IsFixed returns ``True`` if the pane cannot be resized. | |
244 | ||
245 | """ | |
246 | return _aui.PaneInfo_IsFixed(*args, **kwargs) | |
247 | ||
248 | def IsResizable(*args, **kwargs): | |
249 | """ | |
250 | IsResizable(self) -> bool | |
251 | ||
252 | IsResizeable returns ``True`` if the pane can be resized. | |
253 | ||
254 | """ | |
255 | return _aui.PaneInfo_IsResizable(*args, **kwargs) | |
256 | ||
257 | def IsShown(*args, **kwargs): | |
258 | """ | |
259 | IsShown(self) -> bool | |
260 | ||
261 | IsShown returns ``True`` if the pane should be drawn on the screen. | |
262 | ||
263 | """ | |
264 | return _aui.PaneInfo_IsShown(*args, **kwargs) | |
265 | ||
266 | def IsFloating(*args, **kwargs): | |
267 | """ | |
268 | IsFloating(self) -> bool | |
269 | ||
270 | IsFloating returns ``True`` if the pane is floating. | |
271 | ||
272 | """ | |
273 | return _aui.PaneInfo_IsFloating(*args, **kwargs) | |
274 | ||
275 | def IsDocked(*args, **kwargs): | |
276 | """ | |
277 | IsDocked(self) -> bool | |
278 | ||
279 | IsDocked returns ``True`` if the pane is docked. | |
280 | ||
281 | """ | |
282 | return _aui.PaneInfo_IsDocked(*args, **kwargs) | |
283 | ||
284 | def IsToolbar(*args, **kwargs): | |
285 | """ | |
286 | IsToolbar(self) -> bool | |
287 | ||
288 | IsToolbar returns ``True`` if the pane contains a toolbar. | |
289 | ||
290 | """ | |
291 | return _aui.PaneInfo_IsToolbar(*args, **kwargs) | |
292 | ||
293 | def IsTopDockable(*args, **kwargs): | |
294 | """ | |
295 | IsTopDockable(self) -> bool | |
296 | ||
297 | IsTopDockable returns ``True`` if the pane can be docked at the top of | |
298 | the managed frame. | |
299 | ||
300 | """ | |
301 | return _aui.PaneInfo_IsTopDockable(*args, **kwargs) | |
302 | ||
303 | def IsBottomDockable(*args, **kwargs): | |
304 | """ | |
305 | IsBottomDockable(self) -> bool | |
306 | ||
307 | IsBottomDockable returns ``True`` if the pane can be docked at the | |
308 | bottom of the managed frame. | |
309 | ||
310 | """ | |
311 | return _aui.PaneInfo_IsBottomDockable(*args, **kwargs) | |
312 | ||
313 | def IsLeftDockable(*args, **kwargs): | |
314 | """ | |
315 | IsLeftDockable(self) -> bool | |
316 | ||
317 | IsLeftDockable returns ``True`` if the pane can be docked on the left | |
318 | of the managed frame. | |
319 | ||
320 | """ | |
321 | return _aui.PaneInfo_IsLeftDockable(*args, **kwargs) | |
322 | ||
323 | def IsRightDockable(*args, **kwargs): | |
324 | """ | |
325 | IsRightDockable(self) -> bool | |
326 | ||
327 | IsRightDockable returns ``True`` if the pane can be docked on the | |
328 | right of the managed frame. | |
329 | ||
330 | """ | |
331 | return _aui.PaneInfo_IsRightDockable(*args, **kwargs) | |
332 | ||
333 | def IsFloatable(*args, **kwargs): | |
334 | """ | |
335 | IsFloatable(self) -> bool | |
336 | ||
337 | IsFloatable returns ``True`` if the pane can be undocked and displayed | |
338 | as a floating window. | |
339 | ||
340 | """ | |
341 | return _aui.PaneInfo_IsFloatable(*args, **kwargs) | |
342 | ||
343 | def IsMovable(*args, **kwargs): | |
344 | """ | |
345 | IsMovable(self) -> bool | |
346 | ||
347 | IsMoveable returns ``True`` if the docked frame can be undocked or moved | |
348 | to another dock position. | |
349 | ||
350 | """ | |
351 | return _aui.PaneInfo_IsMovable(*args, **kwargs) | |
352 | ||
353 | def HasCaption(*args, **kwargs): | |
354 | """ | |
355 | HasCaption(self) -> bool | |
356 | ||
357 | HasCaption returns ``True`` if the pane displays a caption. | |
358 | ||
359 | """ | |
360 | return _aui.PaneInfo_HasCaption(*args, **kwargs) | |
361 | ||
362 | def HasGripper(*args, **kwargs): | |
363 | """ | |
364 | HasGripper(self) -> bool | |
365 | ||
366 | HasGripper returns ``True`` if the pane displays a gripper. | |
367 | ||
368 | """ | |
369 | return _aui.PaneInfo_HasGripper(*args, **kwargs) | |
370 | ||
371 | def HasBorder(*args, **kwargs): | |
372 | """ | |
373 | HasBorder(self) -> bool | |
374 | ||
375 | HasBorder returns ``True`` if the pane displays a border. | |
376 | ||
377 | """ | |
378 | return _aui.PaneInfo_HasBorder(*args, **kwargs) | |
379 | ||
380 | def HasCloseButton(*args, **kwargs): | |
381 | """ | |
382 | HasCloseButton(self) -> bool | |
383 | ||
384 | HasCloseButton returns ``True`` if the pane displays a button to close | |
385 | the pane. | |
386 | ||
387 | """ | |
388 | return _aui.PaneInfo_HasCloseButton(*args, **kwargs) | |
389 | ||
390 | def HasMaximizeButton(*args, **kwargs): | |
391 | """ | |
392 | HasMaximizeButton(self) -> bool | |
393 | ||
394 | HasMaximizeButton returns ``True`` if the pane displays a button to | |
395 | maximize the pane. | |
396 | ||
397 | """ | |
398 | return _aui.PaneInfo_HasMaximizeButton(*args, **kwargs) | |
399 | ||
400 | def HasMinimizeButton(*args, **kwargs): | |
401 | """ | |
402 | HasMinimizeButton(self) -> bool | |
403 | ||
404 | HasMinimizeButton returns ``True`` if the pane displays a button to | |
405 | minimize the pane. | |
406 | ||
407 | """ | |
408 | return _aui.PaneInfo_HasMinimizeButton(*args, **kwargs) | |
409 | ||
410 | def HasPinButton(*args, **kwargs): | |
411 | """ | |
412 | HasPinButton(self) -> bool | |
413 | ||
414 | HasPinButton returns ``True`` if the pane displays a button to float | |
415 | the pane. | |
416 | ||
417 | """ | |
418 | return _aui.PaneInfo_HasPinButton(*args, **kwargs) | |
419 | ||
420 | def HasGripperTop(*args, **kwargs): | |
421 | """HasGripperTop(self) -> bool""" | |
422 | return _aui.PaneInfo_HasGripperTop(*args, **kwargs) | |
423 | ||
424 | def Window(*args, **kwargs): | |
425 | """Window(self, Window w) -> PaneInfo""" | |
426 | return _aui.PaneInfo_Window(*args, **kwargs) | |
427 | ||
428 | def Name(*args, **kwargs): | |
429 | """ | |
430 | Name(self, String n) -> PaneInfo | |
431 | ||
432 | Name sets the name of the pane so it can be referenced in lookup | |
433 | functions. | |
434 | ||
435 | """ | |
436 | return _aui.PaneInfo_Name(*args, **kwargs) | |
437 | ||
438 | def Caption(*args, **kwargs): | |
439 | """ | |
440 | Caption(self, String c) -> PaneInfo | |
441 | ||
442 | Caption sets the caption of the pane. | |
443 | ||
444 | """ | |
445 | return _aui.PaneInfo_Caption(*args, **kwargs) | |
446 | ||
447 | def Left(*args, **kwargs): | |
448 | """ | |
449 | Left(self) -> PaneInfo | |
450 | ||
451 | Left sets the pane dock position to the left side of the frame. | |
452 | ||
453 | """ | |
454 | return _aui.PaneInfo_Left(*args, **kwargs) | |
455 | ||
456 | def Right(*args, **kwargs): | |
457 | """ | |
458 | Right(self) -> PaneInfo | |
459 | ||
460 | Right sets the pane dock position to the right side of the frame. | |
461 | ||
462 | """ | |
463 | return _aui.PaneInfo_Right(*args, **kwargs) | |
464 | ||
465 | def Top(*args, **kwargs): | |
466 | """ | |
467 | Top(self) -> PaneInfo | |
468 | ||
469 | Top sets the pane dock position to the top of the frame. | |
470 | ||
471 | """ | |
472 | return _aui.PaneInfo_Top(*args, **kwargs) | |
473 | ||
474 | def Bottom(*args, **kwargs): | |
475 | """ | |
476 | Bottom(self) -> PaneInfo | |
477 | ||
478 | Bottom sets the pane dock position to the bottom of the frame. | |
479 | ||
480 | """ | |
481 | return _aui.PaneInfo_Bottom(*args, **kwargs) | |
482 | ||
483 | def Center(*args, **kwargs): | |
484 | """ | |
485 | Center(self) -> PaneInfo | |
486 | ||
487 | Center sets the pane to the center position of the frame. | |
488 | ||
489 | """ | |
490 | return _aui.PaneInfo_Center(*args, **kwargs) | |
491 | ||
492 | def Centre(*args, **kwargs): | |
493 | """ | |
494 | Centre(self) -> PaneInfo | |
495 | ||
496 | Centre sets the pane to the center position of the frame. | |
497 | ||
498 | """ | |
499 | return _aui.PaneInfo_Centre(*args, **kwargs) | |
500 | ||
501 | def Direction(*args, **kwargs): | |
502 | """ | |
503 | Direction(self, int direction) -> PaneInfo | |
504 | ||
505 | Direction determines the direction of the docked pane. | |
506 | ||
507 | """ | |
508 | return _aui.PaneInfo_Direction(*args, **kwargs) | |
509 | ||
510 | def Layer(*args, **kwargs): | |
511 | """ | |
512 | Layer(self, int layer) -> PaneInfo | |
513 | ||
514 | Layer determines the layer of the docked pane. | |
515 | ||
516 | """ | |
517 | return _aui.PaneInfo_Layer(*args, **kwargs) | |
518 | ||
519 | def Row(*args, **kwargs): | |
520 | """ | |
521 | Row(self, int row) -> PaneInfo | |
522 | ||
523 | Row determines the row of the docked pane. | |
524 | ||
525 | """ | |
526 | return _aui.PaneInfo_Row(*args, **kwargs) | |
527 | ||
528 | def Position(*args, **kwargs): | |
529 | """ | |
530 | Position(self, int pos) -> PaneInfo | |
531 | ||
532 | Position determines the position of the docked pane. | |
533 | ||
534 | """ | |
535 | return _aui.PaneInfo_Position(*args, **kwargs) | |
536 | ||
537 | def BestSize(*args, **kwargs): | |
538 | """ | |
539 | BestSize(self, Size size) -> PaneInfo | |
540 | ||
541 | BestSize sets the ideal size for the pane. | |
542 | ||
543 | """ | |
544 | return _aui.PaneInfo_BestSize(*args, **kwargs) | |
545 | ||
546 | def MinSize(*args, **kwargs): | |
547 | """ | |
548 | MinSize(self, Size size) -> PaneInfo | |
549 | ||
550 | MinSize sets the minimum size of the pane. | |
551 | ||
552 | """ | |
553 | return _aui.PaneInfo_MinSize(*args, **kwargs) | |
554 | ||
555 | def MaxSize(*args, **kwargs): | |
556 | """ | |
557 | MaxSize(self, Size size) -> PaneInfo | |
558 | ||
559 | MaxSize sets the maximum size of the pane. | |
560 | ||
561 | """ | |
562 | return _aui.PaneInfo_MaxSize(*args, **kwargs) | |
563 | ||
564 | def FloatingPosition(*args, **kwargs): | |
565 | """ | |
566 | FloatingPosition(self, Point pos) -> PaneInfo | |
567 | ||
568 | FloatingPosition sets the position of the floating pane. | |
569 | ||
570 | """ | |
571 | return _aui.PaneInfo_FloatingPosition(*args, **kwargs) | |
572 | ||
573 | def FloatingSize(*args, **kwargs): | |
574 | """ | |
575 | FloatingSize(self, Size size) -> PaneInfo | |
576 | ||
577 | FloatingSize sets the size of the floating pane. | |
578 | ||
579 | """ | |
580 | return _aui.PaneInfo_FloatingSize(*args, **kwargs) | |
581 | ||
582 | def Fixed(*args, **kwargs): | |
583 | """ | |
584 | Fixed(self) -> PaneInfo | |
585 | ||
586 | Fixed forces a pane to be fixed size so that it cannot be resized. | |
587 | ||
588 | """ | |
589 | return _aui.PaneInfo_Fixed(*args, **kwargs) | |
590 | ||
591 | def Resizable(*args, **kwargs): | |
592 | """ | |
593 | Resizable(self, bool resizable=True) -> PaneInfo | |
594 | ||
595 | Resized allows a pane to be resized if resizable is true, and forces | |
596 | it to be a fixed size if resizeable is false. | |
597 | ||
598 | """ | |
599 | return _aui.PaneInfo_Resizable(*args, **kwargs) | |
600 | ||
601 | def Dock(*args, **kwargs): | |
602 | """ | |
603 | Dock(self) -> PaneInfo | |
604 | ||
605 | Dock indicates that a pane should be docked. | |
606 | ||
607 | """ | |
608 | return _aui.PaneInfo_Dock(*args, **kwargs) | |
609 | ||
610 | def Float(*args, **kwargs): | |
611 | """ | |
612 | Float(self) -> PaneInfo | |
613 | ||
614 | Float indicates that a pane should be floated. | |
615 | ||
616 | """ | |
617 | return _aui.PaneInfo_Float(*args, **kwargs) | |
618 | ||
619 | def Hide(*args, **kwargs): | |
620 | """ | |
621 | Hide(self) -> PaneInfo | |
622 | ||
623 | Hide indicates that a pane should be hidden. | |
624 | ||
625 | """ | |
626 | return _aui.PaneInfo_Hide(*args, **kwargs) | |
627 | ||
628 | def Show(*args, **kwargs): | |
629 | """ | |
630 | Show(self, bool show=True) -> PaneInfo | |
631 | ||
632 | Show indicates that a pane should be shown. | |
633 | ||
634 | """ | |
635 | return _aui.PaneInfo_Show(*args, **kwargs) | |
636 | ||
637 | def CaptionVisible(*args, **kwargs): | |
638 | """ | |
639 | CaptionVisible(self, bool visible=True) -> PaneInfo | |
640 | ||
641 | CaptionVisible indicates that a pane caption should be visible. | |
642 | ||
643 | """ | |
644 | return _aui.PaneInfo_CaptionVisible(*args, **kwargs) | |
645 | ||
646 | def PaneBorder(*args, **kwargs): | |
647 | """ | |
648 | PaneBorder(self, bool visible=True) -> PaneInfo | |
649 | ||
650 | PaneBorder indicates that a border should be drawn for the pane. | |
651 | ||
652 | """ | |
653 | return _aui.PaneInfo_PaneBorder(*args, **kwargs) | |
654 | ||
655 | def Gripper(*args, **kwargs): | |
656 | """ | |
657 | Gripper(self, bool visible=True) -> PaneInfo | |
658 | ||
659 | Gripper indicates that a gripper should be drawn for the pane.. | |
660 | ||
661 | """ | |
662 | return _aui.PaneInfo_Gripper(*args, **kwargs) | |
663 | ||
664 | def GripperTop(*args, **kwargs): | |
665 | """GripperTop(self, bool attop=True) -> PaneInfo""" | |
666 | return _aui.PaneInfo_GripperTop(*args, **kwargs) | |
667 | ||
668 | def CloseButton(*args, **kwargs): | |
669 | """ | |
670 | CloseButton(self, bool visible=True) -> PaneInfo | |
671 | ||
672 | CloseButton indicates that a close button should be drawn for the | |
673 | pane. | |
674 | ||
675 | """ | |
676 | return _aui.PaneInfo_CloseButton(*args, **kwargs) | |
677 | ||
678 | def MaximizeButton(*args, **kwargs): | |
679 | """ | |
680 | MaximizeButton(self, bool visible=True) -> PaneInfo | |
681 | ||
682 | MaximizeButton indicates that a maximize button should be drawn for | |
683 | the pane. | |
684 | ||
685 | """ | |
686 | return _aui.PaneInfo_MaximizeButton(*args, **kwargs) | |
687 | ||
688 | def MinimizeButton(*args, **kwargs): | |
689 | """ | |
690 | MinimizeButton(self, bool visible=True) -> PaneInfo | |
691 | ||
692 | MinimizeButton indicates that a minimize button should be drawn for | |
693 | the pane. | |
694 | ||
695 | """ | |
696 | return _aui.PaneInfo_MinimizeButton(*args, **kwargs) | |
697 | ||
698 | def PinButton(*args, **kwargs): | |
699 | """ | |
700 | PinButton(self, bool visible=True) -> PaneInfo | |
701 | ||
702 | PinButton indicates that a pin button should be drawn for the pane. | |
703 | ||
704 | """ | |
705 | return _aui.PaneInfo_PinButton(*args, **kwargs) | |
706 | ||
707 | def DestroyOnClose(*args, **kwargs): | |
708 | """ | |
709 | DestroyOnClose(self, bool b=True) -> PaneInfo | |
710 | ||
711 | DestroyOnClose indicates whether a pane should be detroyed when it is | |
712 | closed. | |
713 | ||
714 | """ | |
715 | return _aui.PaneInfo_DestroyOnClose(*args, **kwargs) | |
716 | ||
717 | def TopDockable(*args, **kwargs): | |
718 | """ | |
719 | TopDockable(self, bool b=True) -> PaneInfo | |
720 | ||
721 | TopDockable indicates whether a pane can be docked at the top of the | |
722 | frame. | |
723 | ||
724 | """ | |
725 | return _aui.PaneInfo_TopDockable(*args, **kwargs) | |
726 | ||
727 | def BottomDockable(*args, **kwargs): | |
728 | """ | |
729 | BottomDockable(self, bool b=True) -> PaneInfo | |
730 | ||
731 | BottomDockable indicates whether a pane can be docked at the bottom of | |
732 | the frame. | |
733 | ||
734 | """ | |
735 | return _aui.PaneInfo_BottomDockable(*args, **kwargs) | |
736 | ||
737 | def LeftDockable(*args, **kwargs): | |
738 | """ | |
739 | LeftDockable(self, bool b=True) -> PaneInfo | |
740 | ||
741 | LeftDockable indicates whether a pane can be docked on the left of the | |
742 | frame. | |
743 | ||
744 | """ | |
745 | return _aui.PaneInfo_LeftDockable(*args, **kwargs) | |
746 | ||
747 | def RightDockable(*args, **kwargs): | |
748 | """ | |
749 | RightDockable(self, bool b=True) -> PaneInfo | |
750 | ||
751 | RightDockable indicates whether a pane can be docked on the right of | |
752 | the frame. | |
753 | ||
754 | """ | |
755 | return _aui.PaneInfo_RightDockable(*args, **kwargs) | |
756 | ||
757 | def Floatable(*args, **kwargs): | |
758 | """ | |
759 | Floatable(self, bool b=True) -> PaneInfo | |
760 | ||
761 | Floatable indicates whether a frame can be floated. | |
762 | ||
763 | """ | |
764 | return _aui.PaneInfo_Floatable(*args, **kwargs) | |
765 | ||
766 | def Movable(*args, **kwargs): | |
767 | """ | |
768 | Movable(self, bool b=True) -> PaneInfo | |
769 | ||
770 | Movable indicates whether a frame can be moved. | |
771 | ||
772 | """ | |
773 | return _aui.PaneInfo_Movable(*args, **kwargs) | |
774 | ||
775 | def Dockable(*args, **kwargs): | |
776 | """ | |
777 | Dockable(self, bool b=True) -> PaneInfo | |
778 | ||
779 | Dockable indicates whether a pane can be docked at any position of the | |
780 | frame. | |
781 | ||
782 | """ | |
783 | return _aui.PaneInfo_Dockable(*args, **kwargs) | |
784 | ||
785 | def DefaultPane(*args, **kwargs): | |
786 | """ | |
787 | DefaultPane(self) -> PaneInfo | |
788 | ||
789 | DefaultPane specifies that the pane should adopt the default pane | |
790 | settings. | |
791 | ||
792 | """ | |
793 | return _aui.PaneInfo_DefaultPane(*args, **kwargs) | |
794 | ||
795 | def CentrePane(*args, **kwargs): | |
796 | """ | |
797 | CentrePane(self) -> PaneInfo | |
798 | ||
799 | CentrePane specifies that the pane should adopt the default center | |
800 | pane settings. | |
801 | ||
802 | """ | |
803 | return _aui.PaneInfo_CentrePane(*args, **kwargs) | |
804 | ||
805 | def CenterPane(*args, **kwargs): | |
806 | """ | |
807 | CenterPane(self) -> PaneInfo | |
808 | ||
809 | CenterPane specifies that the pane should adopt the default center | |
810 | pane settings. | |
811 | ||
812 | """ | |
813 | return _aui.PaneInfo_CenterPane(*args, **kwargs) | |
814 | ||
815 | def ToolbarPane(*args, **kwargs): | |
816 | """ | |
817 | ToolbarPane(self) -> PaneInfo | |
818 | ||
819 | ToolbarPane specifies that the pane should adopt the default toolbar | |
820 | pane settings. | |
821 | ||
822 | """ | |
823 | return _aui.PaneInfo_ToolbarPane(*args, **kwargs) | |
824 | ||
825 | def SetFlag(*args, **kwargs): | |
826 | """ | |
827 | SetFlag(self, int flag, bool option_state) -> PaneInfo | |
828 | ||
829 | SetFlag turns the property given by flag on or off with the | |
830 | option_state parameter. | |
831 | ||
832 | """ | |
833 | return _aui.PaneInfo_SetFlag(*args, **kwargs) | |
834 | ||
835 | def HasFlag(*args, **kwargs): | |
836 | """ | |
837 | HasFlag(self, int flag) -> bool | |
838 | ||
839 | HasFlag returns ``True`` if the the property specified by flag is | |
840 | active for the pane. | |
841 | ||
842 | """ | |
843 | return _aui.PaneInfo_HasFlag(*args, **kwargs) | |
844 | ||
845 | optionFloating = _aui.PaneInfo_optionFloating | |
846 | optionHidden = _aui.PaneInfo_optionHidden | |
847 | optionLeftDockable = _aui.PaneInfo_optionLeftDockable | |
848 | optionRightDockable = _aui.PaneInfo_optionRightDockable | |
849 | optionTopDockable = _aui.PaneInfo_optionTopDockable | |
850 | optionBottomDockable = _aui.PaneInfo_optionBottomDockable | |
851 | optionFloatable = _aui.PaneInfo_optionFloatable | |
852 | optionMovable = _aui.PaneInfo_optionMovable | |
853 | optionResizable = _aui.PaneInfo_optionResizable | |
854 | optionPaneBorder = _aui.PaneInfo_optionPaneBorder | |
855 | optionCaption = _aui.PaneInfo_optionCaption | |
856 | optionGripper = _aui.PaneInfo_optionGripper | |
857 | optionDestroyOnClose = _aui.PaneInfo_optionDestroyOnClose | |
858 | optionToolbar = _aui.PaneInfo_optionToolbar | |
859 | optionActive = _aui.PaneInfo_optionActive | |
860 | optionGripperTop = _aui.PaneInfo_optionGripperTop | |
861 | buttonClose = _aui.PaneInfo_buttonClose | |
862 | buttonMaximize = _aui.PaneInfo_buttonMaximize | |
863 | buttonMinimize = _aui.PaneInfo_buttonMinimize | |
864 | buttonPin = _aui.PaneInfo_buttonPin | |
865 | buttonCustom1 = _aui.PaneInfo_buttonCustom1 | |
866 | buttonCustom2 = _aui.PaneInfo_buttonCustom2 | |
867 | buttonCustom3 = _aui.PaneInfo_buttonCustom3 | |
868 | actionPane = _aui.PaneInfo_actionPane | |
869 | name = property(_aui.PaneInfo_name_get, _aui.PaneInfo_name_set) | |
870 | caption = property(_aui.PaneInfo_caption_get, _aui.PaneInfo_caption_set) | |
871 | window = property(_aui.PaneInfo_window_get, _aui.PaneInfo_window_set) | |
872 | frame = property(_aui.PaneInfo_frame_get, _aui.PaneInfo_frame_set) | |
873 | state = property(_aui.PaneInfo_state_get, _aui.PaneInfo_state_set) | |
874 | dock_direction = property(_aui.PaneInfo_dock_direction_get, _aui.PaneInfo_dock_direction_set) | |
875 | dock_layer = property(_aui.PaneInfo_dock_layer_get, _aui.PaneInfo_dock_layer_set) | |
876 | dock_row = property(_aui.PaneInfo_dock_row_get, _aui.PaneInfo_dock_row_set) | |
877 | dock_pos = property(_aui.PaneInfo_dock_pos_get, _aui.PaneInfo_dock_pos_set) | |
878 | best_size = property(_aui.PaneInfo_best_size_get, _aui.PaneInfo_best_size_set) | |
879 | min_size = property(_aui.PaneInfo_min_size_get, _aui.PaneInfo_min_size_set) | |
880 | max_size = property(_aui.PaneInfo_max_size_get, _aui.PaneInfo_max_size_set) | |
881 | floating_pos = property(_aui.PaneInfo_floating_pos_get, _aui.PaneInfo_floating_pos_set) | |
882 | floating_size = property(_aui.PaneInfo_floating_size_get, _aui.PaneInfo_floating_size_set) | |
883 | dock_proportion = property(_aui.PaneInfo_dock_proportion_get, _aui.PaneInfo_dock_proportion_set) | |
884 | buttons = property(_aui.PaneInfo_buttons_get, _aui.PaneInfo_buttons_set) | |
885 | rect = property(_aui.PaneInfo_rect_get, _aui.PaneInfo_rect_set) | |
886 | _aui.PaneInfo_swigregister(PaneInfo) | |
887 | cvar = _aui.cvar | |
888 | ||
889 | class FrameManager(_core.EvtHandler): | |
890 | """ | |
891 | FrameManager manages the panes associated with it for a particular | |
892 | `wx.Frame`, using a pane's `PaneInfo` information to determine each | |
893 | pane's docking and floating behavior. FrameManager uses wxWidgets' | |
894 | sizer mechanism to plan the layout of each frame. It uses a | |
895 | replaceable `DockArt` class to do all drawing, so all drawing is | |
896 | localized in one area, and may be customized depending on an | |
897 | application's specific needs. | |
898 | ||
899 | """ | |
900 | thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') | |
901 | __repr__ = _swig_repr | |
902 | def __init__(self, *args, **kwargs): | |
903 | """ | |
10044bf1 | 904 | __init__(self, Window managed_wnd=None, int flags=AUI_MGR_DEFAULT) -> FrameManager |
27e45892 RD |
905 | |
906 | Constructor. | |
907 | ||
10044bf1 RD |
908 | :param managed_wnd: Specifies the `wx.Window` which should be |
909 | managed. If not set in the call to this constructor then | |
910 | `SetManagedWindow` should be called later. | |
27e45892 RD |
911 | |
912 | :param flags: Specifies options which allow the frame management | |
913 | behavior to be modified. | |
914 | ||
915 | """ | |
916 | _aui.FrameManager_swiginit(self,_aui.new_FrameManager(*args, **kwargs)) | |
917 | __swig_destroy__ = _aui.delete_FrameManager | |
918 | __del__ = lambda self : None; | |
919 | def UnInit(*args, **kwargs): | |
920 | """ | |
921 | UnInit(self) | |
922 | ||
923 | UnInit uninitializes the framework and should be called before a | |
924 | managed frame is destroyed. UnInit is usually called in the managed | |
10044bf1 | 925 | window's destructor. |
27e45892 RD |
926 | |
927 | """ | |
928 | return _aui.FrameManager_UnInit(*args, **kwargs) | |
929 | ||
930 | def SetFlags(*args, **kwargs): | |
931 | """ | |
932 | SetFlags(self, int flags) | |
933 | ||
934 | SetFlags is used to specify the FrameManager's behavioral | |
935 | settings. The flags parameter is described in the docs for `__init__` | |
936 | ||
937 | """ | |
938 | return _aui.FrameManager_SetFlags(*args, **kwargs) | |
939 | ||
940 | def GetFlags(*args, **kwargs): | |
941 | """ | |
942 | GetFlags(self) -> int | |
943 | ||
944 | GetFlags returns the current FrameManager's flags. | |
945 | ||
946 | """ | |
947 | return _aui.FrameManager_GetFlags(*args, **kwargs) | |
948 | ||
10044bf1 | 949 | def SetManagedWindow(*args, **kwargs): |
27e45892 | 950 | """ |
10044bf1 | 951 | SetManagedWindow(self, Window managed_wnd) |
27e45892 | 952 | |
10044bf1 RD |
953 | SetManagedWindow is called to specify the window which is to be |
954 | managed by the FrameManager. It is normally a `wx.Frame` but it is | |
955 | possible to also allow docking within any container window. This only | |
956 | needs to be called if the window was not given to the manager in the | |
957 | constructor. | |
27e45892 RD |
958 | |
959 | """ | |
10044bf1 | 960 | return _aui.FrameManager_SetManagedWindow(*args, **kwargs) |
27e45892 | 961 | |
10044bf1 | 962 | def GetManagedWindow(*args, **kwargs): |
27e45892 | 963 | """ |
10044bf1 | 964 | GetManagedWindow(self) -> Window |
27e45892 | 965 | |
10044bf1 | 966 | GetManagedWindow returns the window currently being managed by the |
27e45892 RD |
967 | FrameManager. |
968 | ||
969 | """ | |
10044bf1 | 970 | return _aui.FrameManager_GetManagedWindow(*args, **kwargs) |
27e45892 RD |
971 | |
972 | def SetArtProvider(*args, **kwargs): | |
973 | """ | |
974 | SetArtProvider(self, DockArt art_provider) | |
975 | ||
976 | SetArtProvider instructs FrameManager to use the art provider | |
977 | specified for all drawing calls. This allows plugable look-and-feel | |
978 | features. The previous art provider object, if any, will be destroyed | |
979 | by FrameManager. | |
980 | ||
981 | :note: If you wish to use a custom `DockArt` class to override drawing | |
982 | or metrics then you shoudl derive your class from the `PyDockArt` | |
983 | class, which has been instrumented for reflecting virtual calls to | |
984 | Python methods. | |
985 | ||
986 | """ | |
987 | return _aui.FrameManager_SetArtProvider(*args, **kwargs) | |
988 | ||
989 | def GetArtProvider(*args, **kwargs): | |
990 | """ | |
991 | GetArtProvider(self) -> DockArt | |
992 | ||
993 | GetArtProvider returns the current art provider being used. | |
994 | ||
995 | """ | |
996 | return _aui.FrameManager_GetArtProvider(*args, **kwargs) | |
997 | ||
998 | def _GetPaneByWidget(*args, **kwargs): | |
999 | """_GetPaneByWidget(self, Window window) -> PaneInfo""" | |
1000 | return _aui.FrameManager__GetPaneByWidget(*args, **kwargs) | |
1001 | ||
1002 | def _GetPaneByName(*args, **kwargs): | |
1003 | """_GetPaneByName(self, String name) -> PaneInfo""" | |
1004 | return _aui.FrameManager__GetPaneByName(*args, **kwargs) | |
1005 | ||
1006 | def GetAllPanes(*args, **kwargs): | |
1007 | """ | |
1008 | GetAllPanes(self) -> list | |
1009 | ||
1010 | GetAllPanes returns a list of `PaneInfo` objects for all panes managed | |
1011 | by the frame manager. | |
1012 | ||
1013 | """ | |
1014 | return _aui.FrameManager_GetAllPanes(*args, **kwargs) | |
1015 | ||
1016 | def _AddPane1(*args, **kwargs): | |
1017 | """_AddPane1(self, Window window, PaneInfo pane_info) -> bool""" | |
1018 | return _aui.FrameManager__AddPane1(*args, **kwargs) | |
1019 | ||
10044bf1 RD |
1020 | def AddPaneAtPos(*args, **kwargs): |
1021 | """AddPaneAtPos(self, Window window, PaneInfo pane_info, Point drop_pos) -> bool""" | |
1022 | return _aui.FrameManager_AddPaneAtPos(*args, **kwargs) | |
1023 | ||
27e45892 RD |
1024 | def _AddPane2(*args, **kwargs): |
1025 | """_AddPane2(self, Window window, int direction=LEFT, String caption=wxEmptyString) -> bool""" | |
1026 | return _aui.FrameManager__AddPane2(*args, **kwargs) | |
1027 | ||
1028 | def InsertPane(*args, **kwargs): | |
1029 | """ | |
1030 | InsertPane(self, Window window, PaneInfo insert_location, int insert_level=AUI_INSERT_PANE) -> bool | |
1031 | ||
1032 | InsertPane is used to insert either a previously unmanaged pane window | |
1033 | into the frame manager, or to insert a currently managed pane | |
1034 | somewhere else. InsertPane will push all panes, rows, or docks aside | |
1035 | and insert the window into the position specified by | |
1036 | ``insert_location``. Because ``insert_location`` can specify either a pane, | |
1037 | dock row, or dock layer, the ``insert_level`` parameter is used to | |
1038 | disambiguate this. The parameter ``insert_level`` can take a value of | |
1039 | ``AUI_INSERT_PANE``, ``AUI_INSERT_ROW`` or ``AUI_INSERT_DOCK``. | |
1040 | ||
1041 | """ | |
1042 | return _aui.FrameManager_InsertPane(*args, **kwargs) | |
1043 | ||
1044 | def DetachPane(*args, **kwargs): | |
1045 | """ | |
1046 | DetachPane(self, Window window) -> bool | |
1047 | ||
1048 | DetachPane tells the FrameManager to stop managing the pane specified | |
1049 | by window. The window, if in a floated frame, is reparented to the | |
1050 | frame managed by FrameManager. | |
1051 | ||
1052 | """ | |
1053 | return _aui.FrameManager_DetachPane(*args, **kwargs) | |
1054 | ||
10044bf1 RD |
1055 | def SavePaneInfo(*args, **kwargs): |
1056 | """SavePaneInfo(self, PaneInfo pane) -> String""" | |
1057 | return _aui.FrameManager_SavePaneInfo(*args, **kwargs) | |
1058 | ||
1059 | def LoadPaneInfo(*args, **kwargs): | |
1060 | """LoadPaneInfo(self, String pane_part, PaneInfo pane)""" | |
1061 | return _aui.FrameManager_LoadPaneInfo(*args, **kwargs) | |
1062 | ||
27e45892 RD |
1063 | def SavePerspective(*args, **kwargs): |
1064 | """ | |
1065 | SavePerspective(self) -> String | |
1066 | ||
1067 | SavePerspective saves the entire user interface layout into an encoded | |
1068 | string, which can then be stored someplace by the application. When a | |
1069 | perspective is restored using `LoadPerspective`, the entire user | |
1070 | interface will return to the state it was when the perspective was | |
1071 | saved. | |
1072 | ||
1073 | """ | |
1074 | return _aui.FrameManager_SavePerspective(*args, **kwargs) | |
1075 | ||
1076 | def LoadPerspective(*args, **kwargs): | |
1077 | """ | |
1078 | LoadPerspective(self, String perspective, bool update=True) -> bool | |
1079 | ||
1080 | LoadPerspective loads a saved perspective. If ``update`` is ``True``, | |
1081 | `Update` is automatically invoked, thus realizing the saved | |
1082 | perspective on screen. | |
1083 | ||
1084 | """ | |
1085 | return _aui.FrameManager_LoadPerspective(*args, **kwargs) | |
1086 | ||
1087 | def Update(*args, **kwargs): | |
1088 | """ | |
1089 | Update(self) | |
1090 | ||
1091 | Update shoudl be called called after any number of changes are made to | |
1092 | any of the managed panes. Update must be invoked after `AddPane` or | |
1093 | `InsertPane` are called in order to "realize" or "commit" the | |
1094 | changes. In addition, any number of changes may be made to `PaneInfo` | |
1095 | structures (retrieved with `GetPane` or `GetAllPanes`), but to realize | |
1096 | the changes, Update must be called. This construction allows pane | |
1097 | flicker to be avoided by updating the whole layout at one time. | |
1098 | ||
1099 | """ | |
1100 | return _aui.FrameManager_Update(*args, **kwargs) | |
1101 | ||
10044bf1 RD |
1102 | def DrawHintRect(*args, **kwargs): |
1103 | """DrawHintRect(self, Window pane_window, Point pt, Point offset)""" | |
1104 | return _aui.FrameManager_DrawHintRect(*args, **kwargs) | |
1105 | ||
1106 | def ShowHint(*args, **kwargs): | |
1107 | """ShowHint(self, Rect rect)""" | |
1108 | return _aui.FrameManager_ShowHint(*args, **kwargs) | |
1109 | ||
1110 | def HideHint(*args, **kwargs): | |
1111 | """HideHint(self)""" | |
1112 | return _aui.FrameManager_HideHint(*args, **kwargs) | |
1113 | ||
81f5836b RD |
1114 | def OnRender(*args, **kwargs): |
1115 | """OnRender(self, FrameManagerEvent evt)""" | |
1116 | return _aui.FrameManager_OnRender(*args, **kwargs) | |
1117 | ||
1118 | def OnPaneButton(*args, **kwargs): | |
1119 | """OnPaneButton(self, FrameManagerEvent evt)""" | |
1120 | return _aui.FrameManager_OnPaneButton(*args, **kwargs) | |
1121 | ||
27e45892 RD |
1122 | def GetPane(self, item): |
1123 | """ | |
1124 | GetPane(self, window_or_info item) -> PaneInfo | |
1125 | ||
1126 | GetPane is used to search for a `PaneInfo` object either by | |
1127 | widget reference or by pane name, which acts as a unique id | |
1128 | for a window pane. The returned `PaneInfo` object may then be | |
1129 | modified to change a pane's look, state or position. After one | |
1130 | or more modifications to the `PaneInfo`, `FrameManager.Update` | |
1131 | should be called to realize the changes to the user interface. | |
1132 | ||
1133 | If the lookup failed (meaning the pane could not be found in | |
1134 | the manager) GetPane returns an empty `PaneInfo`, a condition | |
1135 | which can be checked by calling `PaneInfo.IsOk`. | |
1136 | """ | |
1137 | if isinstance(item, wx.Window): | |
1138 | return self._GetPaneByWidget(item) | |
1139 | else: | |
1140 | return self._GetPaneByName(item) | |
1141 | ||
1142 | def AddPane(self, window, info=None, caption=None): | |
1143 | """ | |
1144 | AddPane(self, window, info=None, caption=None) -> bool | |
1145 | ||
1146 | AddPane tells the frame manager to start managing a child | |
1147 | window. There are two versions of this function. The first | |
1148 | verison accepts a `PaneInfo` object for the ``info`` parameter | |
1149 | and allows the full spectrum of pane parameter | |
1150 | possibilities. (Say that 3 times fast!) | |
1151 | ||
1152 | The second version is used for simpler user interfaces which | |
1153 | do not require as much configuration. In this case the | |
1154 | ``info`` parameter specifies the direction property of the | |
1155 | pane info, and defaults to ``wx.LEFT``. The pane caption may | |
1156 | also be specified as an extra parameter in this form. | |
1157 | """ | |
1158 | if type(info) == PaneInfo: | |
1159 | return self._AddPane1(window, info) | |
1160 | else: | |
1161 | ||
1162 | if info is None: | |
1163 | info = wx.LEFT | |
1164 | if caption is None: | |
1165 | caption = "" | |
1166 | return self._AddPane2(window, info, caption) | |
1167 | ||
10044bf1 RD |
1168 | SetFrame = wx._deprecated(SetManagedWindow, |
1169 | "SetFrame is deprecated, use `SetManagedWindow` instead.") | |
1170 | GetFrame = wx._deprecated(GetManagedWindow, | |
1171 | "GetFrame is deprecated, use `GetManagedWindow` instead.") | |
1172 | ||
27e45892 RD |
1173 | _aui.FrameManager_swigregister(FrameManager) |
1174 | ||
1175 | class FrameManagerEvent(_core.Event): | |
1176 | """Proxy of C++ FrameManagerEvent class""" | |
1177 | thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') | |
1178 | __repr__ = _swig_repr | |
1179 | def __init__(self, *args, **kwargs): | |
1180 | """__init__(self, EventType type=wxEVT_NULL) -> FrameManagerEvent""" | |
1181 | _aui.FrameManagerEvent_swiginit(self,_aui.new_FrameManagerEvent(*args, **kwargs)) | |
1182 | def Clone(*args, **kwargs): | |
1183 | """Clone(self) -> Event""" | |
1184 | return _aui.FrameManagerEvent_Clone(*args, **kwargs) | |
1185 | ||
1186 | def SetPane(*args, **kwargs): | |
1187 | """SetPane(self, PaneInfo p)""" | |
1188 | return _aui.FrameManagerEvent_SetPane(*args, **kwargs) | |
1189 | ||
1190 | def SetButton(*args, **kwargs): | |
1191 | """SetButton(self, int b)""" | |
1192 | return _aui.FrameManagerEvent_SetButton(*args, **kwargs) | |
1193 | ||
81f5836b RD |
1194 | def SetDC(*args, **kwargs): |
1195 | """SetDC(self, DC pdc)""" | |
1196 | return _aui.FrameManagerEvent_SetDC(*args, **kwargs) | |
1197 | ||
27e45892 RD |
1198 | def GetPane(*args, **kwargs): |
1199 | """GetPane(self) -> PaneInfo""" | |
1200 | return _aui.FrameManagerEvent_GetPane(*args, **kwargs) | |
1201 | ||
1202 | def GetButton(*args, **kwargs): | |
1203 | """GetButton(self) -> int""" | |
1204 | return _aui.FrameManagerEvent_GetButton(*args, **kwargs) | |
1205 | ||
81f5836b RD |
1206 | def GetDC(*args, **kwargs): |
1207 | """GetDC(self) -> DC""" | |
1208 | return _aui.FrameManagerEvent_GetDC(*args, **kwargs) | |
1209 | ||
27e45892 RD |
1210 | def Veto(*args, **kwargs): |
1211 | """Veto(self, bool veto=True)""" | |
1212 | return _aui.FrameManagerEvent_Veto(*args, **kwargs) | |
1213 | ||
1214 | def GetVeto(*args, **kwargs): | |
1215 | """GetVeto(self) -> bool""" | |
1216 | return _aui.FrameManagerEvent_GetVeto(*args, **kwargs) | |
1217 | ||
1218 | def SetCanVeto(*args, **kwargs): | |
1219 | """SetCanVeto(self, bool can_veto)""" | |
1220 | return _aui.FrameManagerEvent_SetCanVeto(*args, **kwargs) | |
1221 | ||
1222 | def CanVeto(*args, **kwargs): | |
1223 | """CanVeto(self) -> bool""" | |
1224 | return _aui.FrameManagerEvent_CanVeto(*args, **kwargs) | |
1225 | ||
1226 | pane = property(_aui.FrameManagerEvent_pane_get, _aui.FrameManagerEvent_pane_set) | |
1227 | button = property(_aui.FrameManagerEvent_button_get, _aui.FrameManagerEvent_button_set) | |
1228 | veto_flag = property(_aui.FrameManagerEvent_veto_flag_get, _aui.FrameManagerEvent_veto_flag_set) | |
1229 | canveto_flag = property(_aui.FrameManagerEvent_canveto_flag_get, _aui.FrameManagerEvent_canveto_flag_set) | |
81f5836b | 1230 | dc = property(_aui.FrameManagerEvent_dc_get, _aui.FrameManagerEvent_dc_set) |
27e45892 RD |
1231 | _aui.FrameManagerEvent_swigregister(FrameManagerEvent) |
1232 | ||
1233 | class DockInfo(object): | |
1234 | """Proxy of C++ DockInfo class""" | |
1235 | thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') | |
1236 | __repr__ = _swig_repr | |
1237 | def __init__(self, *args, **kwargs): | |
1238 | """__init__(self) -> DockInfo""" | |
1239 | _aui.DockInfo_swiginit(self,_aui.new_DockInfo(*args, **kwargs)) | |
1240 | def IsOk(*args, **kwargs): | |
1241 | """IsOk(self) -> bool""" | |
1242 | return _aui.DockInfo_IsOk(*args, **kwargs) | |
1243 | ||
1244 | def IsHorizontal(*args, **kwargs): | |
1245 | """IsHorizontal(self) -> bool""" | |
1246 | return _aui.DockInfo_IsHorizontal(*args, **kwargs) | |
1247 | ||
1248 | def IsVertical(*args, **kwargs): | |
1249 | """IsVertical(self) -> bool""" | |
1250 | return _aui.DockInfo_IsVertical(*args, **kwargs) | |
1251 | ||
1252 | panes = property(_aui.DockInfo_panes_get, _aui.DockInfo_panes_set) | |
1253 | rect = property(_aui.DockInfo_rect_get, _aui.DockInfo_rect_set) | |
1254 | dock_direction = property(_aui.DockInfo_dock_direction_get, _aui.DockInfo_dock_direction_set) | |
1255 | dock_layer = property(_aui.DockInfo_dock_layer_get, _aui.DockInfo_dock_layer_set) | |
1256 | dock_row = property(_aui.DockInfo_dock_row_get, _aui.DockInfo_dock_row_set) | |
1257 | size = property(_aui.DockInfo_size_get, _aui.DockInfo_size_set) | |
1258 | min_size = property(_aui.DockInfo_min_size_get, _aui.DockInfo_min_size_set) | |
1259 | resizable = property(_aui.DockInfo_resizable_get, _aui.DockInfo_resizable_set) | |
1260 | toolbar = property(_aui.DockInfo_toolbar_get, _aui.DockInfo_toolbar_set) | |
1261 | fixed = property(_aui.DockInfo_fixed_get, _aui.DockInfo_fixed_set) | |
1262 | _aui.DockInfo_swigregister(DockInfo) | |
1263 | ||
1264 | class DockUIPart(object): | |
1265 | """Proxy of C++ DockUIPart class""" | |
1266 | thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') | |
1267 | def __init__(self): raise AttributeError, "No constructor defined" | |
1268 | __repr__ = _swig_repr | |
1269 | typeCaption = _aui.DockUIPart_typeCaption | |
1270 | typeGripper = _aui.DockUIPart_typeGripper | |
1271 | typeDock = _aui.DockUIPart_typeDock | |
1272 | typeDockSizer = _aui.DockUIPart_typeDockSizer | |
1273 | typePane = _aui.DockUIPart_typePane | |
1274 | typePaneSizer = _aui.DockUIPart_typePaneSizer | |
1275 | typeBackground = _aui.DockUIPart_typeBackground | |
1276 | typePaneBorder = _aui.DockUIPart_typePaneBorder | |
1277 | typePaneButton = _aui.DockUIPart_typePaneButton | |
1278 | type = property(_aui.DockUIPart_type_get, _aui.DockUIPart_type_set) | |
1279 | orientation = property(_aui.DockUIPart_orientation_get, _aui.DockUIPart_orientation_set) | |
1280 | dock = property(_aui.DockUIPart_dock_get, _aui.DockUIPart_dock_set) | |
1281 | pane = property(_aui.DockUIPart_pane_get, _aui.DockUIPart_pane_set) | |
1282 | button = property(_aui.DockUIPart_button_get, _aui.DockUIPart_button_set) | |
1283 | cont_sizer = property(_aui.DockUIPart_cont_sizer_get, _aui.DockUIPart_cont_sizer_set) | |
1284 | sizer_item = property(_aui.DockUIPart_sizer_item_get, _aui.DockUIPart_sizer_item_set) | |
1285 | rect = property(_aui.DockUIPart_rect_get, _aui.DockUIPart_rect_set) | |
1286 | _aui.DockUIPart_swigregister(DockUIPart) | |
1287 | ||
1288 | class PaneButton(object): | |
1289 | """Proxy of C++ PaneButton class""" | |
1290 | thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') | |
1291 | def __init__(self): raise AttributeError, "No constructor defined" | |
1292 | __repr__ = _swig_repr | |
1293 | button_id = property(_aui.PaneButton_button_id_get, _aui.PaneButton_button_id_set) | |
1294 | _aui.PaneButton_swigregister(PaneButton) | |
1295 | ||
1296 | wxEVT_AUI_PANEBUTTON = _aui.wxEVT_AUI_PANEBUTTON | |
1297 | wxEVT_AUI_PANECLOSE = _aui.wxEVT_AUI_PANECLOSE | |
81f5836b | 1298 | wxEVT_AUI_RENDER = _aui.wxEVT_AUI_RENDER |
27e45892 RD |
1299 | EVT_AUI_PANEBUTTON = wx.PyEventBinder( wxEVT_AUI_PANEBUTTON ) |
1300 | EVT_AUI_PANECLOSE = wx.PyEventBinder( wxEVT_AUI_PANECLOSE ) | |
81f5836b | 1301 | EVT_AUI_RENDER = wx.PyEventBinder( wxEVT_AUI_RENDER ) |
27e45892 RD |
1302 | |
1303 | class DockArt(object): | |
1304 | """ | |
1305 | DockArt is an art provider class which does all of the drawing for | |
1306 | `FrameManager`. This allows the library caller to customize or replace the | |
1307 | dock art and drawing routines by deriving a new class from `PyDockArt`. The | |
1308 | active dock art class can be set via `FrameManager.SetArtProvider`. | |
1309 | ||
1310 | """ | |
1311 | thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') | |
1312 | def __init__(self): raise AttributeError, "No constructor defined" | |
1313 | __repr__ = _swig_repr | |
1314 | __swig_destroy__ = _aui.delete_DockArt | |
1315 | __del__ = lambda self : None; | |
1316 | def GetMetric(*args, **kwargs): | |
1317 | """GetMetric(self, int id) -> int""" | |
1318 | return _aui.DockArt_GetMetric(*args, **kwargs) | |
1319 | ||
1320 | def SetMetric(*args, **kwargs): | |
1321 | """SetMetric(self, int id, int new_val)""" | |
1322 | return _aui.DockArt_SetMetric(*args, **kwargs) | |
1323 | ||
1324 | def SetFont(*args, **kwargs): | |
1325 | """SetFont(self, int id, Font font)""" | |
1326 | return _aui.DockArt_SetFont(*args, **kwargs) | |
1327 | ||
1328 | def GetFont(*args, **kwargs): | |
1329 | """GetFont(self, int id) -> Font""" | |
1330 | return _aui.DockArt_GetFont(*args, **kwargs) | |
1331 | ||
1332 | def GetColour(*args, **kwargs): | |
1333 | """GetColour(self, int id) -> Colour""" | |
1334 | return _aui.DockArt_GetColour(*args, **kwargs) | |
1335 | ||
1336 | def SetColour(*args, **kwargs): | |
1337 | """SetColour(self, int id, wxColor colour)""" | |
1338 | return _aui.DockArt_SetColour(*args, **kwargs) | |
1339 | ||
1340 | def GetColor(*args, **kwargs): | |
1341 | """GetColor(self, int id) -> Colour""" | |
1342 | return _aui.DockArt_GetColor(*args, **kwargs) | |
1343 | ||
1344 | def SetColor(*args, **kwargs): | |
1345 | """SetColor(self, int id, Colour color)""" | |
1346 | return _aui.DockArt_SetColor(*args, **kwargs) | |
1347 | ||
1348 | def DrawSash(*args, **kwargs): | |
97ab0f6a | 1349 | """DrawSash(self, DC dc, Window window, int orientation, Rect rect)""" |
27e45892 RD |
1350 | return _aui.DockArt_DrawSash(*args, **kwargs) |
1351 | ||
1352 | def DrawBackground(*args, **kwargs): | |
97ab0f6a | 1353 | """DrawBackground(self, DC dc, Window window, int orientation, Rect rect)""" |
27e45892 RD |
1354 | return _aui.DockArt_DrawBackground(*args, **kwargs) |
1355 | ||
1356 | def DrawCaption(*args, **kwargs): | |
97ab0f6a | 1357 | """DrawCaption(self, DC dc, Window window, String text, Rect rect, PaneInfo pane)""" |
27e45892 RD |
1358 | return _aui.DockArt_DrawCaption(*args, **kwargs) |
1359 | ||
1360 | def DrawGripper(*args, **kwargs): | |
97ab0f6a | 1361 | """DrawGripper(self, DC dc, Window window, Rect rect, PaneInfo pane)""" |
27e45892 RD |
1362 | return _aui.DockArt_DrawGripper(*args, **kwargs) |
1363 | ||
1364 | def DrawBorder(*args, **kwargs): | |
97ab0f6a | 1365 | """DrawBorder(self, DC dc, Window window, Rect rect, PaneInfo pane)""" |
27e45892 RD |
1366 | return _aui.DockArt_DrawBorder(*args, **kwargs) |
1367 | ||
1368 | def DrawPaneButton(*args, **kwargs): | |
97ab0f6a RD |
1369 | """ |
1370 | DrawPaneButton(self, DC dc, Window window, int button, int button_state, | |
1371 | Rect rect, PaneInfo pane) | |
1372 | """ | |
27e45892 RD |
1373 | return _aui.DockArt_DrawPaneButton(*args, **kwargs) |
1374 | ||
1375 | _aui.DockArt_swigregister(DockArt) | |
1376 | ||
1377 | class DefaultDockArt(DockArt): | |
1378 | """ | |
1379 | DefaultDockArt is the type of art class constructed by default for the | |
1380 | `FrameManager`. | |
1381 | """ | |
1382 | thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') | |
1383 | __repr__ = _swig_repr | |
1384 | def __init__(self, *args, **kwargs): | |
1385 | """ | |
1386 | __init__(self) -> DefaultDockArt | |
1387 | ||
1388 | DefaultDockArt is the type of art class constructed by default for the | |
1389 | `FrameManager`. | |
1390 | """ | |
1391 | _aui.DefaultDockArt_swiginit(self,_aui.new_DefaultDockArt(*args, **kwargs)) | |
1392 | _aui.DefaultDockArt_swigregister(DefaultDockArt) | |
1393 | ||
fc46b7f3 | 1394 | class FloatingPane(_windows.MiniFrame): |
27e45892 RD |
1395 | """Proxy of C++ FloatingPane class""" |
1396 | thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') | |
1397 | __repr__ = _swig_repr | |
1398 | def __init__(self, *args, **kwargs): | |
1399 | """ | |
1400 | __init__(self, Window parent, FrameManager owner_mgr, PaneInfo pane, | |
1401 | int id=ID_ANY) -> FloatingPane | |
1402 | """ | |
1403 | _aui.FloatingPane_swiginit(self,_aui.new_FloatingPane(*args, **kwargs)) | |
1404 | __swig_destroy__ = _aui.delete_FloatingPane | |
1405 | __del__ = lambda self : None; | |
1406 | def SetPaneWindow(*args, **kwargs): | |
1407 | """SetPaneWindow(self, PaneInfo pane)""" | |
1408 | return _aui.FloatingPane_SetPaneWindow(*args, **kwargs) | |
1409 | ||
1410 | _aui.FloatingPane_swigregister(FloatingPane) | |
1411 | ||
10044bf1 RD |
1412 | class AuiNotebookEvent(_core.NotifyEvent): |
1413 | """Proxy of C++ AuiNotebookEvent class""" | |
1414 | thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') | |
1415 | __repr__ = _swig_repr | |
1416 | def __init__(self, *args, **kwargs): | |
1417 | """__init__(self, EventType command_type=wxEVT_NULL, int win_id=0) -> AuiNotebookEvent""" | |
1418 | _aui.AuiNotebookEvent_swiginit(self,_aui.new_AuiNotebookEvent(*args, **kwargs)) | |
1419 | def SetSelection(*args, **kwargs): | |
1420 | """SetSelection(self, int s)""" | |
1421 | return _aui.AuiNotebookEvent_SetSelection(*args, **kwargs) | |
1422 | ||
1423 | def SetOldSelection(*args, **kwargs): | |
1424 | """SetOldSelection(self, int s)""" | |
1425 | return _aui.AuiNotebookEvent_SetOldSelection(*args, **kwargs) | |
1426 | ||
1427 | def GetSelection(*args, **kwargs): | |
1428 | """ | |
1429 | GetSelection(self) -> int | |
1430 | ||
1431 | Returns item index for a listbox or choice selection event (not valid | |
1432 | for a deselection). | |
1433 | """ | |
1434 | return _aui.AuiNotebookEvent_GetSelection(*args, **kwargs) | |
1435 | ||
1436 | def GetOldSelection(*args, **kwargs): | |
1437 | """GetOldSelection(self) -> int""" | |
1438 | return _aui.AuiNotebookEvent_GetOldSelection(*args, **kwargs) | |
1439 | ||
1440 | old_selection = property(_aui.AuiNotebookEvent_old_selection_get, _aui.AuiNotebookEvent_old_selection_set) | |
1441 | selection = property(_aui.AuiNotebookEvent_selection_get, _aui.AuiNotebookEvent_selection_set) | |
1442 | _aui.AuiNotebookEvent_swigregister(AuiNotebookEvent) | |
1443 | ||
1444 | class AuiNotebookPage(object): | |
1445 | """Proxy of C++ AuiNotebookPage class""" | |
1446 | thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') | |
1447 | def __init__(self): raise AttributeError, "No constructor defined" | |
1448 | __repr__ = _swig_repr | |
1449 | window = property(_aui.AuiNotebookPage_window_get, _aui.AuiNotebookPage_window_set) | |
1450 | caption = property(_aui.AuiNotebookPage_caption_get, _aui.AuiNotebookPage_caption_set) | |
1451 | bitmap = property(_aui.AuiNotebookPage_bitmap_get, _aui.AuiNotebookPage_bitmap_set) | |
1452 | rect = property(_aui.AuiNotebookPage_rect_get, _aui.AuiNotebookPage_rect_set) | |
1453 | active = property(_aui.AuiNotebookPage_active_get, _aui.AuiNotebookPage_active_set) | |
1454 | _aui.AuiNotebookPage_swigregister(AuiNotebookPage) | |
1455 | ||
1456 | class AuiTabContainerButton(object): | |
1457 | """Proxy of C++ AuiTabContainerButton class""" | |
1458 | thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') | |
1459 | def __init__(self): raise AttributeError, "No constructor defined" | |
1460 | __repr__ = _swig_repr | |
1461 | id = property(_aui.AuiTabContainerButton_id_get, _aui.AuiTabContainerButton_id_set) | |
1462 | cur_state = property(_aui.AuiTabContainerButton_cur_state_get, _aui.AuiTabContainerButton_cur_state_set) | |
1463 | bitmap = property(_aui.AuiTabContainerButton_bitmap_get, _aui.AuiTabContainerButton_bitmap_set) | |
1464 | rect = property(_aui.AuiTabContainerButton_rect_get, _aui.AuiTabContainerButton_rect_set) | |
1465 | _aui.AuiTabContainerButton_swigregister(AuiTabContainerButton) | |
1466 | ||
1467 | class AuiTabContainer(object): | |
1468 | """Proxy of C++ AuiTabContainer class""" | |
1469 | thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') | |
1470 | __repr__ = _swig_repr | |
1471 | def __init__(self, *args, **kwargs): | |
1472 | """__init__(self) -> AuiTabContainer""" | |
1473 | _aui.AuiTabContainer_swiginit(self,_aui.new_AuiTabContainer(*args, **kwargs)) | |
1474 | __swig_destroy__ = _aui.delete_AuiTabContainer | |
1475 | __del__ = lambda self : None; | |
1476 | def AddPage(*args, **kwargs): | |
1477 | """AddPage(self, Window page, AuiNotebookPage info) -> bool""" | |
1478 | return _aui.AuiTabContainer_AddPage(*args, **kwargs) | |
1479 | ||
1480 | def InsertPage(*args, **kwargs): | |
1481 | """InsertPage(self, Window page, AuiNotebookPage info, size_t idx) -> bool""" | |
1482 | return _aui.AuiTabContainer_InsertPage(*args, **kwargs) | |
1483 | ||
1484 | def RemovePage(*args, **kwargs): | |
1485 | """RemovePage(self, Window page) -> bool""" | |
1486 | return _aui.AuiTabContainer_RemovePage(*args, **kwargs) | |
1487 | ||
1488 | def SetActivePage(*args): | |
1489 | """ | |
1490 | SetActivePage(self, Window page) -> bool | |
1491 | SetActivePage(self, size_t page) -> bool | |
1492 | """ | |
1493 | return _aui.AuiTabContainer_SetActivePage(*args) | |
1494 | ||
1495 | def SetNoneActive(*args, **kwargs): | |
1496 | """SetNoneActive(self)""" | |
1497 | return _aui.AuiTabContainer_SetNoneActive(*args, **kwargs) | |
1498 | ||
1499 | def GetActivePage(*args, **kwargs): | |
1500 | """GetActivePage(self) -> int""" | |
1501 | return _aui.AuiTabContainer_GetActivePage(*args, **kwargs) | |
1502 | ||
1503 | def TabHitTest(*args, **kwargs): | |
1504 | """TabHitTest(self, int x, int y, Window hit) -> bool""" | |
1505 | return _aui.AuiTabContainer_TabHitTest(*args, **kwargs) | |
1506 | ||
1507 | def ButtonHitTest(*args, **kwargs): | |
1508 | """ButtonHitTest(self, int x, int y, AuiTabContainerButton hit) -> bool""" | |
1509 | return _aui.AuiTabContainer_ButtonHitTest(*args, **kwargs) | |
1510 | ||
1511 | def GetWindowFromIdx(*args, **kwargs): | |
1512 | """GetWindowFromIdx(self, size_t idx) -> Window""" | |
1513 | return _aui.AuiTabContainer_GetWindowFromIdx(*args, **kwargs) | |
1514 | ||
1515 | def GetIdxFromWindow(*args, **kwargs): | |
1516 | """GetIdxFromWindow(self, Window page) -> int""" | |
1517 | return _aui.AuiTabContainer_GetIdxFromWindow(*args, **kwargs) | |
1518 | ||
1519 | def GetPageCount(*args, **kwargs): | |
1520 | """GetPageCount(self) -> size_t""" | |
1521 | return _aui.AuiTabContainer_GetPageCount(*args, **kwargs) | |
1522 | ||
1523 | def GetPage(*args, **kwargs): | |
1524 | """GetPage(self, size_t idx) -> AuiNotebookPage""" | |
1525 | return _aui.AuiTabContainer_GetPage(*args, **kwargs) | |
1526 | ||
1527 | def GetPages(*args, **kwargs): | |
1528 | """GetPages(self) -> wxAuiNotebookPageArray""" | |
1529 | return _aui.AuiTabContainer_GetPages(*args, **kwargs) | |
1530 | ||
1531 | def SetNormalFont(*args, **kwargs): | |
1532 | """SetNormalFont(self, Font normal_font)""" | |
1533 | return _aui.AuiTabContainer_SetNormalFont(*args, **kwargs) | |
1534 | ||
1535 | def SetSelectedFont(*args, **kwargs): | |
1536 | """SetSelectedFont(self, Font selected_font)""" | |
1537 | return _aui.AuiTabContainer_SetSelectedFont(*args, **kwargs) | |
1538 | ||
1539 | def SetMeasuringFont(*args, **kwargs): | |
1540 | """SetMeasuringFont(self, Font measuring_font)""" | |
1541 | return _aui.AuiTabContainer_SetMeasuringFont(*args, **kwargs) | |
1542 | ||
1543 | def DoShowHide(*args, **kwargs): | |
1544 | """DoShowHide(self)""" | |
1545 | return _aui.AuiTabContainer_DoShowHide(*args, **kwargs) | |
1546 | ||
1547 | def SetRect(*args, **kwargs): | |
1548 | """SetRect(self, Rect rect)""" | |
1549 | return _aui.AuiTabContainer_SetRect(*args, **kwargs) | |
1550 | ||
1551 | def AddButton(*args, **kwargs): | |
1552 | """AddButton(self, int id, Bitmap bmp)""" | |
1553 | return _aui.AuiTabContainer_AddButton(*args, **kwargs) | |
1554 | ||
1555 | _aui.AuiTabContainer_swigregister(AuiTabContainer) | |
1556 | ||
1557 | class AuiTabCtrl(_core.Control,AuiTabContainer): | |
1558 | """Proxy of C++ AuiTabCtrl class""" | |
1559 | thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') | |
1560 | __repr__ = _swig_repr | |
1561 | def __init__(self, *args, **kwargs): | |
1562 | """ | |
1563 | __init__(self, Window parent, int id=ID_ANY, Point pos=DefaultPosition, | |
1564 | Size size=DefaultSize, long style=0) -> AuiTabCtrl | |
1565 | """ | |
1566 | _aui.AuiTabCtrl_swiginit(self,_aui.new_AuiTabCtrl(*args, **kwargs)) | |
1567 | self._setOORInfo(self) | |
1568 | ||
1569 | _aui.AuiTabCtrl_swigregister(AuiTabCtrl) | |
1570 | ||
1571 | class AuiMultiNotebook(_core.Control): | |
1572 | """Proxy of C++ AuiMultiNotebook class""" | |
1573 | thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') | |
1574 | __repr__ = _swig_repr | |
1575 | def __init__(self, *args, **kwargs): | |
1576 | """ | |
1577 | __init__(self, Window parent, int id=ID_ANY, Point pos=DefaultPosition, | |
1578 | Size size=DefaultSize, long style=0) -> AuiMultiNotebook | |
1579 | """ | |
1580 | _aui.AuiMultiNotebook_swiginit(self,_aui.new_AuiMultiNotebook(*args, **kwargs)) | |
1581 | self._setOORInfo(self) | |
1582 | ||
1583 | def Create(*args, **kwargs): | |
1584 | """ | |
1585 | Create(self, Window parent, int id=ID_ANY, Point pos=DefaultPosition, | |
1586 | Size size=DefaultSize, long style=0) -> bool | |
1587 | ||
1588 | Do the 2nd phase and create the GUI control. | |
1589 | """ | |
1590 | return _aui.AuiMultiNotebook_Create(*args, **kwargs) | |
1591 | ||
1592 | def AddPage(*args, **kwargs): | |
1593 | """AddPage(self, Window page, String caption, bool select=False, Bitmap bitmap=wxNullBitmap) -> bool""" | |
1594 | return _aui.AuiMultiNotebook_AddPage(*args, **kwargs) | |
1595 | ||
1596 | def InsertPage(*args, **kwargs): | |
1597 | """ | |
1598 | InsertPage(self, size_t page_idx, Window page, String caption, bool select=False, | |
1599 | Bitmap bitmap=wxNullBitmap) -> bool | |
1600 | """ | |
1601 | return _aui.AuiMultiNotebook_InsertPage(*args, **kwargs) | |
1602 | ||
1603 | def DeletePage(*args, **kwargs): | |
1604 | """DeletePage(self, size_t page) -> bool""" | |
1605 | return _aui.AuiMultiNotebook_DeletePage(*args, **kwargs) | |
1606 | ||
1607 | def RemovePage(*args, **kwargs): | |
1608 | """RemovePage(self, size_t page) -> bool""" | |
1609 | return _aui.AuiMultiNotebook_RemovePage(*args, **kwargs) | |
1610 | ||
1611 | def SetPageText(*args, **kwargs): | |
1612 | """SetPageText(self, size_t page, String text) -> bool""" | |
1613 | return _aui.AuiMultiNotebook_SetPageText(*args, **kwargs) | |
1614 | ||
1615 | def SetSelection(*args, **kwargs): | |
1616 | """SetSelection(self, size_t new_page) -> size_t""" | |
1617 | return _aui.AuiMultiNotebook_SetSelection(*args, **kwargs) | |
1618 | ||
1619 | def GetSelection(*args, **kwargs): | |
1620 | """GetSelection(self) -> int""" | |
1621 | return _aui.AuiMultiNotebook_GetSelection(*args, **kwargs) | |
1622 | ||
1623 | def GetPageCount(*args, **kwargs): | |
1624 | """GetPageCount(self) -> size_t""" | |
1625 | return _aui.AuiMultiNotebook_GetPageCount(*args, **kwargs) | |
1626 | ||
1627 | def GetPage(*args, **kwargs): | |
1628 | """GetPage(self, size_t page_idx) -> Window""" | |
1629 | return _aui.AuiMultiNotebook_GetPage(*args, **kwargs) | |
1630 | ||
1631 | _aui.AuiMultiNotebook_swigregister(AuiMultiNotebook) | |
1632 | ||
1633 | def PreAuiMultiNotebook(*args, **kwargs): | |
1634 | """PreAuiMultiNotebook() -> AuiMultiNotebook""" | |
1635 | val = _aui.new_PreAuiMultiNotebook(*args, **kwargs) | |
1636 | self._setOORInfo(self) | |
1637 | return val | |
1638 | ||
1639 | wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED = _aui.wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED | |
1640 | wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING = _aui.wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING | |
1641 | wxEVT_COMMAND_AUINOTEBOOK_BUTTON = _aui.wxEVT_COMMAND_AUINOTEBOOK_BUTTON | |
1642 | wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG = _aui.wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG | |
1643 | wxEVT_COMMAND_AUINOTEBOOK_END_DRAG = _aui.wxEVT_COMMAND_AUINOTEBOOK_END_DRAG | |
1644 | wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION = _aui.wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION | |
1645 | EVT_AUINOTEBOOK_PAGE_CHANGED = wx.PyEventBinder( wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED, 1 ) | |
1646 | EVT_AUINOTEBOOK_PAGE_CHANGING = wx.PyEventBinder( wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, 1 ) | |
1647 | EVT_AUINOTEBOOK_BUTTON = wx.PyEventBinder( wxEVT_COMMAND_AUINOTEBOOK_BUTTON, 1 ) | |
1648 | EVT_AUINOTEBOOK_BEGIN_DRAG = wx.PyEventBinder( wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG, 1 ) | |
1649 | EVT_AUINOTEBOOK_END_DRAG = wx.PyEventBinder( wxEVT_COMMAND_AUINOTEBOOK_END_DRAG, 1 ) | |
1650 | EVT_AUINOTEBOOK_DRAG_MOTION = wx.PyEventBinder( wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION, 1 ) | |
1651 | ||
27e45892 RD |
1652 | class PyDockArt(DefaultDockArt): |
1653 | """ | |
1654 | This version of the `DockArt` class has been instrumented to be | |
1655 | subclassable in Python and to reflect all calls to the C++ base class | |
1656 | methods to the Python methods implemented in the derived class. | |
1657 | """ | |
1658 | thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') | |
1659 | def __init__(self): raise AttributeError, "No constructor defined" | |
1660 | __repr__ = _swig_repr | |
1661 | _aui.PyDockArt_swigregister(PyDockArt) | |
1662 | ||
1663 | ||
1664 |