/[pcsx2_0.9.7]/branch/r3113_0.9.7_beta/3rdparty/wxWidgets/include/wx/aui/framemanager.h
ViewVC logotype

Contents of /branch/r3113_0.9.7_beta/3rdparty/wxWidgets/include/wx/aui/framemanager.h

Parent Directory Parent Directory | Revision Log Revision Log


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

  ViewVC Help
Powered by ViewVC 1.1.22