]>
Commit | Line | Data |
---|---|---|
1 | /////////////////////////////////////////////////////////////////////////////// | |
2 | // Name: wx/aui/framemanager.h | |
3 | // Purpose: wxaui: wx advanced user interface - docking window manager | |
4 | // Author: Benjamin I. Williams | |
5 | // Modified by: | |
6 | // Created: 2005-05-17 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (C) Copyright 2005, Kirix Corporation, All Rights Reserved. | |
9 | // Licence: wxWindows Library Licence, Version 3.1 | |
10 | /////////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | #ifndef _WX_FRAMEMANAGER_H_ | |
13 | #define _WX_FRAMEMANAGER_H_ | |
14 | ||
15 | // ---------------------------------------------------------------------------- | |
16 | // headers | |
17 | // ---------------------------------------------------------------------------- | |
18 | ||
19 | #include "wx/defs.h" | |
20 | ||
21 | #if wxUSE_AUI | |
22 | ||
23 | #include "wx/dynarray.h" | |
24 | #include "wx/gdicmn.h" | |
25 | #include "wx/window.h" | |
26 | #include "wx/timer.h" | |
27 | #include "wx/sizer.h" | |
28 | #include "wx/bitmap.h" | |
29 | ||
30 | enum wxAuiManagerDock | |
31 | { | |
32 | wxAUI_DOCK_NONE = 0, | |
33 | wxAUI_DOCK_TOP = 1, | |
34 | wxAUI_DOCK_RIGHT = 2, | |
35 | wxAUI_DOCK_BOTTOM = 3, | |
36 | wxAUI_DOCK_LEFT = 4, | |
37 | wxAUI_DOCK_CENTER = 5, | |
38 | wxAUI_DOCK_CENTRE = wxAUI_DOCK_CENTER | |
39 | }; | |
40 | ||
41 | enum wxAuiManagerOption | |
42 | { | |
43 | wxAUI_MGR_ALLOW_FLOATING = 1 << 0, | |
44 | wxAUI_MGR_ALLOW_ACTIVE_PANE = 1 << 1, | |
45 | wxAUI_MGR_TRANSPARENT_DRAG = 1 << 2, | |
46 | wxAUI_MGR_TRANSPARENT_HINT = 1 << 3, | |
47 | wxAUI_MGR_VENETIAN_BLINDS_HINT = 1 << 4, | |
48 | wxAUI_MGR_RECTANGLE_HINT = 1 << 5, | |
49 | wxAUI_MGR_HINT_FADE = 1 << 6, | |
50 | wxAUI_MGR_NO_VENETIAN_BLINDS_FADE = 1 << 7, | |
51 | wxAUI_MGR_LIVE_RESIZE = 1 << 8, | |
52 | ||
53 | wxAUI_MGR_DEFAULT = wxAUI_MGR_ALLOW_FLOATING | | |
54 | wxAUI_MGR_TRANSPARENT_HINT | | |
55 | wxAUI_MGR_HINT_FADE | | |
56 | wxAUI_MGR_NO_VENETIAN_BLINDS_FADE | |
57 | }; | |
58 | ||
59 | ||
60 | enum wxAuiPaneDockArtSetting | |
61 | { | |
62 | wxAUI_DOCKART_SASH_SIZE = 0, | |
63 | wxAUI_DOCKART_CAPTION_SIZE = 1, | |
64 | wxAUI_DOCKART_GRIPPER_SIZE = 2, | |
65 | wxAUI_DOCKART_PANE_BORDER_SIZE = 3, | |
66 | wxAUI_DOCKART_PANE_BUTTON_SIZE = 4, | |
67 | wxAUI_DOCKART_BACKGROUND_COLOUR = 5, | |
68 | wxAUI_DOCKART_SASH_COLOUR = 6, | |
69 | wxAUI_DOCKART_ACTIVE_CAPTION_COLOUR = 7, | |
70 | wxAUI_DOCKART_ACTIVE_CAPTION_GRADIENT_COLOUR = 8, | |
71 | wxAUI_DOCKART_INACTIVE_CAPTION_COLOUR = 9, | |
72 | wxAUI_DOCKART_INACTIVE_CAPTION_GRADIENT_COLOUR = 10, | |
73 | wxAUI_DOCKART_ACTIVE_CAPTION_TEXT_COLOUR = 11, | |
74 | wxAUI_DOCKART_INACTIVE_CAPTION_TEXT_COLOUR = 12, | |
75 | wxAUI_DOCKART_BORDER_COLOUR = 13, | |
76 | wxAUI_DOCKART_GRIPPER_COLOUR = 14, | |
77 | wxAUI_DOCKART_CAPTION_FONT = 15, | |
78 | wxAUI_DOCKART_GRADIENT_TYPE = 16 | |
79 | }; | |
80 | ||
81 | enum wxAuiPaneDockArtGradients | |
82 | { | |
83 | wxAUI_GRADIENT_NONE = 0, | |
84 | wxAUI_GRADIENT_VERTICAL = 1, | |
85 | wxAUI_GRADIENT_HORIZONTAL = 2 | |
86 | }; | |
87 | ||
88 | enum wxAuiPaneButtonState | |
89 | { | |
90 | wxAUI_BUTTON_STATE_NORMAL = 0, | |
91 | wxAUI_BUTTON_STATE_HOVER = 1 << 1, | |
92 | wxAUI_BUTTON_STATE_PRESSED = 1 << 2, | |
93 | wxAUI_BUTTON_STATE_DISABLED = 1 << 3, | |
94 | wxAUI_BUTTON_STATE_HIDDEN = 1 << 4, | |
95 | wxAUI_BUTTON_STATE_CHECKED = 1 << 5 | |
96 | }; | |
97 | ||
98 | enum wxAuiButtonId | |
99 | { | |
100 | wxAUI_BUTTON_CLOSE = 101, | |
101 | wxAUI_BUTTON_MAXIMIZE_RESTORE = 102, | |
102 | wxAUI_BUTTON_MINIMIZE = 103, | |
103 | wxAUI_BUTTON_PIN = 104, | |
104 | wxAUI_BUTTON_OPTIONS = 105, | |
105 | wxAUI_BUTTON_WINDOWLIST = 106, | |
106 | wxAUI_BUTTON_LEFT = 107, | |
107 | wxAUI_BUTTON_RIGHT = 108, | |
108 | wxAUI_BUTTON_UP = 109, | |
109 | wxAUI_BUTTON_DOWN = 110, | |
110 | wxAUI_BUTTON_CUSTOM1 = 201, | |
111 | wxAUI_BUTTON_CUSTOM2 = 202, | |
112 | wxAUI_BUTTON_CUSTOM3 = 203 | |
113 | }; | |
114 | ||
115 | enum wxAuiPaneInsertLevel | |
116 | { | |
117 | wxAUI_INSERT_PANE = 0, | |
118 | wxAUI_INSERT_ROW = 1, | |
119 | wxAUI_INSERT_DOCK = 2 | |
120 | }; | |
121 | ||
122 | ||
123 | ||
124 | ||
125 | // forwards and array declarations | |
126 | class wxAuiDockUIPart; | |
127 | class wxAuiPaneButton; | |
128 | class wxAuiPaneInfo; | |
129 | class wxAuiDockInfo; | |
130 | class wxAuiDockArt; | |
131 | class wxAuiManagerEvent; | |
132 | ||
133 | #ifndef SWIG | |
134 | WX_DECLARE_USER_EXPORTED_OBJARRAY(wxAuiDockInfo, wxAuiDockInfoArray, WXDLLIMPEXP_AUI); | |
135 | WX_DECLARE_USER_EXPORTED_OBJARRAY(wxAuiDockUIPart, wxAuiDockUIPartArray, WXDLLIMPEXP_AUI); | |
136 | WX_DECLARE_USER_EXPORTED_OBJARRAY(wxAuiPaneButton, wxAuiPaneButtonArray, WXDLLIMPEXP_AUI); | |
137 | WX_DECLARE_USER_EXPORTED_OBJARRAY(wxAuiPaneInfo, wxAuiPaneInfoArray, WXDLLIMPEXP_AUI); | |
138 | WX_DEFINE_USER_EXPORTED_ARRAY_PTR(wxAuiPaneInfo*, wxAuiPaneInfoPtrArray, class WXDLLIMPEXP_AUI); | |
139 | WX_DEFINE_USER_EXPORTED_ARRAY_PTR(wxAuiDockInfo*, wxAuiDockInfoPtrArray, class WXDLLIMPEXP_AUI); | |
140 | #endif // SWIG | |
141 | ||
142 | extern WXDLLIMPEXP_AUI wxAuiDockInfo wxAuiNullDockInfo; | |
143 | extern WXDLLIMPEXP_AUI wxAuiPaneInfo wxAuiNullPaneInfo; | |
144 | ||
145 | ||
146 | ||
147 | class WXDLLIMPEXP_AUI wxAuiPaneInfo | |
148 | { | |
149 | public: | |
150 | ||
151 | wxAuiPaneInfo() | |
152 | { | |
153 | window = NULL; | |
154 | frame = NULL; | |
155 | state = 0; | |
156 | dock_direction = wxAUI_DOCK_LEFT; | |
157 | dock_layer = 0; | |
158 | dock_row = 0; | |
159 | dock_pos = 0; | |
160 | floating_pos = wxDefaultPosition; | |
161 | floating_size = wxDefaultSize; | |
162 | best_size = wxDefaultSize; | |
163 | min_size = wxDefaultSize; | |
164 | max_size = wxDefaultSize; | |
165 | dock_proportion = 0; | |
166 | ||
167 | DefaultPane(); | |
168 | } | |
169 | ||
170 | ~wxAuiPaneInfo() {} | |
171 | ||
172 | #ifndef SWIG | |
173 | wxAuiPaneInfo(const wxAuiPaneInfo& c) | |
174 | { | |
175 | name = c.name; | |
176 | caption = c.caption; | |
177 | icon = c.icon; | |
178 | window = c.window; | |
179 | frame = c.frame; | |
180 | state = c.state; | |
181 | dock_direction = c.dock_direction; | |
182 | dock_layer = c.dock_layer; | |
183 | dock_row = c.dock_row; | |
184 | dock_pos = c.dock_pos; | |
185 | best_size = c.best_size; | |
186 | min_size = c.min_size; | |
187 | max_size = c.max_size; | |
188 | floating_pos = c.floating_pos; | |
189 | floating_size = c.floating_size; | |
190 | dock_proportion = c.dock_proportion; | |
191 | buttons = c.buttons; | |
192 | rect = c.rect; | |
193 | } | |
194 | ||
195 | wxAuiPaneInfo& operator=(const wxAuiPaneInfo& c) | |
196 | { | |
197 | name = c.name; | |
198 | caption = c.caption; | |
199 | window = c.window; | |
200 | frame = c.frame; | |
201 | state = c.state; | |
202 | dock_direction = c.dock_direction; | |
203 | dock_layer = c.dock_layer; | |
204 | dock_row = c.dock_row; | |
205 | dock_pos = c.dock_pos; | |
206 | best_size = c.best_size; | |
207 | min_size = c.min_size; | |
208 | max_size = c.max_size; | |
209 | floating_pos = c.floating_pos; | |
210 | floating_size = c.floating_size; | |
211 | dock_proportion = c.dock_proportion; | |
212 | buttons = c.buttons; | |
213 | rect = c.rect; | |
214 | return *this; | |
215 | } | |
216 | #endif // SWIG | |
217 | ||
218 | // Write the safe parts of a newly loaded PaneInfo structure "source" into "this" | |
219 | // used on loading perspectives etc. | |
220 | void SafeSet(wxAuiPaneInfo source) | |
221 | { | |
222 | // note source is not passed by reference so we can overwrite, to keep the | |
223 | // unsafe bits of "dest" | |
224 | source.window = window; | |
225 | source.frame = frame; | |
226 | source.buttons = buttons; | |
227 | wxCHECK_RET(source.IsValid(), | |
228 | "window settings and pane settings are incompatible"); | |
229 | // now assign | |
230 | *this = source; | |
231 | } | |
232 | ||
233 | bool IsOk() const { return window != NULL; } | |
234 | bool IsFixed() const { return !HasFlag(optionResizable); } | |
235 | bool IsResizable() const { return HasFlag(optionResizable); } | |
236 | bool IsShown() const { return !HasFlag(optionHidden); } | |
237 | bool IsFloating() const { return HasFlag(optionFloating); } | |
238 | bool IsDocked() const { return !HasFlag(optionFloating); } | |
239 | bool IsToolbar() const { return HasFlag(optionToolbar); } | |
240 | bool IsTopDockable() const { return HasFlag(optionTopDockable); } | |
241 | bool IsBottomDockable() const { return HasFlag(optionBottomDockable); } | |
242 | bool IsLeftDockable() const { return HasFlag(optionLeftDockable); } | |
243 | bool IsRightDockable() const { return HasFlag(optionRightDockable); } | |
244 | bool IsDockable() const | |
245 | { | |
246 | return HasFlag(optionTopDockable | optionBottomDockable | | |
247 | optionLeftDockable | optionRightDockable); | |
248 | } | |
249 | bool IsFloatable() const { return HasFlag(optionFloatable); } | |
250 | bool IsMovable() const { return HasFlag(optionMovable); } | |
251 | bool IsDestroyOnClose() const { return HasFlag(optionDestroyOnClose); } | |
252 | bool IsMaximized() const { return HasFlag(optionMaximized); } | |
253 | bool HasCaption() const { return HasFlag(optionCaption); } | |
254 | bool HasGripper() const { return HasFlag(optionGripper); } | |
255 | bool HasBorder() const { return HasFlag(optionPaneBorder); } | |
256 | bool HasCloseButton() const { return HasFlag(buttonClose); } | |
257 | bool HasMaximizeButton() const { return HasFlag(buttonMaximize); } | |
258 | bool HasMinimizeButton() const { return HasFlag(buttonMinimize); } | |
259 | bool HasPinButton() const { return HasFlag(buttonPin); } | |
260 | bool HasGripperTop() const { return HasFlag(optionGripperTop); } | |
261 | ||
262 | #ifdef SWIG | |
263 | %typemap(out) wxAuiPaneInfo& { $result = $self; Py_INCREF($result); } | |
264 | #endif | |
265 | wxAuiPaneInfo& Window(wxWindow* w) | |
266 | { | |
267 | wxAuiPaneInfo test(*this); | |
268 | test.window = w; | |
269 | wxCHECK_MSG(test.IsValid(), *this, | |
270 | "window settings and pane settings are incompatible"); | |
271 | *this = test; | |
272 | return *this; | |
273 | } | |
274 | wxAuiPaneInfo& Name(const wxString& n) { name = n; return *this; } | |
275 | wxAuiPaneInfo& Caption(const wxString& c) { caption = c; return *this; } | |
276 | wxAuiPaneInfo& Icon(const wxBitmap& b) { icon = b; return *this; } | |
277 | wxAuiPaneInfo& Left() { dock_direction = wxAUI_DOCK_LEFT; return *this; } | |
278 | wxAuiPaneInfo& Right() { dock_direction = wxAUI_DOCK_RIGHT; return *this; } | |
279 | wxAuiPaneInfo& Top() { dock_direction = wxAUI_DOCK_TOP; return *this; } | |
280 | wxAuiPaneInfo& Bottom() { dock_direction = wxAUI_DOCK_BOTTOM; return *this; } | |
281 | wxAuiPaneInfo& Center() { dock_direction = wxAUI_DOCK_CENTER; return *this; } | |
282 | wxAuiPaneInfo& Centre() { dock_direction = wxAUI_DOCK_CENTRE; return *this; } | |
283 | wxAuiPaneInfo& Direction(int direction) { dock_direction = direction; return *this; } | |
284 | wxAuiPaneInfo& Layer(int layer) { dock_layer = layer; return *this; } | |
285 | wxAuiPaneInfo& Row(int row) { dock_row = row; return *this; } | |
286 | wxAuiPaneInfo& Position(int pos) { dock_pos = pos; return *this; } | |
287 | wxAuiPaneInfo& BestSize(const wxSize& size) { best_size = size; return *this; } | |
288 | wxAuiPaneInfo& MinSize(const wxSize& size) { min_size = size; return *this; } | |
289 | wxAuiPaneInfo& MaxSize(const wxSize& size) { max_size = size; return *this; } | |
290 | wxAuiPaneInfo& BestSize(int x, int y) { best_size.Set(x,y); return *this; } | |
291 | wxAuiPaneInfo& MinSize(int x, int y) { min_size.Set(x,y); return *this; } | |
292 | wxAuiPaneInfo& MaxSize(int x, int y) { max_size.Set(x,y); return *this; } | |
293 | wxAuiPaneInfo& FloatingPosition(const wxPoint& pos) { floating_pos = pos; return *this; } | |
294 | wxAuiPaneInfo& FloatingPosition(int x, int y) { floating_pos.x = x; floating_pos.y = y; return *this; } | |
295 | wxAuiPaneInfo& FloatingSize(const wxSize& size) { floating_size = size; return *this; } | |
296 | wxAuiPaneInfo& FloatingSize(int x, int y) { floating_size.Set(x,y); return *this; } | |
297 | wxAuiPaneInfo& Fixed() { return SetFlag(optionResizable, false); } | |
298 | wxAuiPaneInfo& Resizable(bool resizable = true) { return SetFlag(optionResizable, resizable); } | |
299 | wxAuiPaneInfo& Dock() { return SetFlag(optionFloating, false); } | |
300 | wxAuiPaneInfo& Float() { return SetFlag(optionFloating, true); } | |
301 | wxAuiPaneInfo& Hide() { return SetFlag(optionHidden, true); } | |
302 | wxAuiPaneInfo& Show(bool show = true) { return SetFlag(optionHidden, !show); } | |
303 | wxAuiPaneInfo& CaptionVisible(bool visible = true) { return SetFlag(optionCaption, visible); } | |
304 | wxAuiPaneInfo& Maximize() { return SetFlag(optionMaximized, true); } | |
305 | wxAuiPaneInfo& Restore() { return SetFlag(optionMaximized, false); } | |
306 | wxAuiPaneInfo& PaneBorder(bool visible = true) { return SetFlag(optionPaneBorder, visible); } | |
307 | wxAuiPaneInfo& Gripper(bool visible = true) { return SetFlag(optionGripper, visible); } | |
308 | wxAuiPaneInfo& GripperTop(bool attop = true) { return SetFlag(optionGripperTop, attop); } | |
309 | wxAuiPaneInfo& CloseButton(bool visible = true) { return SetFlag(buttonClose, visible); } | |
310 | wxAuiPaneInfo& MaximizeButton(bool visible = true) { return SetFlag(buttonMaximize, visible); } | |
311 | wxAuiPaneInfo& MinimizeButton(bool visible = true) { return SetFlag(buttonMinimize, visible); } | |
312 | wxAuiPaneInfo& PinButton(bool visible = true) { return SetFlag(buttonPin, visible); } | |
313 | wxAuiPaneInfo& DestroyOnClose(bool b = true) { return SetFlag(optionDestroyOnClose, b); } | |
314 | wxAuiPaneInfo& TopDockable(bool b = true) { return SetFlag(optionTopDockable, b); } | |
315 | wxAuiPaneInfo& BottomDockable(bool b = true) { return SetFlag(optionBottomDockable, b); } | |
316 | wxAuiPaneInfo& LeftDockable(bool b = true) { return SetFlag(optionLeftDockable, b); } | |
317 | wxAuiPaneInfo& RightDockable(bool b = true) { return SetFlag(optionRightDockable, b); } | |
318 | wxAuiPaneInfo& Floatable(bool b = true) { return SetFlag(optionFloatable, b); } | |
319 | wxAuiPaneInfo& Movable(bool b = true) { return SetFlag(optionMovable, b); } | |
320 | wxAuiPaneInfo& DockFixed(bool b = true) { return SetFlag(optionDockFixed, b); } | |
321 | ||
322 | wxAuiPaneInfo& Dockable(bool b = true) | |
323 | { | |
324 | return TopDockable(b).BottomDockable(b).LeftDockable(b).RightDockable(b); | |
325 | } | |
326 | ||
327 | wxAuiPaneInfo& DefaultPane() | |
328 | { | |
329 | wxAuiPaneInfo test(*this); | |
330 | test.state |= optionTopDockable | optionBottomDockable | | |
331 | optionLeftDockable | optionRightDockable | | |
332 | optionFloatable | optionMovable | optionResizable | | |
333 | optionCaption | optionPaneBorder | buttonClose; | |
334 | wxCHECK_MSG(test.IsValid(), *this, | |
335 | "window settings and pane settings are incompatible"); | |
336 | *this = test; | |
337 | return *this; | |
338 | } | |
339 | ||
340 | wxAuiPaneInfo& CentrePane() { return CenterPane(); } | |
341 | wxAuiPaneInfo& CenterPane() | |
342 | { | |
343 | state = 0; | |
344 | return Center().PaneBorder().Resizable(); | |
345 | } | |
346 | ||
347 | wxAuiPaneInfo& ToolbarPane() | |
348 | { | |
349 | DefaultPane(); | |
350 | state |= (optionToolbar | optionGripper); | |
351 | state &= ~(optionResizable | optionCaption); | |
352 | if (dock_layer == 0) | |
353 | dock_layer = 10; | |
354 | return *this; | |
355 | } | |
356 | ||
357 | wxAuiPaneInfo& SetFlag(int flag, bool option_state) | |
358 | { | |
359 | wxAuiPaneInfo test(*this); | |
360 | if (option_state) | |
361 | test.state |= flag; | |
362 | else | |
363 | test.state &= ~flag; | |
364 | wxCHECK_MSG(test.IsValid(), *this, | |
365 | "window settings and pane settings are incompatible"); | |
366 | *this = test; | |
367 | return *this; | |
368 | } | |
369 | ||
370 | bool HasFlag(int flag) const | |
371 | { | |
372 | return (state & flag) != 0; | |
373 | } | |
374 | ||
375 | #ifdef SWIG | |
376 | %typemap(out) wxAuiPaneInfo& ; | |
377 | #endif | |
378 | ||
379 | public: | |
380 | ||
381 | // NOTE: You can add and subtract flags from this list, | |
382 | // but do not change the values of the flags, because | |
383 | // they are stored in a binary integer format in the | |
384 | // perspective string. If you really need to change the | |
385 | // values around, you'll have to ensure backwards-compatibility | |
386 | // in the perspective loading code. | |
387 | enum wxAuiPaneState | |
388 | { | |
389 | optionFloating = 1 << 0, | |
390 | optionHidden = 1 << 1, | |
391 | optionLeftDockable = 1 << 2, | |
392 | optionRightDockable = 1 << 3, | |
393 | optionTopDockable = 1 << 4, | |
394 | optionBottomDockable = 1 << 5, | |
395 | optionFloatable = 1 << 6, | |
396 | optionMovable = 1 << 7, | |
397 | optionResizable = 1 << 8, | |
398 | optionPaneBorder = 1 << 9, | |
399 | optionCaption = 1 << 10, | |
400 | optionGripper = 1 << 11, | |
401 | optionDestroyOnClose = 1 << 12, | |
402 | optionToolbar = 1 << 13, | |
403 | optionActive = 1 << 14, | |
404 | optionGripperTop = 1 << 15, | |
405 | optionMaximized = 1 << 16, | |
406 | optionDockFixed = 1 << 17, | |
407 | ||
408 | buttonClose = 1 << 21, | |
409 | buttonMaximize = 1 << 22, | |
410 | buttonMinimize = 1 << 23, | |
411 | buttonPin = 1 << 24, | |
412 | ||
413 | buttonCustom1 = 1 << 26, | |
414 | buttonCustom2 = 1 << 27, | |
415 | buttonCustom3 = 1 << 28, | |
416 | ||
417 | savedHiddenState = 1 << 30, // used internally | |
418 | actionPane = 1 << 31 // used internally | |
419 | }; | |
420 | ||
421 | public: | |
422 | wxString name; // name of the pane | |
423 | wxString caption; // caption displayed on the window | |
424 | wxBitmap icon; // icon of the pane, may be invalid | |
425 | ||
426 | wxWindow* window; // window that is in this pane | |
427 | wxFrame* frame; // floating frame window that holds the pane | |
428 | unsigned int state; // a combination of wxPaneState values | |
429 | ||
430 | int dock_direction; // dock direction (top, bottom, left, right, center) | |
431 | int dock_layer; // layer number (0 = innermost layer) | |
432 | int dock_row; // row number on the docking bar (0 = first row) | |
433 | int dock_pos; // position inside the row (0 = first position) | |
434 | ||
435 | wxSize best_size; // size that the layout engine will prefer | |
436 | wxSize min_size; // minimum size the pane window can tolerate | |
437 | wxSize max_size; // maximum size the pane window can tolerate | |
438 | ||
439 | wxPoint floating_pos; // position while floating | |
440 | wxSize floating_size; // size while floating | |
441 | int dock_proportion; // proportion while docked | |
442 | ||
443 | wxAuiPaneButtonArray buttons; // buttons on the pane | |
444 | ||
445 | ||
446 | wxRect rect; // current rectangle (populated by wxAUI) | |
447 | ||
448 | bool IsValid() const; | |
449 | }; | |
450 | ||
451 | ||
452 | ||
453 | class WXDLLIMPEXP_FWD_AUI wxAuiFloatingFrame; | |
454 | ||
455 | class WXDLLIMPEXP_AUI wxAuiManager : public wxEvtHandler | |
456 | { | |
457 | friend class wxAuiFloatingFrame; | |
458 | ||
459 | public: | |
460 | ||
461 | wxAuiManager(wxWindow* managedWnd = NULL, | |
462 | unsigned int flags = wxAUI_MGR_DEFAULT); | |
463 | virtual ~wxAuiManager(); | |
464 | void UnInit(); | |
465 | ||
466 | void SetFlags(unsigned int flags); | |
467 | unsigned int GetFlags() const; | |
468 | ||
469 | void SetManagedWindow(wxWindow* managedWnd); | |
470 | wxWindow* GetManagedWindow() const; | |
471 | ||
472 | static wxAuiManager* GetManager(wxWindow* window); | |
473 | ||
474 | void SetArtProvider(wxAuiDockArt* artProvider); | |
475 | wxAuiDockArt* GetArtProvider() const; | |
476 | ||
477 | wxAuiPaneInfo& GetPane(wxWindow* window); | |
478 | wxAuiPaneInfo& GetPane(const wxString& name); | |
479 | wxAuiPaneInfoArray& GetAllPanes(); | |
480 | ||
481 | bool AddPane(wxWindow* window, | |
482 | const wxAuiPaneInfo& paneInfo); | |
483 | ||
484 | bool AddPane(wxWindow* window, | |
485 | const wxAuiPaneInfo& paneInfo, | |
486 | const wxPoint& dropPos); | |
487 | ||
488 | bool AddPane(wxWindow* window, | |
489 | int direction = wxLEFT, | |
490 | const wxString& caption = wxEmptyString); | |
491 | ||
492 | bool InsertPane(wxWindow* window, | |
493 | const wxAuiPaneInfo& insertLocation, | |
494 | int insertLevel = wxAUI_INSERT_PANE); | |
495 | ||
496 | bool DetachPane(wxWindow* window); | |
497 | ||
498 | void Update(); | |
499 | ||
500 | wxString SavePaneInfo(wxAuiPaneInfo& pane); | |
501 | void LoadPaneInfo(wxString panePart, wxAuiPaneInfo &pane); | |
502 | wxString SavePerspective(); | |
503 | bool LoadPerspective(const wxString& perspective, bool update = true); | |
504 | ||
505 | void SetDockSizeConstraint(double widthPct, double heightPct); | |
506 | void GetDockSizeConstraint(double* widthPct, double* heightPct) const; | |
507 | ||
508 | void ClosePane(wxAuiPaneInfo& paneInfo); | |
509 | void MaximizePane(wxAuiPaneInfo& paneInfo); | |
510 | void RestorePane(wxAuiPaneInfo& paneInfo); | |
511 | void RestoreMaximizedPane(); | |
512 | ||
513 | public: | |
514 | ||
515 | virtual wxAuiFloatingFrame* CreateFloatingFrame(wxWindow* parent, const wxAuiPaneInfo& p); | |
516 | virtual bool CanDockPanel(const wxAuiPaneInfo & p); | |
517 | ||
518 | void StartPaneDrag( | |
519 | wxWindow* paneWindow, | |
520 | const wxPoint& offset); | |
521 | ||
522 | wxRect CalculateHintRect( | |
523 | wxWindow* paneWindow, | |
524 | const wxPoint& pt, | |
525 | const wxPoint& offset); | |
526 | ||
527 | void DrawHintRect( | |
528 | wxWindow* paneWindow, | |
529 | const wxPoint& pt, | |
530 | const wxPoint& offset); | |
531 | ||
532 | virtual void ShowHint(const wxRect& rect); | |
533 | virtual void HideHint(); | |
534 | ||
535 | void OnHintActivate(wxActivateEvent& event); | |
536 | ||
537 | public: | |
538 | ||
539 | // deprecated -- please use SetManagedWindow() and | |
540 | // and GetManagedWindow() instead | |
541 | ||
542 | wxDEPRECATED( void SetFrame(wxFrame* frame) ); | |
543 | wxDEPRECATED( wxFrame* GetFrame() const ); | |
544 | ||
545 | protected: | |
546 | ||
547 | void UpdateHintWindowConfig(); | |
548 | ||
549 | void DoFrameLayout(); | |
550 | ||
551 | void LayoutAddPane(wxSizer* container, | |
552 | wxAuiDockInfo& dock, | |
553 | wxAuiPaneInfo& pane, | |
554 | wxAuiDockUIPartArray& uiparts, | |
555 | bool spacerOnly); | |
556 | ||
557 | void LayoutAddDock(wxSizer* container, | |
558 | wxAuiDockInfo& dock, | |
559 | wxAuiDockUIPartArray& uiParts, | |
560 | bool spacerOnly); | |
561 | ||
562 | wxSizer* LayoutAll(wxAuiPaneInfoArray& panes, | |
563 | wxAuiDockInfoArray& docks, | |
564 | wxAuiDockUIPartArray & uiParts, | |
565 | bool spacerOnly = false); | |
566 | ||
567 | virtual bool ProcessDockResult(wxAuiPaneInfo& target, | |
568 | const wxAuiPaneInfo& newPos); | |
569 | ||
570 | bool DoDrop(wxAuiDockInfoArray& docks, | |
571 | wxAuiPaneInfoArray& panes, | |
572 | wxAuiPaneInfo& drop, | |
573 | const wxPoint& pt, | |
574 | const wxPoint& actionOffset = wxPoint(0,0)); | |
575 | ||
576 | wxAuiDockUIPart* HitTest(int x, int y); | |
577 | wxAuiDockUIPart* GetPanePart(wxWindow* pane); | |
578 | int GetDockPixelOffset(wxAuiPaneInfo& test); | |
579 | void OnFloatingPaneMoveStart(wxWindow* window); | |
580 | void OnFloatingPaneMoving(wxWindow* window, wxDirection dir ); | |
581 | void OnFloatingPaneMoved(wxWindow* window, wxDirection dir); | |
582 | void OnFloatingPaneActivated(wxWindow* window); | |
583 | void OnFloatingPaneClosed(wxWindow* window, wxCloseEvent& evt); | |
584 | void OnFloatingPaneResized(wxWindow* window, const wxRect& rect); | |
585 | void Render(wxDC* dc); | |
586 | void Repaint(wxDC* dc = NULL); | |
587 | void ProcessMgrEvent(wxAuiManagerEvent& event); | |
588 | void UpdateButtonOnScreen(wxAuiDockUIPart* buttonUiPart, | |
589 | const wxMouseEvent& event); | |
590 | void GetPanePositionsAndSizes(wxAuiDockInfo& dock, | |
591 | wxArrayInt& positions, | |
592 | wxArrayInt& sizes); | |
593 | ||
594 | /// Ends a resize action, or for live update, resizes the sash | |
595 | bool DoEndResizeAction(wxMouseEvent& event); | |
596 | ||
597 | public: | |
598 | ||
599 | // public events (which can be invoked externally) | |
600 | void OnRender(wxAuiManagerEvent& evt); | |
601 | void OnPaneButton(wxAuiManagerEvent& evt); | |
602 | ||
603 | protected: | |
604 | ||
605 | // protected events | |
606 | void OnPaint(wxPaintEvent& evt); | |
607 | void OnEraseBackground(wxEraseEvent& evt); | |
608 | void OnSize(wxSizeEvent& evt); | |
609 | void OnSetCursor(wxSetCursorEvent& evt); | |
610 | void OnLeftDown(wxMouseEvent& evt); | |
611 | void OnLeftUp(wxMouseEvent& evt); | |
612 | void OnMotion(wxMouseEvent& evt); | |
613 | void OnCaptureLost(wxMouseCaptureLostEvent& evt); | |
614 | void OnLeaveWindow(wxMouseEvent& evt); | |
615 | void OnChildFocus(wxChildFocusEvent& evt); | |
616 | void OnHintFadeTimer(wxTimerEvent& evt); | |
617 | void OnFindManager(wxAuiManagerEvent& evt); | |
618 | ||
619 | protected: | |
620 | ||
621 | enum | |
622 | { | |
623 | actionNone = 0, | |
624 | actionResize, | |
625 | actionClickButton, | |
626 | actionClickCaption, | |
627 | actionDragToolbarPane, | |
628 | actionDragFloatingPane | |
629 | }; | |
630 | ||
631 | protected: | |
632 | ||
633 | wxWindow* m_frame; // the window being managed | |
634 | wxAuiDockArt* m_art; // dock art object which does all drawing | |
635 | unsigned int m_flags; // manager flags wxAUI_MGR_* | |
636 | ||
637 | wxAuiPaneInfoArray m_panes; // array of panes structures | |
638 | wxAuiDockInfoArray m_docks; // array of docks structures | |
639 | wxAuiDockUIPartArray m_uiParts; // array of UI parts (captions, buttons, etc) | |
640 | ||
641 | int m_action; // current mouse action | |
642 | wxPoint m_actionStart; // position where the action click started | |
643 | wxPoint m_actionOffset; // offset from upper left of the item clicked | |
644 | wxAuiDockUIPart* m_actionPart; // ptr to the part the action happened to | |
645 | wxWindow* m_actionWindow; // action frame or window (NULL if none) | |
646 | wxRect m_actionHintRect; // hint rectangle for the action | |
647 | wxRect m_lastRect; | |
648 | wxAuiDockUIPart* m_hoverButton;// button uipart being hovered over | |
649 | wxRect m_lastHint; // last hint rectangle | |
650 | wxPoint m_lastMouseMove; // last mouse move position (see OnMotion) | |
651 | int m_currentDragItem; | |
652 | bool m_skipping; | |
653 | bool m_hasMaximized; | |
654 | ||
655 | double m_dockConstraintX; // 0.0 .. 1.0; max pct of window width a dock can consume | |
656 | double m_dockConstraintY; // 0.0 .. 1.0; max pct of window height a dock can consume | |
657 | ||
658 | wxFrame* m_hintWnd; // transparent hint window, if supported by platform | |
659 | wxTimer m_hintFadeTimer; // transparent fade timer | |
660 | wxByte m_hintFadeAmt; // transparent fade amount | |
661 | wxByte m_hintFadeMax; // maximum value of hint fade | |
662 | ||
663 | void* m_reserved; | |
664 | ||
665 | #ifndef SWIG | |
666 | DECLARE_EVENT_TABLE() | |
667 | DECLARE_CLASS(wxAuiManager) | |
668 | #endif // SWIG | |
669 | }; | |
670 | ||
671 | ||
672 | ||
673 | // event declarations/classes | |
674 | ||
675 | class WXDLLIMPEXP_AUI wxAuiManagerEvent : public wxEvent | |
676 | { | |
677 | public: | |
678 | wxAuiManagerEvent(wxEventType type=wxEVT_NULL) : wxEvent(0, type) | |
679 | { | |
680 | manager = NULL; | |
681 | pane = NULL; | |
682 | button = 0; | |
683 | veto_flag = false; | |
684 | canveto_flag = true; | |
685 | dc = NULL; | |
686 | } | |
687 | #ifndef SWIG | |
688 | wxAuiManagerEvent(const wxAuiManagerEvent& c) : wxEvent(c) | |
689 | { | |
690 | manager = c.manager; | |
691 | pane = c.pane; | |
692 | button = c.button; | |
693 | veto_flag = c.veto_flag; | |
694 | canveto_flag = c.canveto_flag; | |
695 | dc = c.dc; | |
696 | } | |
697 | #endif | |
698 | wxEvent *Clone() const { return new wxAuiManagerEvent(*this); } | |
699 | ||
700 | void SetManager(wxAuiManager* mgr) { manager = mgr; } | |
701 | void SetPane(wxAuiPaneInfo* p) { pane = p; } | |
702 | void SetButton(int b) { button = b; } | |
703 | void SetDC(wxDC* pdc) { dc = pdc; } | |
704 | ||
705 | wxAuiManager* GetManager() const { return manager; } | |
706 | wxAuiPaneInfo* GetPane() const { return pane; } | |
707 | int GetButton() const { return button; } | |
708 | wxDC* GetDC() const { return dc; } | |
709 | ||
710 | void Veto(bool veto = true) { veto_flag = veto; } | |
711 | bool GetVeto() const { return veto_flag; } | |
712 | void SetCanVeto(bool can_veto) { canveto_flag = can_veto; } | |
713 | bool CanVeto() const { return canveto_flag && veto_flag; } | |
714 | ||
715 | public: | |
716 | wxAuiManager* manager; | |
717 | wxAuiPaneInfo* pane; | |
718 | int button; | |
719 | bool veto_flag; | |
720 | bool canveto_flag; | |
721 | wxDC* dc; | |
722 | ||
723 | #ifndef SWIG | |
724 | private: | |
725 | DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxAuiManagerEvent) | |
726 | #endif | |
727 | }; | |
728 | ||
729 | ||
730 | class WXDLLIMPEXP_AUI wxAuiDockInfo | |
731 | { | |
732 | public: | |
733 | wxAuiDockInfo() | |
734 | { | |
735 | dock_direction = 0; | |
736 | dock_layer = 0; | |
737 | dock_row = 0; | |
738 | size = 0; | |
739 | min_size = 0; | |
740 | resizable = true; | |
741 | fixed = false; | |
742 | toolbar = false; | |
743 | reserved1 = false; | |
744 | } | |
745 | ||
746 | #ifndef SWIG | |
747 | wxAuiDockInfo(const wxAuiDockInfo& c) | |
748 | { | |
749 | dock_direction = c.dock_direction; | |
750 | dock_layer = c.dock_layer; | |
751 | dock_row = c.dock_row; | |
752 | size = c.size; | |
753 | min_size = c.min_size; | |
754 | resizable = c.resizable; | |
755 | fixed = c.fixed; | |
756 | toolbar = c.toolbar; | |
757 | panes = c.panes; | |
758 | rect = c.rect; | |
759 | reserved1 = c.reserved1; | |
760 | } | |
761 | ||
762 | wxAuiDockInfo& operator=(const wxAuiDockInfo& c) | |
763 | { | |
764 | dock_direction = c.dock_direction; | |
765 | dock_layer = c.dock_layer; | |
766 | dock_row = c.dock_row; | |
767 | size = c.size; | |
768 | min_size = c.min_size; | |
769 | resizable = c.resizable; | |
770 | fixed = c.fixed; | |
771 | toolbar = c.toolbar; | |
772 | panes = c.panes; | |
773 | rect = c.rect; | |
774 | reserved1 = c.reserved1; | |
775 | return *this; | |
776 | } | |
777 | #endif // SWIG | |
778 | ||
779 | bool IsOk() const { return dock_direction != 0; } | |
780 | bool IsHorizontal() const { return dock_direction == wxAUI_DOCK_TOP || | |
781 | dock_direction == wxAUI_DOCK_BOTTOM; } | |
782 | bool IsVertical() const { return dock_direction == wxAUI_DOCK_LEFT || | |
783 | dock_direction == wxAUI_DOCK_RIGHT || | |
784 | dock_direction == wxAUI_DOCK_CENTER; } | |
785 | public: | |
786 | wxAuiPaneInfoPtrArray panes; // array of panes | |
787 | wxRect rect; // current rectangle | |
788 | int dock_direction; // dock direction (top, bottom, left, right, center) | |
789 | int dock_layer; // layer number (0 = innermost layer) | |
790 | int dock_row; // row number on the docking bar (0 = first row) | |
791 | int size; // size of the dock | |
792 | int min_size; // minimum size of a dock (0 if there is no min) | |
793 | bool resizable; // flag indicating whether the dock is resizable | |
794 | bool toolbar; // flag indicating dock contains only toolbars | |
795 | bool fixed; // flag indicating that the dock operates on | |
796 | // absolute coordinates as opposed to proportional | |
797 | bool reserved1; | |
798 | }; | |
799 | ||
800 | ||
801 | class WXDLLIMPEXP_AUI wxAuiDockUIPart | |
802 | { | |
803 | public: | |
804 | enum | |
805 | { | |
806 | typeCaption, | |
807 | typeGripper, | |
808 | typeDock, | |
809 | typeDockSizer, | |
810 | typePane, | |
811 | typePaneSizer, | |
812 | typeBackground, | |
813 | typePaneBorder, | |
814 | typePaneButton | |
815 | }; | |
816 | ||
817 | int type; // ui part type (see enum above) | |
818 | int orientation; // orientation (either wxHORIZONTAL or wxVERTICAL) | |
819 | wxAuiDockInfo* dock; // which dock the item is associated with | |
820 | wxAuiPaneInfo* pane; // which pane the item is associated with | |
821 | wxAuiPaneButton* button; // which pane button the item is associated with | |
822 | wxSizer* cont_sizer; // the part's containing sizer | |
823 | wxSizerItem* sizer_item; // the sizer item of the part | |
824 | wxRect rect; // client coord rectangle of the part itself | |
825 | }; | |
826 | ||
827 | ||
828 | class WXDLLIMPEXP_AUI wxAuiPaneButton | |
829 | { | |
830 | public: | |
831 | int button_id; // id of the button (e.g. buttonClose) | |
832 | }; | |
833 | ||
834 | ||
835 | ||
836 | #ifndef SWIG | |
837 | ||
838 | wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_AUI, wxEVT_AUI_PANE_BUTTON, wxAuiManagerEvent ); | |
839 | wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_AUI, wxEVT_AUI_PANE_CLOSE, wxAuiManagerEvent ); | |
840 | wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_AUI, wxEVT_AUI_PANE_MAXIMIZE, wxAuiManagerEvent ); | |
841 | wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_AUI, wxEVT_AUI_PANE_RESTORE, wxAuiManagerEvent ); | |
842 | wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_AUI, wxEVT_AUI_RENDER, wxAuiManagerEvent ); | |
843 | wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_AUI, wxEVT_AUI_FIND_MANAGER, wxAuiManagerEvent ); | |
844 | ||
845 | typedef void (wxEvtHandler::*wxAuiManagerEventFunction)(wxAuiManagerEvent&); | |
846 | ||
847 | #define wxAuiManagerEventHandler(func) \ | |
848 | wxEVENT_HANDLER_CAST(wxAuiManagerEventFunction, func) | |
849 | ||
850 | #define EVT_AUI_PANE_BUTTON(func) \ | |
851 | wx__DECLARE_EVT0(wxEVT_AUI_PANE_BUTTON, wxAuiManagerEventHandler(func)) | |
852 | #define EVT_AUI_PANE_CLOSE(func) \ | |
853 | wx__DECLARE_EVT0(wxEVT_AUI_PANE_CLOSE, wxAuiManagerEventHandler(func)) | |
854 | #define EVT_AUI_PANE_MAXIMIZE(func) \ | |
855 | wx__DECLARE_EVT0(wxEVT_AUI_PANE_MAXIMIZE, wxAuiManagerEventHandler(func)) | |
856 | #define EVT_AUI_PANE_RESTORE(func) \ | |
857 | wx__DECLARE_EVT0(wxEVT_AUI_PANE_RESTORE, wxAuiManagerEventHandler(func)) | |
858 | #define EVT_AUI_RENDER(func) \ | |
859 | wx__DECLARE_EVT0(wxEVT_AUI_RENDER, wxAuiManagerEventHandler(func)) | |
860 | #define EVT_AUI_FIND_MANAGER(func) \ | |
861 | wx__DECLARE_EVT0(wxEVT_AUI_FIND_MANAGER, wxAuiManagerEventHandler(func)) | |
862 | ||
863 | #else | |
864 | ||
865 | %constant wxEventType wxEVT_AUI_PANE_BUTTON; | |
866 | %constant wxEventType wxEVT_AUI_PANE_CLOSE; | |
867 | %constant wxEventType wxEVT_AUI_PANE_MAXIMIZE; | |
868 | %constant wxEventType wxEVT_AUI_PANE_RESTORE; | |
869 | %constant wxEventType wxEVT_AUI_RENDER; | |
870 | %constant wxEventType wxEVT_AUI_FIND_MANAGER; | |
871 | ||
872 | %pythoncode { | |
873 | EVT_AUI_PANE_BUTTON = wx.PyEventBinder( wxEVT_AUI_PANE_BUTTON ) | |
874 | EVT_AUI_PANE_CLOSE = wx.PyEventBinder( wxEVT_AUI_PANE_CLOSE ) | |
875 | EVT_AUI_PANE_MAXIMIZE = wx.PyEventBinder( wxEVT_AUI_PANE_MAXIMIZE ) | |
876 | EVT_AUI_PANE_RESTORE = wx.PyEventBinder( wxEVT_AUI_PANE_RESTORE ) | |
877 | EVT_AUI_RENDER = wx.PyEventBinder( wxEVT_AUI_RENDER ) | |
878 | EVT_AUI_FIND_MANAGER = wx.PyEventBinder( wxEVT_AUI_FIND_MANAGER ) | |
879 | } | |
880 | #endif // SWIG | |
881 | ||
882 | #endif // wxUSE_AUI | |
883 | #endif //_WX_FRAMEMANAGER_H_ | |
884 |