]> git.saurik.com Git - wxWidgets.git/blame - interface/aui/aui.h
more utils.h fixes
[wxWidgets.git] / interface / aui / aui.h
CommitLineData
23324ae1
FM
1/////////////////////////////////////////////////////////////////////////////
2// Name: aui/aui.h
e54c96f1 3// Purpose: interface of wxAuiManager
23324ae1
FM
4// Author: wxWidgets team
5// RCS-ID: $Id$
6// Licence: wxWindows license
7/////////////////////////////////////////////////////////////////////////////
8
47d602c1
FM
9
10/**
11 @todo TOWRITE
12*/
13enum 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*/
28enum 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
23324ae1
FM
45/**
46 @class wxAuiManager
47 @headerfile aui.h wx/aui/aui.h
7c913512 48
23324ae1 49 wxAuiManager is the central class of the wxAUI class framework.
47d602c1 50 See also @ref overview_aui.
7c913512 51
47d602c1
FM
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.
7c913512 55
47d602c1
FM
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.
7c913512 60
23324ae1
FM
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().
7c913512 67
23324ae1 68 Panes can be added quite easily:
7c913512 69
23324ae1
FM
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
7c913512 77
23324ae1
FM
78 Later on, the positions can be modified easily. The following will float
79 an existing pane in a tool window:
7c913512 80
23324ae1
FM
81 @code
82 m_mgr.GetPane(text1).Float();
83 @endcode
7c913512 84
47d602c1
FM
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
23324ae1
FM
112 @library{wxbase}
113 @category{aui}
7c913512 114
e54c96f1 115 @see wxAuiPaneInfo, wxAuiDockArt
23324ae1
FM
116*/
117class wxAuiManager : public wxEvtHandler
118{
119public:
120 /**
4cc4bfaf
FM
121 Constructor. @a managed_wnd specifies the wxFrame which should be managed.
122 @a flags specifies options which allow the frame management behavior
23324ae1
FM
123 to be modified.
124 */
4cc4bfaf 125 wxAuiManager(wxWindow* managed_wnd = NULL,
23324ae1
FM
126 unsigned int flags = wxAUI_MGR_DEFAULT);
127
128 /**
47d602c1 129 Dtor.
23324ae1
FM
130 */
131 ~wxAuiManager();
132
133 //@{
134 /**
47d602c1
FM
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.
23324ae1
FM
141 */
142 bool AddPane(wxWindow* window, const wxAuiPaneInfo& pane_info);
7c913512
FM
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);
23324ae1
FM
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.
47d602c1 164 @see wxAuiDockArt.
23324ae1 165 */
328f5751 166 wxAuiDockArt* GetArtProvider() const;
23324ae1
FM
167
168 /**
47d602c1
FM
169 Returns the current dock constraint values.
170 See SetDockSizeConstraint() for more information.
23324ae1
FM
171 */
172 void GetDockSizeConstraint(double* widthpct, double* heightpct);
173
174 /**
175 Returns the current manager's flags.
176 */
328f5751 177 unsigned int GetFlags() const;
23324ae1
FM
178
179 /**
180 Returns the frame currently being managed by wxAuiManager.
181 */
328f5751 182 wxWindow* GetManagedWindow() const;
23324ae1
FM
183
184 /**
47d602c1
FM
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
4cc4bfaf 189 The @a window parameter need not be managed by the manager itself, nor does it
47d602c1
FM
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.
23324ae1
FM
192 */
193 static wxAuiManager* GetManager(wxWindow* window);
194
195 //@{
196 /**
47d602c1
FM
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.
23324ae1
FM
205 */
206 wxAuiPaneInfo GetPane(wxWindow* window);
7c913512 207 wxAuiPaneInfo GetPane(const wxString& name);
23324ae1
FM
208 //@}
209
210 /**
211 HideHint() hides any docking hint that may be visible.
212 */
213 void HideHint();
214
215 /**
216 This method is used to insert either a previously unmanaged pane window
7c913512 217 into the frame manager, or to insert a currently managed pane somewhere
47d602c1
FM
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
4cc4bfaf 221 Because @a insert_location can specify either a pane, dock row, or dock
47d602c1
FM
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.
23324ae1
FM
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
47d602c1
FM
232 only loads information about a single pane. It is used in combination with
233 SavePaneInfo().
23324ae1
FM
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,
4cc4bfaf 242 bool update = true);
23324ae1
FM
243
244 /**
47d602c1
FM
245 ProcessDockResult() is a protected member of the wxAUI layout manager.
246 It can be overridden by derived classes to provide custom docking calculations.
23324ae1
FM
247 */
248 bool ProcessDockResult(wxAuiPaneInfo& target,
249 const wxAuiPaneInfo& new_pos);
250
251 /**
252 SavePaneInfo() is similar to SavePerspective, with the exception that it only
47d602c1
FM
253 saves information about a single pane. It is used in combination with
254 LoadPaneInfo().
23324ae1
FM
255 */
256 wxString SavePaneInfo(wxAuiPaneInfo& pane);
257
258 /**
259 Saves the entire user interface layout into an encoded wxString, which
47d602c1
FM
260 can then be stored by the application (probably using wxConfig).
261
262 When a perspective is restored using LoadPerspective(), the entire user
23324ae1
FM
263 interface will return to the state it was when the perspective was saved.
264 */
265 wxString SavePerspective();
266
267 /**
268 Instructs wxAuiManager to use art provider specified by parameter
47d602c1
FM
269 @a art_provider for all drawing calls.
270 This allows plugable look-and-feel features. The previous art provider object,
271 if any, will be deleted by wxAuiManager.
272
273 @see wxAuiDockArt.
23324ae1
FM
274 */
275 void SetArtProvider(wxAuiDockArt* art_provider);
276
277 /**
278 When a user creates a new dock by dragging a window into a docked position,
47d602c1
FM
279 often times the large size of the window will create a dock that is unwieldly
280 large. wxAuiManager by default limits the size of any new dock to 1/3 of the
281 window size. For horizontal docks, this would be 1/3 of the window height.
282 For vertical docks, 1/3 of the width.
283
284 Calling this function will adjust this constraint value. The numbers must be
285 between 0.0 and 1.0. For instance, calling SetDockSizeContraint with
286 0.5, 0.5 will cause new docks to be limited to half of the size of the
287 entire managed window.
23324ae1
FM
288 */
289 void SetDockSizeConstraint(double widthpct, double heightpct);
290
291 /**
47d602c1 292 This method is used to specify wxAuiManager's settings flags. @a flags
23324ae1
FM
293 specifies options which allow the frame management behavior to be modified.
294 */
295 void SetFlags(unsigned int flags);
296
297 /**
7c913512 298 Called to specify the frame or window which is to be managed by wxAuiManager.
47d602c1
FM
299 Frame management is not restricted to just frames. Child windows or custom
300 controls are also allowed.
23324ae1
FM
301 */
302 void SetManagedWindow(wxWindow* managed_wnd);
303
304 /**
305 This function is used by controls to explicitly show a hint window at the
47d602c1
FM
306 specified rectangle. It is rarely called, and is mostly used by controls
307 implementing custom pane drag/drop behaviour.
308 The specified rectangle should be in screen coordinates.
23324ae1
FM
309 */
310 void ShowHint(const wxRect& rect);
311
312 /**
313 Uninitializes the framework and should be called before a managed frame or
47d602c1
FM
314 window is destroyed. UnInit() is usually called in the managed wxFrame's
315 destructor. It is necessary to call this function before the managed frame
316 or window is destroyed, otherwise the manager cannot remove its custom event
317 handlers from a window.
23324ae1
FM
318 */
319 void UnInit();
320
321 /**
322 This method is called after any number of changes are
323 made to any of the managed panes. Update() must be invoked after
324 AddPane() or InsertPane() are called in order to "realize" or "commit"
325 the changes. In addition, any number of changes may be made to
326 wxAuiPaneInfo structures (retrieved with wxAuiManager::GetPane), but to
327 realize the changes, Update() must be called. This construction allows
328 pane flicker to be avoided by updating the whole layout at one time.
329 */
330 void Update();
331};
332
333
e54c96f1 334
23324ae1
FM
335/**
336 @class wxAuiPaneInfo
337 @headerfile aui.h wx/aui/aui.h
7c913512 338
23324ae1 339 wxAuiPaneInfo is part of the wxAUI class framework.
47d602c1 340 See also @ref overview_aui.
7c913512 341
23324ae1 342 wxAuiPaneInfo specifies all the parameters for a pane.
47d602c1
FM
343 These parameters specify where the pane is on the screen, whether it is docked
344 or floating, or hidden.
345 In addition, these parameters specify the pane's docked position, floating
346 position, preferred size, minimum size, caption text among many other parameters.
7c913512 347
23324ae1
FM
348 @library{wxbase}
349 @category{aui}
7c913512 350
e54c96f1 351 @see wxAuiManager, wxAuiDockArt
23324ae1 352*/
7c913512 353class wxAuiPaneInfo
23324ae1
FM
354{
355public:
47d602c1
FM
356 wxAuiPaneInfo();
357
23324ae1
FM
358 /**
359 Copy constructor.
360 */
7c913512 361 wxAuiPaneInfo(const wxAuiPaneInfo& c);
23324ae1
FM
362
363 //@{
364 /**
365 BestSize() sets the ideal size for the pane. The docking manager will attempt
366 to use this size as much as possible when docking or floating the pane.
367 */
368 wxAuiPaneInfo BestSize(const wxSize& size);
7c913512 369 wxAuiPaneInfo BestSize(int x, int y);
23324ae1
FM
370 //@}
371
372 /**
373 Bottom() sets the pane dock position to the bottom side of the frame. This is
374 the same thing as calling Direction(wxAUI_DOCK_BOTTOM).
375 */
376 wxAuiPaneInfo Bottom();
377
378 /**
379 BottomDockable() indicates whether a pane can be docked at the bottom of the
380 frame.
381 */
4cc4bfaf 382 wxAuiPaneInfo BottomDockable(bool b = true);
23324ae1
FM
383
384 /**
385 Caption() sets the caption of the pane.
386 */
387 wxAuiPaneInfo Caption(const wxString& c);
388
389 /**
390 CaptionVisible indicates that a pane caption should be visible. If @false, no
391 pane caption is drawn.
392 */
4cc4bfaf 393 wxAuiPaneInfo CaptionVisible(bool visible = true);
23324ae1
FM
394
395 //@{
396 /**
397 Center() sets the pane dock position to the left side of the frame.
398 The centre pane is the space in the middle after all border panes (left, top,
399 right, bottom) are subtracted from the layout.
23324ae1
FM
400 This is the same thing as calling Direction(wxAUI_DOCK_CENTRE).
401 */
402 wxAuiPaneInfo Centre();
7c913512 403 wxAuiPaneInfo Center();
23324ae1
FM
404 //@}
405
406 //@{
407 /**
408 CentrePane() specifies that the pane should adopt the default center pane
47d602c1
FM
409 settings. Centre panes usually do not have caption bars.
410 This function provides an easy way of preparing a pane to be displayed in
411 the center dock position.
23324ae1
FM
412 */
413 wxAuiPaneInfo CentrePane();
7c913512 414 wxAuiPaneInfo CenterPane();
23324ae1
FM
415 //@}
416
417 /**
418 CloseButton() indicates that a close button should be drawn for the pane.
419 */
4cc4bfaf 420 wxAuiPaneInfo CloseButton(bool visible = true);
23324ae1
FM
421
422 /**
423 DefaultPane() specifies that the pane should adopt the default pane settings.
424 */
425 wxAuiPaneInfo DefaultPane();
426
427 /**
428 DestroyOnClose() indicates whether a pane should be detroyed when it is closed.
47d602c1
FM
429 Normally a pane is simply hidden when the close button is clicked.
430 Setting DestroyOnClose to @true will cause the window to be destroyed when
431 the user clicks the pane's close button.
23324ae1 432 */
4cc4bfaf 433 wxAuiPaneInfo DestroyOnClose(bool b = true);
23324ae1
FM
434
435 /**
436 Direction() determines the direction of the docked pane. It is functionally the
47d602c1
FM
437 same as calling Left(), Right(), Top() or Bottom(), except that docking direction
438 may be specified programmatically via the parameter.
23324ae1
FM
439 */
440 wxAuiPaneInfo Direction(int direction);
441
442 /**
443 Dock() indicates that a pane should be docked. It is the opposite of Float().
444 */
445 wxAuiPaneInfo Dock();
446
447 /**
448 DockFixed() causes the containing dock to have no resize sash. This is useful
47d602c1
FM
449 for creating panes that span the entire width or height of a dock, but should
450 not be resizable in the other direction.
23324ae1 451 */
4cc4bfaf 452 wxAuiPaneInfo DockFixed(bool b = true);
23324ae1
FM
453
454 /**
455 Dockable() specifies whether a frame can be docked or not. It is the same as
456 specifying TopDockable(b).BottomDockable(b).LeftDockable(b).RightDockable(b).
457 */
4cc4bfaf 458 wxAuiPaneInfo Dockable(bool b = true);
23324ae1
FM
459
460 /**
461 Fixed() forces a pane to be fixed size so that it cannot be resized. After
462 calling Fixed(), IsFixed() will return @true.
463 */
464 wxAuiPaneInfo Fixed();
465
466 /**
467 Float() indicates that a pane should be floated. It is the opposite of Dock().
468 */
469 wxAuiPaneInfo Float();
470
471 /**
472 Floatable() sets whether the user will be able to undock a pane and turn it
473 into a floating window.
474 */
4cc4bfaf 475 wxAuiPaneInfo Floatable(bool b = true);
23324ae1
FM
476
477 //@{
478 /**
479 FloatingPosition() sets the position of the floating pane.
480 */
481 wxAuiPaneInfo FloatingPosition(const wxPoint& pos);
7c913512 482 wxAuiPaneInfo FloatingPosition(int x, int y);
23324ae1
FM
483 //@}
484
485 //@{
486 /**
487 FloatingSize() sets the size of the floating pane.
488 */
489 wxAuiPaneInfo FloatingSize(const wxSize& size);
7c913512 490 wxAuiPaneInfo FloatingSize(int x, int y);
23324ae1
FM
491 //@}
492
493 /**
494 Gripper() indicates that a gripper should be drawn for the pane.
495 */
4cc4bfaf 496 wxAuiPaneInfo Gripper(bool visible = true);
23324ae1
FM
497
498 /**
499 GripperTop() indicates that a gripper should be drawn at the top of the pane.
500 */
4cc4bfaf 501 wxAuiPaneInfo GripperTop(bool attop = true);
23324ae1
FM
502
503 /**
504 HasBorder() returns @true if the pane displays a border.
505 */
328f5751 506 bool HasBorder() const;
23324ae1
FM
507
508 /**
509 HasCaption() returns @true if the pane displays a caption.
510 */
328f5751 511 bool HasCaption() const;
23324ae1
FM
512
513 /**
514 HasCloseButton() returns @true if the pane displays a button to close the pane.
515 */
328f5751 516 bool HasCloseButton() const;
23324ae1
FM
517
518 /**
519 HasFlag() returns @true if the the property specified by flag is active for the
520 pane.
521 */
328f5751 522 bool HasFlag(unsigned int flag) const;
23324ae1
FM
523
524 /**
525 HasGripper() returns @true if the pane displays a gripper.
526 */
328f5751 527 bool HasGripper() const;
23324ae1
FM
528
529 /**
530 HasGripper() returns @true if the pane displays a gripper at the top.
531 */
328f5751 532 bool HasGripperTop() const;
23324ae1
FM
533
534 /**
535 HasMaximizeButton() returns @true if the pane displays a button to maximize the
536 pane.
537 */
328f5751 538 bool HasMaximizeButton() const;
23324ae1
FM
539
540 /**
541 HasMinimizeButton() returns @true if the pane displays a button to minimize the
542 pane.
543 */
328f5751 544 bool HasMinimizeButton() const;
23324ae1
FM
545
546 /**
547 HasPinButton() returns @true if the pane displays a button to float the pane.
548 */
328f5751 549 bool HasPinButton() const;
23324ae1
FM
550
551 /**
552 Hide() indicates that a pane should be hidden.
553 */
554 wxAuiPaneInfo Hide();
555
556 /**
557 IsBottomDockable() returns @true if the pane can be docked at the bottom of the
558 managed frame.
559 */
328f5751 560 bool IsBottomDockable() const;
23324ae1
FM
561
562 /**
563 IsDocked() returns @true if the pane is docked.
564 */
328f5751 565 bool IsDocked() const;
23324ae1
FM
566
567 /**
568 IsFixed() returns @true if the pane cannot be resized.
569 */
328f5751 570 bool IsFixed() const;
23324ae1
FM
571
572 /**
573 IsFloatable() returns @true if the pane can be undocked and displayed as a
574 floating window.
575 */
328f5751 576 bool IsFloatable() const;
23324ae1
FM
577
578 /**
579 IsFloating() returns @true if the pane is floating.
580 */
328f5751 581 bool IsFloating() const;
23324ae1
FM
582
583 /**
584 IsLeftDockable() returns @true if the pane can be docked on the left of the
585 managed frame.
586 */
328f5751 587 bool IsLeftDockable() const;
23324ae1
FM
588
589 /**
590 IsMoveable() returns @true if the docked frame can be undocked or moved to
591 another dock position.
592 */
328f5751 593 bool IsMovable() const;
23324ae1
FM
594
595 /**
596 IsOk() returns @true if the wxAuiPaneInfo structure is valid. A pane structure
597 is valid if it has an associated window.
598 */
328f5751 599 bool IsOk() const;
23324ae1
FM
600
601 /**
602 IsResizable() returns @true if the pane can be resized.
603 */
328f5751 604 bool IsResizable() const;
23324ae1
FM
605
606 /**
607 IsRightDockable() returns @true if the pane can be docked on the right of the
608 managed frame.
609 */
328f5751 610 bool IsRightDockable() const;
23324ae1
FM
611
612 /**
613 IsShown() returns @true if the pane is currently shown.
614 */
328f5751 615 bool IsShown() const;
23324ae1
FM
616
617 /**
618 IsToolbar() returns @true if the pane contains a toolbar.
619 */
328f5751 620 bool IsToolbar() const;
23324ae1
FM
621
622 /**
623 IsTopDockable() returns @true if the pane can be docked at the top of the
624 managed frame.
625 */
328f5751 626 bool IsTopDockable() const;
23324ae1
FM
627
628 /**
629 Layer() determines the layer of the docked pane. The dock layer is similar to
47d602c1
FM
630 an onion, the inner-most layer being layer 0. Each shell moving in the outward
631 direction has a higher layer number. This allows for more complex docking layout
632 formation.
23324ae1
FM
633 */
634 wxAuiPaneInfo Layer(int layer);
635
636 /**
637 Left() sets the pane dock position to the left side of the frame. This is the
638 same thing as calling Direction(wxAUI_DOCK_LEFT).
639 */
640 wxAuiPaneInfo Left();
641
642 /**
643 LeftDockable() indicates whether a pane can be docked on the left of the frame.
644 */
4cc4bfaf 645 wxAuiPaneInfo LeftDockable(bool b = true);
23324ae1
FM
646
647 //@{
648 /**
649 MaxSize() sets the maximum size of the pane.
650 */
651 wxAuiPaneInfo MaxSize(const wxSize& size);
7c913512 652 wxAuiPaneInfo MaxSize(int x, int y);
23324ae1
FM
653 //@}
654
655 /**
656 MaximizeButton() indicates that a maximize button should be drawn for the pane.
657 */
4cc4bfaf 658 wxAuiPaneInfo MaximizeButton(bool visible = true);
23324ae1
FM
659
660 //@{
661 /**
662 MinSize() sets the minimum size of the pane. Please note that this is only
663 partially supported as of this writing.
664 */
665 wxAuiPaneInfo MinSize(const wxSize& size);
7c913512 666 wxAuiPaneInfo MinSize(int x, int y);
23324ae1
FM
667 //@}
668
669 /**
670 MinimizeButton() indicates that a minimize button should be drawn for the pane.
671 */
4cc4bfaf 672 wxAuiPaneInfo MinimizeButton(bool visible = true);
23324ae1
FM
673
674 /**
675 Movable indicates whether a frame can be moved.
676 */
4cc4bfaf 677 wxAuiPaneInfo Movable(bool b = true);
23324ae1
FM
678
679 /**
680 Name() sets the name of the pane so it can be referenced in lookup functions.
47d602c1
FM
681 If a name is not specified by the user, a random name is assigned to the pane
682 when it is added to the manager.
23324ae1
FM
683 */
684 wxAuiPaneInfo Name(const wxString& n);
685
686 /**
687 PaneBorder indicates that a border should be drawn for the pane.
688 */
4cc4bfaf 689 wxAuiPaneInfo PaneBorder(bool visible = true);
23324ae1
FM
690
691 /**
692 PinButton() indicates that a pin button should be drawn for the pane.
693 */
4cc4bfaf 694 wxAuiPaneInfo PinButton(bool visible = true);
23324ae1
FM
695
696 /**
697 Position() determines the position of the docked pane.
698 */
699 wxAuiPaneInfo Position(int pos);
700
701 /**
702 Resizable() allows a pane to be resized if the parameter is @true, and forces it
703 to be a fixed size if the parameter is @false. This is simply an antonym for Fixed().
704 */
4cc4bfaf 705 wxAuiPaneInfo Resizable(bool resizable = true);
23324ae1
FM
706
707 /**
708 Right() sets the pane dock position to the right side of the frame.
709 */
710 wxAuiPaneInfo Right();
711
712 /**
713 RightDockable() indicates whether a pane can be docked on the right of the
714 frame.
715 */
4cc4bfaf 716 wxAuiPaneInfo RightDockable(bool b = true);
23324ae1
FM
717
718 /**
719 Row() determines the row of the docked pane.
720 */
4cc4bfaf 721 wxAuiPaneInfo Row(int row);
23324ae1
FM
722
723 /**
724 Write the safe parts of a newly loaded PaneInfo structure "source" into "this"
725 used on loading perspectives etc.
726 */
727 void SafeSet(wxAuiPaneInfo source);
728
729 /**
730 SetFlag() turns the property given by flag on or off with the option_state
731 parameter.
732 */
733 wxAuiPaneInfo SetFlag(unsigned int flag, bool option_state);
734
735 /**
736 Show() indicates that a pane should be shown.
737 */
4cc4bfaf 738 wxAuiPaneInfo Show(bool show = true);
23324ae1
FM
739
740 /**
741 ToolbarPane() specifies that the pane should adopt the default toolbar pane
742 settings.
743 */
744 wxAuiPaneInfo ToolbarPane();
745
746 /**
747 Top() sets the pane dock position to the top of the frame.
748 */
4cc4bfaf 749 wxAuiPaneInfo Top();
23324ae1
FM
750
751 /**
752 TopDockable() indicates whether a pane can be docked at the top of the frame.
753 */
4cc4bfaf 754 wxAuiPaneInfo TopDockable(bool b = true);
23324ae1
FM
755
756 /**
47d602c1
FM
757 Window() assigns the window pointer that the wxAuiPaneInfo should use.
758 This normally does not need to be specified, as the window pointer is
759 automatically assigned to the wxAuiPaneInfo structure as soon as it is added
760 to the manager.
23324ae1
FM
761 */
762 wxAuiPaneInfo Window(wxWindow* w);
763
764 /**
765 Makes a copy of the wxAuiPaneInfo object.
766 */
767 wxAuiPaneInfo& operator operator=(const wxAuiPaneInfo& c);
768};
e54c96f1 769