]> git.saurik.com Git - wxWidgets.git/blob - interface/aui/framemanager.h
improved rendering of styles and events sections: put the description of those items...
[wxWidgets.git] / interface / aui / framemanager.h
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: aui/aui.h
3 // Purpose: interface of wxAuiManager
4 // Author: wxWidgets team
5 // RCS-ID: $Id$
6 // Licence: wxWindows license
7 /////////////////////////////////////////////////////////////////////////////
8
9
10 /**
11 @todo TOWRITE
12 */
13 enum wxAuiManagerDock
14 {
15 wxAUI_DOCK_NONE = 0,
16 wxAUI_DOCK_TOP = 1,
17 wxAUI_DOCK_RIGHT = 2,
18 wxAUI_DOCK_BOTTOM = 3,
19 wxAUI_DOCK_LEFT = 4,
20 wxAUI_DOCK_CENTER = 5,
21 wxAUI_DOCK_CENTRE = wxAUI_DOCK_CENTER
22 };
23
24
25 /**
26 @todo TOWRITE
27 */
28 enum wxAuiManagerOption
29 {
30 wxAUI_MGR_ALLOW_FLOATING = 1 << 0,
31 wxAUI_MGR_ALLOW_ACTIVE_PANE = 1 << 1,
32 wxAUI_MGR_TRANSPARENT_DRAG = 1 << 2,
33 wxAUI_MGR_TRANSPARENT_HINT = 1 << 3,
34 wxAUI_MGR_VENETIAN_BLINDS_HINT = 1 << 4,
35 wxAUI_MGR_RECTANGLE_HINT = 1 << 5,
36 wxAUI_MGR_HINT_FADE = 1 << 6,
37 wxAUI_MGR_NO_VENETIAN_BLINDS_FADE = 1 << 7,
38
39 wxAUI_MGR_DEFAULT = wxAUI_MGR_ALLOW_FLOATING |
40 wxAUI_MGR_TRANSPARENT_HINT |
41 wxAUI_MGR_HINT_FADE |
42 wxAUI_MGR_NO_VENETIAN_BLINDS_FADE
43 };
44
45 /**
46 @class wxAuiManager
47 @headerfile aui.h wx/aui/aui.h
48
49 wxAuiManager is the central class of the wxAUI class framework.
50 See also @ref overview_aui.
51
52 wxAuiManager manages the panes associated with it for a particular wxFrame,
53 using a pane's wxAuiPaneInfo information to determine each pane's docking
54 and floating behavior.
55
56 wxAuiManager uses wxWidgets' sizer mechanism to plan the layout of each frame.
57 It uses a replaceable dock art class to do all drawing, so all drawing is
58 localized in one area, and may be customized depending on an application's
59 specific needs.
60
61 wxAuiManager works as follows: the programmer adds panes to the class,
62 or makes changes to existing pane properties (dock position, floating
63 state, show state, etc.). To apply these changes, wxAuiManager's
64 Update() function is called. This batch processing can be used to avoid
65 flicker, by modifying more than one pane at a time, and then "committing"
66 all of the changes at once by calling Update().
67
68 Panes can be added quite easily:
69
70 @code
71 wxTextCtrl* text1 = new wxTextCtrl(this, -1);
72 wxTextCtrl* text2 = new wxTextCtrl(this, -1);
73 m_mgr.AddPane(text1, wxLEFT, wxT("Pane Caption"));
74 m_mgr.AddPane(text2, wxBOTTOM, wxT("Pane Caption"));
75 m_mgr.Update();
76 @endcode
77
78 Later on, the positions can be modified easily. The following will float
79 an existing pane in a tool window:
80
81 @code
82 m_mgr.GetPane(text1).Float();
83 @endcode
84
85
86 @section wxauimanager_layers Layers, Rows and Directions, Positions
87
88 Inside wxAUI, the docking layout is figured out by checking several pane
89 parameters. Four of these are important for determining where a pane will end up:
90
91 @li Direction: Each docked pane has a direction, Top, Bottom, Left, Right, or Center.
92 This is fairly self-explanatory. The pane will be placed in the location specified
93 by this variable.
94 @li Position: More than one pane can be placed inside of a dock. Imagine two panes
95 being docked on the left side of a window. One pane can be placed over another.
96 In proportionally managed docks, the pane position indicates its sequential position,
97 starting with zero. So, in our scenario with two panes docked on the left side,
98 the top pane in the dock would have position 0, and the second one would occupy
99 position 1.
100 @li Row: A row can allow for two docks to be placed next to each other. One of the
101 most common places for this to happen is in the toolbar. Multiple toolbar rows
102 are allowed, the first row being row 0, and the second row 1. Rows can also be
103 used on vertically docked panes.
104 @li Layer: A layer is akin to an onion. Layer 0 is the very center of the managed pane.
105 Thus, if a pane is in layer 0, it will be closest to the center window (also
106 sometimes known as the "content window"). Increasing layers "swallow up" all
107 layers of a lower value. This can look very similar to multiple rows, but is
108 different because all panes in a lower level yield to panes in higher levels.
109 The best way to understand layers is by running the wxAUI sample.
110
111
112 @library{wxbase}
113 @category{aui}
114
115 @see wxAuiPaneInfo, wxAuiDockArt
116 */
117 class wxAuiManager : public wxEvtHandler
118 {
119 public:
120 /**
121 Constructor. @a managed_wnd specifies the wxFrame which should be managed.
122 @a flags specifies options which allow the frame management behavior
123 to be modified.
124 */
125 wxAuiManager(wxWindow* managed_wnd = NULL,
126 unsigned int flags = wxAUI_MGR_DEFAULT);
127
128 /**
129 Dtor.
130 */
131 virtual ~wxAuiManager();
132
133 //@{
134 /**
135 AddPane() tells the frame manager to start managing a child window.
136 There are several versions of this function. The first version allows
137 the full spectrum of pane parameter possibilities. The second version is
138 used for simpler user interfaces which do not require as much configuration.
139 The last version allows a drop position to be specified, which will determine
140 where the pane will be added.
141 */
142 bool AddPane(wxWindow* window, const wxAuiPaneInfo& pane_info);
143 bool AddPane(wxWindow* window, int direction = wxLEFT,
144 const wxString& caption = wxEmptyString);
145 bool AddPane(wxWindow* window,
146 const wxAuiPaneInfo& pane_info,
147 const wxPoint& drop_pos);
148 //@}
149
150 /**
151 Tells the wxAuiManager to stop managing the pane specified by window.
152 The window, if in a floated frame, is reparented to the frame managed
153 by wxAuiManager.
154 */
155 bool DetachPane(wxWindow* window);
156
157 /**
158 Returns an array of all panes managed by the frame manager.
159 */
160 wxAuiPaneInfoArray& GetAllPanes();
161
162 /**
163 Returns the current art provider being used.
164 @see wxAuiDockArt.
165 */
166 wxAuiDockArt* GetArtProvider() const;
167
168 /**
169 Returns the current dock constraint values.
170 See SetDockSizeConstraint() for more information.
171 */
172 void GetDockSizeConstraint(double* widthpct, double* heightpct) const;
173
174 /**
175 Returns the current manager's flags.
176 */
177 unsigned int GetFlags() const;
178
179 /**
180 Returns the frame currently being managed by wxAuiManager.
181 */
182 wxWindow* GetManagedWindow() const;
183
184 /**
185 Calling this method will return the wxAuiManager for a given window.
186 The @a window parameter should specify any child window or sub-child
187 window of the frame or window managed by wxAuiManager.
188
189 The @a window parameter need not be managed by the manager itself, nor does it
190 even need to be a child or sub-child of a managed window. It must however
191 be inside the window hierarchy underneath the managed window.
192 */
193 static wxAuiManager* GetManager(wxWindow* window);
194
195 //@{
196 /**
197 GetPane() is used to lookup a wxAuiPaneInfo object either by window pointer
198 or by pane name, which acts as a unique id for a window pane.
199
200 The returned wxAuiPaneInfo object may then be modified to change a pane's
201 look, state or position. After one or more modifications to wxAuiPaneInfo,
202 wxAuiManager::Update() should be called to commit the changes to the user
203 interface. If the lookup failed (meaning the pane could not be found in the
204 manager), a call to the returned wxAuiPaneInfo's IsOk() method will return @false.
205 */
206 wxAuiPaneInfo GetPane(wxWindow* window);
207 wxAuiPaneInfo GetPane(const wxString& name);
208 //@}
209
210 /**
211 HideHint() hides any docking hint that may be visible.
212 */
213 virtual void HideHint();
214
215 /**
216 This method is used to insert either a previously unmanaged pane window
217 into the frame manager, or to insert a currently managed pane somewhere
218 else. InsertPane() will push all panes, rows, or docks aside and
219 insert the window into the position specified by @a insert_location.
220
221 Because @a insert_location can specify either a pane, dock row, or dock
222 layer, the @a insert_level parameter is used to disambiguate this.
223 The parameter @a insert_level can take a value of wxAUI_INSERT_PANE,
224 wxAUI_INSERT_ROW or wxAUI_INSERT_DOCK.
225 */
226 bool InsertPane(wxWindow* window,
227 const wxAuiPaneInfo& insert_location,
228 int insert_level = wxAUI_INSERT_PANE);
229
230 /**
231 LoadPaneInfo() is similar to to LoadPerspective, with the exception that it
232 only loads information about a single pane. It is used in combination with
233 SavePaneInfo().
234 */
235 void LoadPaneInfo(wxString pane_part, wxAuiPaneInfo& pane);
236
237 /**
238 Loads a saved perspective. If update is @true, wxAuiManager::Update()
239 is automatically invoked, thus realizing the saved perspective on screen.
240 */
241 bool LoadPerspective(const wxString& perspective,
242 bool update = true);
243
244 /**
245 SavePaneInfo() is similar to SavePerspective, with the exception that it only
246 saves information about a single pane. It is used in combination with
247 LoadPaneInfo().
248 */
249 wxString SavePaneInfo(wxAuiPaneInfo& pane);
250
251 /**
252 Saves the entire user interface layout into an encoded wxString, which
253 can then be stored by the application (probably using wxConfig).
254
255 When a perspective is restored using LoadPerspective(), the entire user
256 interface will return to the state it was when the perspective was saved.
257 */
258 wxString SavePerspective();
259
260 /**
261 Instructs wxAuiManager to use art provider specified by parameter
262 @a art_provider for all drawing calls.
263 This allows plugable look-and-feel features. The previous art provider object,
264 if any, will be deleted by wxAuiManager.
265
266 @see wxAuiDockArt.
267 */
268 void SetArtProvider(wxAuiDockArt* art_provider);
269
270 /**
271 When a user creates a new dock by dragging a window into a docked position,
272 often times the large size of the window will create a dock that is unwieldly
273 large. wxAuiManager by default limits the size of any new dock to 1/3 of the
274 window size. For horizontal docks, this would be 1/3 of the window height.
275 For vertical docks, 1/3 of the width.
276
277 Calling this function will adjust this constraint value. The numbers must be
278 between 0.0 and 1.0. For instance, calling SetDockSizeContraint with
279 0.5, 0.5 will cause new docks to be limited to half of the size of the
280 entire managed window.
281 */
282 void SetDockSizeConstraint(double widthpct, double heightpct);
283
284 /**
285 This method is used to specify wxAuiManager's settings flags. @a flags
286 specifies options which allow the frame management behavior to be modified.
287 */
288 void SetFlags(unsigned int flags);
289
290 /**
291 Called to specify the frame or window which is to be managed by wxAuiManager.
292 Frame management is not restricted to just frames. Child windows or custom
293 controls are also allowed.
294 */
295 void SetManagedWindow(wxWindow* managed_wnd);
296
297 /**
298 This function is used by controls to explicitly show a hint window at the
299 specified rectangle. It is rarely called, and is mostly used by controls
300 implementing custom pane drag/drop behaviour.
301 The specified rectangle should be in screen coordinates.
302 */
303 virtual void ShowHint(const wxRect& rect);
304
305 /**
306 Uninitializes the framework and should be called before a managed frame or
307 window is destroyed. UnInit() is usually called in the managed wxFrame's
308 destructor. It is necessary to call this function before the managed frame
309 or window is destroyed, otherwise the manager cannot remove its custom event
310 handlers from a window.
311 */
312 void UnInit();
313
314 /**
315 This method is called after any number of changes are
316 made to any of the managed panes. Update() must be invoked after
317 AddPane() or InsertPane() are called in order to "realize" or "commit"
318 the changes. In addition, any number of changes may be made to
319 wxAuiPaneInfo structures (retrieved with wxAuiManager::GetPane), but to
320 realize the changes, Update() must be called. This construction allows
321 pane flicker to be avoided by updating the whole layout at one time.
322 */
323 void Update();
324
325 protected:
326
327 /**
328 ProcessDockResult() is a protected member of the wxAUI layout manager.
329 It can be overridden by derived classes to provide custom docking calculations.
330 */
331 virtual bool ProcessDockResult(wxAuiPaneInfo& target,
332 const wxAuiPaneInfo& new_pos);
333 };
334
335
336
337 /**
338 @class wxAuiPaneInfo
339 @headerfile aui.h wx/aui/aui.h
340
341 wxAuiPaneInfo is part of the wxAUI class framework.
342 See also @ref overview_aui.
343
344 wxAuiPaneInfo specifies all the parameters for a pane.
345 These parameters specify where the pane is on the screen, whether it is docked
346 or floating, or hidden.
347 In addition, these parameters specify the pane's docked position, floating
348 position, preferred size, minimum size, caption text among many other parameters.
349
350 @library{wxbase}
351 @category{aui}
352
353 @see wxAuiManager, wxAuiDockArt
354 */
355 class wxAuiPaneInfo
356 {
357 public:
358 wxAuiPaneInfo();
359
360 /**
361 Copy constructor.
362 */
363 wxAuiPaneInfo(const wxAuiPaneInfo& c);
364
365 //@{
366 /**
367 BestSize() sets the ideal size for the pane. The docking manager will attempt
368 to use this size as much as possible when docking or floating the pane.
369 */
370 wxAuiPaneInfo BestSize(const wxSize& size);
371 wxAuiPaneInfo BestSize(int x, int y);
372 //@}
373
374 /**
375 Bottom() sets the pane dock position to the bottom side of the frame. This is
376 the same thing as calling Direction(wxAUI_DOCK_BOTTOM).
377 */
378 wxAuiPaneInfo& Bottom();
379
380 /**
381 BottomDockable() indicates whether a pane can be docked at the bottom of the
382 frame.
383 */
384 wxAuiPaneInfo& BottomDockable(bool b = true);
385
386 /**
387 Caption() sets the caption of the pane.
388 */
389 wxAuiPaneInfo& Caption(const wxString& c);
390
391 /**
392 CaptionVisible indicates that a pane caption should be visible. If @false, no
393 pane caption is drawn.
394 */
395 wxAuiPaneInfo& CaptionVisible(bool visible = true);
396
397 //@{
398 /**
399 Center() sets the pane dock position to the left side of the frame.
400 The centre pane is the space in the middle after all border panes (left, top,
401 right, bottom) are subtracted from the layout.
402 This is the same thing as calling Direction(wxAUI_DOCK_CENTRE).
403 */
404 wxAuiPaneInfo Centre();
405 wxAuiPaneInfo Center();
406 //@}
407
408 //@{
409 /**
410 CentrePane() specifies that the pane should adopt the default center pane
411 settings. Centre panes usually do not have caption bars.
412 This function provides an easy way of preparing a pane to be displayed in
413 the center dock position.
414 */
415 wxAuiPaneInfo CentrePane();
416 wxAuiPaneInfo CenterPane();
417 //@}
418
419 /**
420 CloseButton() indicates that a close button should be drawn for the pane.
421 */
422 wxAuiPaneInfo& CloseButton(bool visible = true);
423
424 /**
425 DefaultPane() specifies that the pane should adopt the default pane settings.
426 */
427 wxAuiPaneInfo& DefaultPane();
428
429 /**
430 DestroyOnClose() indicates whether a pane should be detroyed when it is closed.
431 Normally a pane is simply hidden when the close button is clicked.
432 Setting DestroyOnClose to @true will cause the window to be destroyed when
433 the user clicks the pane's close button.
434 */
435 wxAuiPaneInfo& DestroyOnClose(bool b = true);
436
437 /**
438 Direction() determines the direction of the docked pane. It is functionally the
439 same as calling Left(), Right(), Top() or Bottom(), except that docking direction
440 may be specified programmatically via the parameter.
441 */
442 wxAuiPaneInfo& Direction(int direction);
443
444 /**
445 Dock() indicates that a pane should be docked. It is the opposite of Float().
446 */
447 wxAuiPaneInfo& Dock();
448
449 /**
450 DockFixed() causes the containing dock to have no resize sash. This is useful
451 for creating panes that span the entire width or height of a dock, but should
452 not be resizable in the other direction.
453 */
454 wxAuiPaneInfo& DockFixed(bool b = true);
455
456 /**
457 Dockable() specifies whether a frame can be docked or not. It is the same as
458 specifying TopDockable(b).BottomDockable(b).LeftDockable(b).RightDockable(b).
459 */
460 wxAuiPaneInfo& Dockable(bool b = true);
461
462 /**
463 Fixed() forces a pane to be fixed size so that it cannot be resized. After
464 calling Fixed(), IsFixed() will return @true.
465 */
466 wxAuiPaneInfo& Fixed();
467
468 /**
469 Float() indicates that a pane should be floated. It is the opposite of Dock().
470 */
471 wxAuiPaneInfo& Float();
472
473 /**
474 Floatable() sets whether the user will be able to undock a pane and turn it
475 into a floating window.
476 */
477 wxAuiPaneInfo& Floatable(bool b = true);
478
479 //@{
480 /**
481 FloatingPosition() sets the position of the floating pane.
482 */
483 wxAuiPaneInfo FloatingPosition(const wxPoint& pos);
484 wxAuiPaneInfo FloatingPosition(int x, int y);
485 //@}
486
487 //@{
488 /**
489 FloatingSize() sets the size of the floating pane.
490 */
491 wxAuiPaneInfo FloatingSize(const wxSize& size);
492 wxAuiPaneInfo FloatingSize(int x, int y);
493 //@}
494
495 /**
496 Gripper() indicates that a gripper should be drawn for the pane.
497 */
498 wxAuiPaneInfo& Gripper(bool visible = true);
499
500 /**
501 GripperTop() indicates that a gripper should be drawn at the top of the pane.
502 */
503 wxAuiPaneInfo& GripperTop(bool attop = true);
504
505 /**
506 HasBorder() returns @true if the pane displays a border.
507 */
508 bool HasBorder() const;
509
510 /**
511 HasCaption() returns @true if the pane displays a caption.
512 */
513 bool HasCaption() const;
514
515 /**
516 HasCloseButton() returns @true if the pane displays a button to close the pane.
517 */
518 bool HasCloseButton() const;
519
520 /**
521 HasFlag() returns @true if the the property specified by flag is active for the
522 pane.
523 */
524 bool HasFlag(unsigned int flag) const;
525
526 /**
527 HasGripper() returns @true if the pane displays a gripper.
528 */
529 bool HasGripper() const;
530
531 /**
532 HasGripper() returns @true if the pane displays a gripper at the top.
533 */
534 bool HasGripperTop() const;
535
536 /**
537 HasMaximizeButton() returns @true if the pane displays a button to maximize the
538 pane.
539 */
540 bool HasMaximizeButton() const;
541
542 /**
543 HasMinimizeButton() returns @true if the pane displays a button to minimize the
544 pane.
545 */
546 bool HasMinimizeButton() const;
547
548 /**
549 HasPinButton() returns @true if the pane displays a button to float the pane.
550 */
551 bool HasPinButton() const;
552
553 /**
554 Hide() indicates that a pane should be hidden.
555 */
556 wxAuiPaneInfo& Hide();
557
558 /**
559 IsBottomDockable() returns @true if the pane can be docked at the bottom of the
560 managed frame.
561 */
562 bool IsBottomDockable() const;
563
564 /**
565 IsDocked() returns @true if the pane is docked.
566 */
567 bool IsDocked() const;
568
569 /**
570 IsFixed() returns @true if the pane cannot be resized.
571 */
572 bool IsFixed() const;
573
574 /**
575 IsFloatable() returns @true if the pane can be undocked and displayed as a
576 floating window.
577 */
578 bool IsFloatable() const;
579
580 /**
581 IsFloating() returns @true if the pane is floating.
582 */
583 bool IsFloating() const;
584
585 /**
586 IsLeftDockable() returns @true if the pane can be docked on the left of the
587 managed frame.
588 */
589 bool IsLeftDockable() const;
590
591 /**
592 IsMoveable() returns @true if the docked frame can be undocked or moved to
593 another dock position.
594 */
595 bool IsMovable() const;
596
597 /**
598 IsOk() returns @true if the wxAuiPaneInfo structure is valid. A pane structure
599 is valid if it has an associated window.
600 */
601 bool IsOk() const;
602
603 /**
604 IsResizable() returns @true if the pane can be resized.
605 */
606 bool IsResizable() const;
607
608 /**
609 IsRightDockable() returns @true if the pane can be docked on the right of the
610 managed frame.
611 */
612 bool IsRightDockable() const;
613
614 /**
615 IsShown() returns @true if the pane is currently shown.
616 */
617 bool IsShown() const;
618
619 /**
620 IsToolbar() returns @true if the pane contains a toolbar.
621 */
622 bool IsToolbar() const;
623
624 /**
625 IsTopDockable() returns @true if the pane can be docked at the top of the
626 managed frame.
627 */
628 bool IsTopDockable() const;
629
630 /**
631 Layer() determines the layer of the docked pane. The dock layer is similar to
632 an onion, the inner-most layer being layer 0. Each shell moving in the outward
633 direction has a higher layer number. This allows for more complex docking layout
634 formation.
635 */
636 wxAuiPaneInfo& Layer(int layer);
637
638 /**
639 Left() sets the pane dock position to the left side of the frame. This is the
640 same thing as calling Direction(wxAUI_DOCK_LEFT).
641 */
642 wxAuiPaneInfo& Left();
643
644 /**
645 LeftDockable() indicates whether a pane can be docked on the left of the frame.
646 */
647 wxAuiPaneInfo& LeftDockable(bool b = true);
648
649 //@{
650 /**
651 MaxSize() sets the maximum size of the pane.
652 */
653 wxAuiPaneInfo MaxSize(const wxSize& size);
654 wxAuiPaneInfo MaxSize(int x, int y);
655 //@}
656
657 /**
658 MaximizeButton() indicates that a maximize button should be drawn for the pane.
659 */
660 wxAuiPaneInfo& MaximizeButton(bool visible = true);
661
662 //@{
663 /**
664 MinSize() sets the minimum size of the pane. Please note that this is only
665 partially supported as of this writing.
666 */
667 wxAuiPaneInfo MinSize(const wxSize& size);
668 wxAuiPaneInfo MinSize(int x, int y);
669 //@}
670
671 /**
672 MinimizeButton() indicates that a minimize button should be drawn for the pane.
673 */
674 wxAuiPaneInfo& MinimizeButton(bool visible = true);
675
676 /**
677 Movable indicates whether a frame can be moved.
678 */
679 wxAuiPaneInfo& Movable(bool b = true);
680
681 /**
682 Name() sets the name of the pane so it can be referenced in lookup functions.
683 If a name is not specified by the user, a random name is assigned to the pane
684 when it is added to the manager.
685 */
686 wxAuiPaneInfo& Name(const wxString& n);
687
688 /**
689 PaneBorder indicates that a border should be drawn for the pane.
690 */
691 wxAuiPaneInfo& PaneBorder(bool visible = true);
692
693 /**
694 PinButton() indicates that a pin button should be drawn for the pane.
695 */
696 wxAuiPaneInfo& PinButton(bool visible = true);
697
698 /**
699 Position() determines the position of the docked pane.
700 */
701 wxAuiPaneInfo& Position(int pos);
702
703 /**
704 Resizable() allows a pane to be resized if the parameter is @true, and forces it
705 to be a fixed size if the parameter is @false. This is simply an antonym for Fixed().
706 */
707 wxAuiPaneInfo& Resizable(bool resizable = true);
708
709 /**
710 Right() sets the pane dock position to the right side of the frame.
711 */
712 wxAuiPaneInfo& Right();
713
714 /**
715 RightDockable() indicates whether a pane can be docked on the right of the
716 frame.
717 */
718 wxAuiPaneInfo& RightDockable(bool b = true);
719
720 /**
721 Row() determines the row of the docked pane.
722 */
723 wxAuiPaneInfo& Row(int row);
724
725 /**
726 Write the safe parts of a newly loaded PaneInfo structure "source" into "this"
727 used on loading perspectives etc.
728 */
729 void SafeSet(wxAuiPaneInfo source);
730
731 /**
732 SetFlag() turns the property given by flag on or off with the option_state
733 parameter.
734 */
735 wxAuiPaneInfo& SetFlag(unsigned int flag, bool option_state);
736
737 /**
738 Show() indicates that a pane should be shown.
739 */
740 wxAuiPaneInfo& Show(bool show = true);
741
742 /**
743 ToolbarPane() specifies that the pane should adopt the default toolbar pane
744 settings.
745 */
746 wxAuiPaneInfo& ToolbarPane();
747
748 /**
749 Top() sets the pane dock position to the top of the frame.
750 */
751 wxAuiPaneInfo& Top();
752
753 /**
754 TopDockable() indicates whether a pane can be docked at the top of the frame.
755 */
756 wxAuiPaneInfo& TopDockable(bool b = true);
757
758 /**
759 Window() assigns the window pointer that the wxAuiPaneInfo should use.
760 This normally does not need to be specified, as the window pointer is
761 automatically assigned to the wxAuiPaneInfo structure as soon as it is added
762 to the manager.
763 */
764 wxAuiPaneInfo& Window(wxWindow* w);
765
766 /**
767 Makes a copy of the wxAuiPaneInfo object.
768 */
769 wxAuiPaneInfo& operator=(const wxAuiPaneInfo& c);
770 };
771