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