]>
Commit | Line | Data |
---|---|---|
1 | /////////////////////////////////////////////////////////////////////////////// | |
2 | // Name: src/aui/framemanager.cpp | |
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-2006, Kirix Corporation, All Rights Reserved | |
9 | // Licence: wxWindows Library Licence, Version 3.1 | |
10 | /////////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | // ============================================================================ | |
13 | // declarations | |
14 | // ============================================================================ | |
15 | ||
16 | // ---------------------------------------------------------------------------- | |
17 | // headers | |
18 | // ---------------------------------------------------------------------------- | |
19 | ||
20 | #include "wx/wxprec.h" | |
21 | ||
22 | #ifdef __BORLANDC__ | |
23 | #pragma hdrstop | |
24 | #endif | |
25 | ||
26 | #if wxUSE_AUI | |
27 | ||
28 | #include "wx/aui/framemanager.h" | |
29 | #include "wx/aui/dockart.h" | |
30 | #include "wx/aui/floatpane.h" | |
31 | #include "wx/aui/tabmdi.h" | |
32 | #include "wx/aui/auibar.h" | |
33 | ||
34 | #ifndef WX_PRECOMP | |
35 | #include "wx/panel.h" | |
36 | #include "wx/settings.h" | |
37 | #include "wx/app.h" | |
38 | #include "wx/dcclient.h" | |
39 | #include "wx/dcscreen.h" | |
40 | #include "wx/toolbar.h" | |
41 | #include "wx/mdi.h" | |
42 | #include "wx/image.h" | |
43 | #endif | |
44 | ||
45 | WX_CHECK_BUILD_OPTIONS("wxAUI") | |
46 | ||
47 | #include "wx/arrimpl.cpp" | |
48 | WX_DECLARE_OBJARRAY(wxRect, wxAuiRectArray); | |
49 | WX_DEFINE_OBJARRAY(wxAuiRectArray) | |
50 | WX_DEFINE_OBJARRAY(wxAuiDockUIPartArray) | |
51 | WX_DEFINE_OBJARRAY(wxAuiDockInfoArray) | |
52 | WX_DEFINE_OBJARRAY(wxAuiPaneButtonArray) | |
53 | WX_DEFINE_OBJARRAY(wxAuiPaneInfoArray) | |
54 | ||
55 | wxAuiPaneInfo wxAuiNullPaneInfo; | |
56 | wxAuiDockInfo wxAuiNullDockInfo; | |
57 | DEFINE_EVENT_TYPE(wxEVT_AUI_PANE_BUTTON) | |
58 | DEFINE_EVENT_TYPE(wxEVT_AUI_PANE_CLOSE) | |
59 | DEFINE_EVENT_TYPE(wxEVT_AUI_PANE_MAXIMIZE) | |
60 | DEFINE_EVENT_TYPE(wxEVT_AUI_PANE_RESTORE) | |
61 | DEFINE_EVENT_TYPE(wxEVT_AUI_RENDER) | |
62 | DEFINE_EVENT_TYPE(wxEVT_AUI_FIND_MANAGER) | |
63 | ||
64 | #ifdef __WXMAC__ | |
65 | // a few defines to avoid nameclashes | |
66 | #define __MAC_OS_X_MEMORY_MANAGER_CLEAN__ 1 | |
67 | #define __AIFF__ | |
68 | #include "wx/osx/private.h" | |
69 | #endif | |
70 | ||
71 | #ifdef __WXMSW__ | |
72 | #include "wx/msw/wrapwin.h" | |
73 | #include "wx/msw/private.h" | |
74 | #include "wx/msw/dc.h" | |
75 | #endif | |
76 | ||
77 | IMPLEMENT_DYNAMIC_CLASS(wxAuiManagerEvent, wxEvent) | |
78 | IMPLEMENT_CLASS(wxAuiManager, wxEvtHandler) | |
79 | ||
80 | ||
81 | ||
82 | const int auiToolBarLayer = 10; | |
83 | ||
84 | #ifndef __WXGTK20__ | |
85 | ||
86 | ||
87 | class wxPseudoTransparentFrame : public wxFrame | |
88 | { | |
89 | public: | |
90 | wxPseudoTransparentFrame(wxWindow* parent = NULL, | |
91 | wxWindowID id = wxID_ANY, | |
92 | const wxString& title = wxEmptyString, | |
93 | const wxPoint& pos = wxDefaultPosition, | |
94 | const wxSize& size = wxDefaultSize, | |
95 | long style = wxDEFAULT_FRAME_STYLE, | |
96 | const wxString &name = wxT("frame")) | |
97 | : wxFrame(parent, id, title, pos, size, style | wxFRAME_SHAPED, name) | |
98 | { | |
99 | SetBackgroundStyle(wxBG_STYLE_CUSTOM); | |
100 | m_Amount=0; | |
101 | m_MaxWidth=0; | |
102 | m_MaxHeight=0; | |
103 | m_lastWidth=0; | |
104 | m_lastHeight=0; | |
105 | #ifdef __WXGTK__ | |
106 | m_CanSetShape = false; // have to wait for window create event on GTK | |
107 | #else | |
108 | m_CanSetShape = true; | |
109 | #endif | |
110 | m_Region = wxRegion(0, 0, 0, 0); | |
111 | SetTransparent(0); | |
112 | } | |
113 | ||
114 | virtual bool SetTransparent(wxByte alpha) | |
115 | { | |
116 | if (m_CanSetShape) | |
117 | { | |
118 | int w=100; // some defaults | |
119 | int h=100; | |
120 | GetClientSize(&w, &h); | |
121 | ||
122 | m_MaxWidth = w; | |
123 | m_MaxHeight = h; | |
124 | m_Amount = alpha; | |
125 | m_Region.Clear(); | |
126 | // m_Region.Union(0, 0, 1, m_MaxWidth); | |
127 | if (m_Amount) | |
128 | { | |
129 | for (int y=0; y<m_MaxHeight; y++) | |
130 | { | |
131 | // Reverse the order of the bottom 4 bits | |
132 | int j=((y&8)?1:0)|((y&4)?2:0)|((y&2)?4:0)|((y&1)?8:0); | |
133 | if ((j*16+8)<m_Amount) | |
134 | m_Region.Union(0, y, m_MaxWidth, 1); | |
135 | } | |
136 | } | |
137 | SetShape(m_Region); | |
138 | Refresh(); | |
139 | } | |
140 | return true; | |
141 | } | |
142 | ||
143 | void OnPaint(wxPaintEvent& WXUNUSED(event)) | |
144 | { | |
145 | wxPaintDC dc(this); | |
146 | ||
147 | if (m_Region.IsEmpty()) | |
148 | return; | |
149 | ||
150 | #ifdef __WXMAC__ | |
151 | dc.SetBrush(wxColour(128, 192, 255)); | |
152 | #else | |
153 | dc.SetBrush(wxSystemSettings::GetColour(wxSYS_COLOUR_ACTIVECAPTION)); | |
154 | #endif | |
155 | dc.SetPen(*wxTRANSPARENT_PEN); | |
156 | ||
157 | wxRegionIterator upd(GetUpdateRegion()); // get the update rect list | |
158 | ||
159 | while (upd) | |
160 | { | |
161 | wxRect rect(upd.GetRect()); | |
162 | dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height); | |
163 | ||
164 | ++upd; | |
165 | } | |
166 | } | |
167 | ||
168 | #ifdef __WXGTK__ | |
169 | void OnWindowCreate(wxWindowCreateEvent& WXUNUSED(event)) | |
170 | { | |
171 | m_CanSetShape=true; | |
172 | SetTransparent(0); | |
173 | } | |
174 | #endif | |
175 | ||
176 | void OnSize(wxSizeEvent& event) | |
177 | { | |
178 | // We sometimes get surplus size events | |
179 | if ((event.GetSize().GetWidth() == m_lastWidth) && | |
180 | (event.GetSize().GetHeight() == m_lastHeight)) | |
181 | { | |
182 | event.Skip(); | |
183 | return; | |
184 | } | |
185 | m_lastWidth = event.GetSize().GetWidth(); | |
186 | m_lastHeight = event.GetSize().GetHeight(); | |
187 | ||
188 | SetTransparent(m_Amount); | |
189 | m_Region.Intersect(0, 0, event.GetSize().GetWidth(), | |
190 | event.GetSize().GetHeight()); | |
191 | SetShape(m_Region); | |
192 | Refresh(); | |
193 | event.Skip(); | |
194 | } | |
195 | ||
196 | private: | |
197 | wxByte m_Amount; | |
198 | int m_MaxWidth; | |
199 | int m_MaxHeight; | |
200 | bool m_CanSetShape; | |
201 | int m_lastWidth,m_lastHeight; | |
202 | ||
203 | wxRegion m_Region; | |
204 | ||
205 | DECLARE_DYNAMIC_CLASS(wxPseudoTransparentFrame) | |
206 | DECLARE_EVENT_TABLE() | |
207 | }; | |
208 | ||
209 | ||
210 | IMPLEMENT_DYNAMIC_CLASS(wxPseudoTransparentFrame, wxFrame) | |
211 | ||
212 | BEGIN_EVENT_TABLE(wxPseudoTransparentFrame, wxFrame) | |
213 | EVT_PAINT(wxPseudoTransparentFrame::OnPaint) | |
214 | EVT_SIZE(wxPseudoTransparentFrame::OnSize) | |
215 | #ifdef __WXGTK__ | |
216 | EVT_WINDOW_CREATE(wxPseudoTransparentFrame::OnWindowCreate) | |
217 | #endif | |
218 | END_EVENT_TABLE() | |
219 | ||
220 | ||
221 | #else | |
222 | // __WXGTK20__ | |
223 | ||
224 | #include <gtk/gtk.h> | |
225 | ||
226 | static void | |
227 | gtk_pseudo_window_realized_callback( GtkWidget *m_widget, void *WXUNUSED(win) ) | |
228 | { | |
229 | wxSize disp = wxGetDisplaySize(); | |
230 | int amount = 128; | |
231 | wxRegion region; | |
232 | for (int y=0; y<disp.y; y++) | |
233 | { | |
234 | // Reverse the order of the bottom 4 bits | |
235 | int j=((y&8)?1:0)|((y&4)?2:0)|((y&2)?4:0)|((y&1)?8:0); | |
236 | if ((j*16+8)<amount) | |
237 | region.Union(0, y, disp.x, 1); | |
238 | } | |
239 | gdk_window_shape_combine_region(m_widget->window, region.GetRegion(), 0, 0); | |
240 | } | |
241 | ||
242 | ||
243 | class wxPseudoTransparentFrame: public wxFrame | |
244 | { | |
245 | public: | |
246 | wxPseudoTransparentFrame(wxWindow* parent = NULL, | |
247 | wxWindowID id = wxID_ANY, | |
248 | const wxString& title = wxEmptyString, | |
249 | const wxPoint& pos = wxDefaultPosition, | |
250 | const wxSize& size = wxDefaultSize, | |
251 | long style = wxDEFAULT_FRAME_STYLE, | |
252 | const wxString &name = wxT("frame")) | |
253 | { | |
254 | if (!CreateBase( parent, id, pos, size, style, wxDefaultValidator, name )) | |
255 | return; | |
256 | ||
257 | m_title = title; | |
258 | ||
259 | m_widget = gtk_window_new( GTK_WINDOW_POPUP ); | |
260 | g_object_ref(m_widget); | |
261 | ||
262 | if (parent) parent->AddChild(this); | |
263 | ||
264 | g_signal_connect( m_widget, "realize", | |
265 | G_CALLBACK (gtk_pseudo_window_realized_callback), this ); | |
266 | ||
267 | GdkColor col; | |
268 | col.red = 128 * 256; | |
269 | col.green = 192 * 256; | |
270 | col.blue = 255 * 256; | |
271 | gtk_widget_modify_bg( m_widget, GTK_STATE_NORMAL, &col ); | |
272 | } | |
273 | ||
274 | bool SetTransparent(wxByte WXUNUSED(alpha)) | |
275 | { | |
276 | return true; | |
277 | } | |
278 | ||
279 | private: | |
280 | DECLARE_DYNAMIC_CLASS(wxPseudoTransparentFrame) | |
281 | }; | |
282 | ||
283 | IMPLEMENT_DYNAMIC_CLASS(wxPseudoTransparentFrame, wxFrame) | |
284 | ||
285 | #endif | |
286 | // __WXGTK20__ | |
287 | ||
288 | ||
289 | ||
290 | // -- static utility functions -- | |
291 | ||
292 | static wxBitmap wxPaneCreateStippleBitmap() | |
293 | { | |
294 | unsigned char data[] = { 0,0,0,192,192,192, 192,192,192,0,0,0 }; | |
295 | wxImage img(2,2,data,true); | |
296 | return wxBitmap(img); | |
297 | } | |
298 | ||
299 | static void DrawResizeHint(wxDC& dc, const wxRect& rect) | |
300 | { | |
301 | wxBitmap stipple = wxPaneCreateStippleBitmap(); | |
302 | wxBrush brush(stipple); | |
303 | dc.SetBrush(brush); | |
304 | #ifdef __WXMSW__ | |
305 | wxMSWDCImpl *impl = (wxMSWDCImpl*) dc.GetImpl(); | |
306 | PatBlt(GetHdcOf(*impl), rect.GetX(), rect.GetY(), rect.GetWidth(), rect.GetHeight(), PATINVERT); | |
307 | #else | |
308 | dc.SetPen(*wxTRANSPARENT_PEN); | |
309 | ||
310 | dc.SetLogicalFunction(wxXOR); | |
311 | dc.DrawRectangle(rect); | |
312 | #endif | |
313 | } | |
314 | ||
315 | ||
316 | ||
317 | // CopyDocksAndPanes() - this utility function creates copies of | |
318 | // the dock and pane info. wxAuiDockInfo's usually contain pointers | |
319 | // to wxAuiPaneInfo classes, thus this function is necessary to reliably | |
320 | // reconstruct that relationship in the new dock info and pane info arrays | |
321 | ||
322 | static void CopyDocksAndPanes(wxAuiDockInfoArray& dest_docks, | |
323 | wxAuiPaneInfoArray& dest_panes, | |
324 | const wxAuiDockInfoArray& src_docks, | |
325 | const wxAuiPaneInfoArray& src_panes) | |
326 | { | |
327 | dest_docks = src_docks; | |
328 | dest_panes = src_panes; | |
329 | int i, j, k, dock_count, pc1, pc2; | |
330 | for (i = 0, dock_count = dest_docks.GetCount(); i < dock_count; ++i) | |
331 | { | |
332 | wxAuiDockInfo& dock = dest_docks.Item(i); | |
333 | for (j = 0, pc1 = dock.panes.GetCount(); j < pc1; ++j) | |
334 | for (k = 0, pc2 = src_panes.GetCount(); k < pc2; ++k) | |
335 | if (dock.panes.Item(j) == &src_panes.Item(k)) | |
336 | dock.panes.Item(j) = &dest_panes.Item(k); | |
337 | } | |
338 | } | |
339 | ||
340 | // GetMaxLayer() is an internal function which returns | |
341 | // the highest layer inside the specified dock | |
342 | static int GetMaxLayer(const wxAuiDockInfoArray& docks, | |
343 | int dock_direction) | |
344 | { | |
345 | int i, dock_count, max_layer = 0; | |
346 | for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i) | |
347 | { | |
348 | wxAuiDockInfo& dock = docks.Item(i); | |
349 | if (dock.dock_direction == dock_direction && | |
350 | dock.dock_layer > max_layer && !dock.fixed) | |
351 | max_layer = dock.dock_layer; | |
352 | } | |
353 | return max_layer; | |
354 | } | |
355 | ||
356 | ||
357 | // GetMaxRow() is an internal function which returns | |
358 | // the highest layer inside the specified dock | |
359 | static int GetMaxRow(const wxAuiPaneInfoArray& panes, int direction, int layer) | |
360 | { | |
361 | int i, pane_count, max_row = 0; | |
362 | for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i) | |
363 | { | |
364 | wxAuiPaneInfo& pane = panes.Item(i); | |
365 | if (pane.dock_direction == direction && | |
366 | pane.dock_layer == layer && | |
367 | pane.dock_row > max_row) | |
368 | max_row = pane.dock_row; | |
369 | } | |
370 | return max_row; | |
371 | } | |
372 | ||
373 | ||
374 | ||
375 | // DoInsertDockLayer() is an internal function that inserts a new dock | |
376 | // layer by incrementing all existing dock layer values by one | |
377 | static void DoInsertDockLayer(wxAuiPaneInfoArray& panes, | |
378 | int dock_direction, | |
379 | int dock_layer) | |
380 | { | |
381 | int i, pane_count; | |
382 | for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i) | |
383 | { | |
384 | wxAuiPaneInfo& pane = panes.Item(i); | |
385 | if (!pane.IsFloating() && | |
386 | pane.dock_direction == dock_direction && | |
387 | pane.dock_layer >= dock_layer) | |
388 | pane.dock_layer++; | |
389 | } | |
390 | } | |
391 | ||
392 | // DoInsertDockLayer() is an internal function that inserts a new dock | |
393 | // row by incrementing all existing dock row values by one | |
394 | static void DoInsertDockRow(wxAuiPaneInfoArray& panes, | |
395 | int dock_direction, | |
396 | int dock_layer, | |
397 | int dock_row) | |
398 | { | |
399 | int i, pane_count; | |
400 | for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i) | |
401 | { | |
402 | wxAuiPaneInfo& pane = panes.Item(i); | |
403 | if (!pane.IsFloating() && | |
404 | pane.dock_direction == dock_direction && | |
405 | pane.dock_layer == dock_layer && | |
406 | pane.dock_row >= dock_row) | |
407 | pane.dock_row++; | |
408 | } | |
409 | } | |
410 | ||
411 | // DoInsertDockLayer() is an internal function that inserts a space for | |
412 | // another dock pane by incrementing all existing dock row values by one | |
413 | static void DoInsertPane(wxAuiPaneInfoArray& panes, | |
414 | int dock_direction, | |
415 | int dock_layer, | |
416 | int dock_row, | |
417 | int dock_pos) | |
418 | { | |
419 | int i, pane_count; | |
420 | for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i) | |
421 | { | |
422 | wxAuiPaneInfo& pane = panes.Item(i); | |
423 | if (!pane.IsFloating() && | |
424 | pane.dock_direction == dock_direction && | |
425 | pane.dock_layer == dock_layer && | |
426 | pane.dock_row == dock_row && | |
427 | pane.dock_pos >= dock_pos) | |
428 | pane.dock_pos++; | |
429 | } | |
430 | } | |
431 | ||
432 | // FindDocks() is an internal function that returns a list of docks which meet | |
433 | // the specified conditions in the parameters and returns a sorted array | |
434 | // (sorted by layer and then row) | |
435 | static void FindDocks(wxAuiDockInfoArray& docks, | |
436 | int dock_direction, | |
437 | int dock_layer, | |
438 | int dock_row, | |
439 | wxAuiDockInfoPtrArray& arr) | |
440 | { | |
441 | int begin_layer = dock_layer; | |
442 | int end_layer = dock_layer; | |
443 | int begin_row = dock_row; | |
444 | int end_row = dock_row; | |
445 | int dock_count = docks.GetCount(); | |
446 | int layer, row, i, max_row = 0, max_layer = 0; | |
447 | ||
448 | // discover the maximum dock layer and the max row | |
449 | for (i = 0; i < dock_count; ++i) | |
450 | { | |
451 | max_row = wxMax(max_row, docks.Item(i).dock_row); | |
452 | max_layer = wxMax(max_layer, docks.Item(i).dock_layer); | |
453 | } | |
454 | ||
455 | // if no dock layer was specified, search all dock layers | |
456 | if (dock_layer == -1) | |
457 | { | |
458 | begin_layer = 0; | |
459 | end_layer = max_layer; | |
460 | } | |
461 | ||
462 | // if no dock row was specified, search all dock row | |
463 | if (dock_row == -1) | |
464 | { | |
465 | begin_row = 0; | |
466 | end_row = max_row; | |
467 | } | |
468 | ||
469 | arr.Clear(); | |
470 | ||
471 | for (layer = begin_layer; layer <= end_layer; ++layer) | |
472 | for (row = begin_row; row <= end_row; ++row) | |
473 | for (i = 0; i < dock_count; ++i) | |
474 | { | |
475 | wxAuiDockInfo& d = docks.Item(i); | |
476 | if (dock_direction == -1 || dock_direction == d.dock_direction) | |
477 | { | |
478 | if (d.dock_layer == layer && d.dock_row == row) | |
479 | arr.Add(&d); | |
480 | } | |
481 | } | |
482 | } | |
483 | ||
484 | // FindPaneInDock() looks up a specified window pointer inside a dock. | |
485 | // If found, the corresponding wxAuiPaneInfo pointer is returned, otherwise NULL. | |
486 | static wxAuiPaneInfo* FindPaneInDock(const wxAuiDockInfo& dock, wxWindow* window) | |
487 | { | |
488 | int i, count = dock.panes.GetCount(); | |
489 | for (i = 0; i < count; ++i) | |
490 | { | |
491 | wxAuiPaneInfo* p = dock.panes.Item(i); | |
492 | if (p->window == window) | |
493 | return p; | |
494 | } | |
495 | return NULL; | |
496 | } | |
497 | ||
498 | // RemovePaneFromDocks() removes a pane window from all docks | |
499 | // with a possible exception specified by parameter "ex_cept" | |
500 | static void RemovePaneFromDocks(wxAuiDockInfoArray& docks, | |
501 | wxAuiPaneInfo& pane, | |
502 | wxAuiDockInfo* ex_cept = NULL ) | |
503 | { | |
504 | int i, dock_count; | |
505 | for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i) | |
506 | { | |
507 | wxAuiDockInfo& d = docks.Item(i); | |
508 | if (&d == ex_cept) | |
509 | continue; | |
510 | wxAuiPaneInfo* pi = FindPaneInDock(d, pane.window); | |
511 | if (pi) | |
512 | d.panes.Remove(pi); | |
513 | } | |
514 | } | |
515 | ||
516 | /* | |
517 | // This function works fine, and may be used in the future | |
518 | ||
519 | // RenumberDockRows() takes a dock and assigns sequential numbers | |
520 | // to existing rows. Basically it takes out the gaps; so if a | |
521 | // dock has rows with numbers 0,2,5, they will become 0,1,2 | |
522 | static void RenumberDockRows(wxAuiDockInfoPtrArray& docks) | |
523 | { | |
524 | int i, dock_count; | |
525 | for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i) | |
526 | { | |
527 | wxAuiDockInfo& dock = *docks.Item(i); | |
528 | dock.dock_row = i; | |
529 | ||
530 | int j, pane_count; | |
531 | for (j = 0, pane_count = dock.panes.GetCount(); j < pane_count; ++j) | |
532 | dock.panes.Item(j)->dock_row = i; | |
533 | } | |
534 | } | |
535 | */ | |
536 | ||
537 | ||
538 | // SetActivePane() sets the active pane, as well as cycles through | |
539 | // every other pane and makes sure that all others' active flags | |
540 | // are turned off | |
541 | static void SetActivePane(wxAuiPaneInfoArray& panes, wxWindow* active_pane) | |
542 | { | |
543 | int i, pane_count; | |
544 | for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i) | |
545 | { | |
546 | wxAuiPaneInfo& pane = panes.Item(i); | |
547 | pane.state &= ~wxAuiPaneInfo::optionActive; | |
548 | if (pane.window == active_pane) | |
549 | pane.state |= wxAuiPaneInfo::optionActive; | |
550 | } | |
551 | } | |
552 | ||
553 | ||
554 | // this function is used to sort panes by dock position | |
555 | static int PaneSortFunc(wxAuiPaneInfo** p1, wxAuiPaneInfo** p2) | |
556 | { | |
557 | return ((*p1)->dock_pos < (*p2)->dock_pos) ? -1 : 1; | |
558 | } | |
559 | ||
560 | ||
561 | // -- wxAuiManager class implementation -- | |
562 | ||
563 | ||
564 | BEGIN_EVENT_TABLE(wxAuiManager, wxEvtHandler) | |
565 | EVT_AUI_PANE_BUTTON(wxAuiManager::OnPaneButton) | |
566 | EVT_AUI_RENDER(wxAuiManager::OnRender) | |
567 | EVT_PAINT(wxAuiManager::OnPaint) | |
568 | EVT_ERASE_BACKGROUND(wxAuiManager::OnEraseBackground) | |
569 | EVT_SIZE(wxAuiManager::OnSize) | |
570 | EVT_SET_CURSOR(wxAuiManager::OnSetCursor) | |
571 | EVT_LEFT_DOWN(wxAuiManager::OnLeftDown) | |
572 | EVT_LEFT_UP(wxAuiManager::OnLeftUp) | |
573 | EVT_MOTION(wxAuiManager::OnMotion) | |
574 | EVT_LEAVE_WINDOW(wxAuiManager::OnLeaveWindow) | |
575 | EVT_MOUSE_CAPTURE_LOST(wxAuiManager::OnCaptureLost) | |
576 | EVT_CHILD_FOCUS(wxAuiManager::OnChildFocus) | |
577 | EVT_AUI_FIND_MANAGER(wxAuiManager::OnFindManager) | |
578 | EVT_TIMER(101, wxAuiManager::OnHintFadeTimer) | |
579 | END_EVENT_TABLE() | |
580 | ||
581 | ||
582 | wxAuiManager::wxAuiManager(wxWindow* managed_wnd, unsigned int flags) | |
583 | { | |
584 | m_action = actionNone; | |
585 | m_last_mouse_move = wxPoint(); | |
586 | m_hover_button = NULL; | |
587 | m_art = new wxAuiDefaultDockArt; | |
588 | m_hint_wnd = NULL; | |
589 | m_flags = flags; | |
590 | m_skipping = false; | |
591 | m_has_maximized = false; | |
592 | m_frame = NULL; | |
593 | m_dock_constraint_x = 0.3; | |
594 | m_dock_constraint_y = 0.3; | |
595 | m_reserved = NULL; | |
596 | ||
597 | if (managed_wnd) | |
598 | { | |
599 | SetManagedWindow(managed_wnd); | |
600 | } | |
601 | } | |
602 | ||
603 | wxAuiManager::~wxAuiManager() | |
604 | { | |
605 | // NOTE: It's possible that the windows have already been destroyed by the | |
606 | // time this dtor is called, so this loop can result in memory access via | |
607 | // invalid pointers, resulting in a crash. So it will be disabled while | |
608 | // waiting for a better solution. | |
609 | #if 0 | |
610 | for ( size_t i = 0; i < m_panes.size(); i++ ) | |
611 | { | |
612 | wxAuiPaneInfo& pinfo = m_panes[i]; | |
613 | if (pinfo.window && !pinfo.window->GetParent()) | |
614 | delete pinfo.window; | |
615 | } | |
616 | #endif | |
617 | ||
618 | delete m_art; | |
619 | } | |
620 | ||
621 | // creates a floating frame for the windows | |
622 | wxAuiFloatingFrame* wxAuiManager::CreateFloatingFrame(wxWindow* parent, | |
623 | const wxAuiPaneInfo& pane_info) | |
624 | { | |
625 | return new wxAuiFloatingFrame(parent, this, pane_info); | |
626 | } | |
627 | ||
628 | bool wxAuiManager::CanDockPanel(const wxAuiPaneInfo & WXUNUSED(p)) | |
629 | { | |
630 | // if a key modifier is pressed while dragging the frame, | |
631 | // don't dock the window | |
632 | return !(wxGetKeyState(WXK_CONTROL) || wxGetKeyState(WXK_ALT)); | |
633 | } | |
634 | ||
635 | // GetPane() looks up a wxAuiPaneInfo structure based | |
636 | // on the supplied window pointer. Upon failure, GetPane() | |
637 | // returns an empty wxAuiPaneInfo, a condition which can be checked | |
638 | // by calling wxAuiPaneInfo::IsOk(). | |
639 | // | |
640 | // The pane info's structure may then be modified. Once a pane's | |
641 | // info is modified, wxAuiManager::Update() must be called to | |
642 | // realize the changes in the UI. | |
643 | ||
644 | wxAuiPaneInfo& wxAuiManager::GetPane(wxWindow* window) | |
645 | { | |
646 | int i, pane_count; | |
647 | for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i) | |
648 | { | |
649 | wxAuiPaneInfo& p = m_panes.Item(i); | |
650 | if (p.window == window) | |
651 | return p; | |
652 | } | |
653 | return wxAuiNullPaneInfo; | |
654 | } | |
655 | ||
656 | // this version of GetPane() looks up a pane based on a | |
657 | // 'pane name', see above comment for more info | |
658 | wxAuiPaneInfo& wxAuiManager::GetPane(const wxString& name) | |
659 | { | |
660 | int i, pane_count; | |
661 | for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i) | |
662 | { | |
663 | wxAuiPaneInfo& p = m_panes.Item(i); | |
664 | if (p.name == name) | |
665 | return p; | |
666 | } | |
667 | return wxAuiNullPaneInfo; | |
668 | } | |
669 | ||
670 | // GetAllPanes() returns a reference to all the pane info structures | |
671 | wxAuiPaneInfoArray& wxAuiManager::GetAllPanes() | |
672 | { | |
673 | return m_panes; | |
674 | } | |
675 | ||
676 | // HitTest() is an internal function which determines | |
677 | // which UI item the specified coordinates are over | |
678 | // (x,y) specify a position in client coordinates | |
679 | wxAuiDockUIPart* wxAuiManager::HitTest(int x, int y) | |
680 | { | |
681 | wxAuiDockUIPart* result = NULL; | |
682 | ||
683 | int i, part_count; | |
684 | for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i) | |
685 | { | |
686 | wxAuiDockUIPart* item = &m_uiparts.Item(i); | |
687 | ||
688 | // we are not interested in typeDock, because this space | |
689 | // isn't used to draw anything, just for measurements; | |
690 | // besides, the entire dock area is covered with other | |
691 | // rectangles, which we are interested in. | |
692 | if (item->type == wxAuiDockUIPart::typeDock) | |
693 | continue; | |
694 | ||
695 | // if we already have a hit on a more specific item, we are not | |
696 | // interested in a pane hit. If, however, we don't already have | |
697 | // a hit, returning a pane hit is necessary for some operations | |
698 | if ((item->type == wxAuiDockUIPart::typePane || | |
699 | item->type == wxAuiDockUIPart::typePaneBorder) && result) | |
700 | continue; | |
701 | ||
702 | // if the point is inside the rectangle, we have a hit | |
703 | if (item->rect.Contains(x,y)) | |
704 | result = item; | |
705 | } | |
706 | ||
707 | return result; | |
708 | } | |
709 | ||
710 | ||
711 | // SetFlags() and GetFlags() allow the owner to set various | |
712 | // options which are global to wxAuiManager | |
713 | void wxAuiManager::SetFlags(unsigned int flags) | |
714 | { | |
715 | // find out if we have to call UpdateHintWindowConfig() | |
716 | bool update_hint_wnd = false; | |
717 | unsigned int hint_mask = wxAUI_MGR_TRANSPARENT_HINT | | |
718 | wxAUI_MGR_VENETIAN_BLINDS_HINT | | |
719 | wxAUI_MGR_RECTANGLE_HINT; | |
720 | if ((flags & hint_mask) != (m_flags & hint_mask)) | |
721 | update_hint_wnd = true; | |
722 | ||
723 | ||
724 | // set the new flags | |
725 | m_flags = flags; | |
726 | ||
727 | if (update_hint_wnd) | |
728 | { | |
729 | UpdateHintWindowConfig(); | |
730 | } | |
731 | } | |
732 | ||
733 | unsigned int wxAuiManager::GetFlags() const | |
734 | { | |
735 | return m_flags; | |
736 | } | |
737 | ||
738 | ||
739 | // don't use these anymore as they are deprecated | |
740 | // use Set/GetManagedFrame() instead | |
741 | void wxAuiManager::SetFrame(wxFrame* frame) | |
742 | { | |
743 | SetManagedWindow((wxWindow*)frame); | |
744 | } | |
745 | ||
746 | wxFrame* wxAuiManager::GetFrame() const | |
747 | { | |
748 | return (wxFrame*)m_frame; | |
749 | } | |
750 | ||
751 | ||
752 | // this function will return the aui manager for a given | |
753 | // window. The |window| parameter should be any child window | |
754 | // or grand-child window (and so on) of the frame/window | |
755 | // managed by wxAuiManager. The |window| parameter does not | |
756 | // need to be managed by the manager itself. | |
757 | wxAuiManager* wxAuiManager::GetManager(wxWindow* window) | |
758 | { | |
759 | wxAuiManagerEvent evt(wxEVT_AUI_FIND_MANAGER); | |
760 | evt.SetManager(NULL); | |
761 | evt.ResumePropagation(wxEVENT_PROPAGATE_MAX); | |
762 | if (!window->ProcessEvent(evt)) | |
763 | return NULL; | |
764 | ||
765 | return evt.GetManager(); | |
766 | } | |
767 | ||
768 | ||
769 | void wxAuiManager::UpdateHintWindowConfig() | |
770 | { | |
771 | // find out if the the system can do transparent frames | |
772 | bool can_do_transparent = false; | |
773 | ||
774 | wxWindow* w = m_frame; | |
775 | while (w) | |
776 | { | |
777 | if (w->IsKindOf(CLASSINFO(wxFrame))) | |
778 | { | |
779 | wxFrame* f = static_cast<wxFrame*>(w); | |
780 | can_do_transparent = f->CanSetTransparent(); | |
781 | ||
782 | break; | |
783 | } | |
784 | ||
785 | w = w->GetParent(); | |
786 | } | |
787 | ||
788 | // if there is an existing hint window, delete it | |
789 | if (m_hint_wnd) | |
790 | { | |
791 | m_hint_wnd->Destroy(); | |
792 | m_hint_wnd = NULL; | |
793 | } | |
794 | ||
795 | m_hint_fademax = 50; | |
796 | m_hint_wnd = NULL; | |
797 | ||
798 | if ((m_flags & wxAUI_MGR_TRANSPARENT_HINT) && can_do_transparent) | |
799 | { | |
800 | // Make a window to use for a transparent hint | |
801 | #if defined(__WXMSW__) || defined(__WXGTK__) | |
802 | m_hint_wnd = new wxFrame(m_frame, wxID_ANY, wxEmptyString, | |
803 | wxDefaultPosition, wxSize(1,1), | |
804 | wxFRAME_TOOL_WINDOW | | |
805 | wxFRAME_FLOAT_ON_PARENT | | |
806 | wxFRAME_NO_TASKBAR | | |
807 | wxNO_BORDER); | |
808 | ||
809 | m_hint_wnd->SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_ACTIVECAPTION)); | |
810 | #elif defined(__WXMAC__) | |
811 | // Using a miniframe with float and tool styles keeps the parent | |
812 | // frame activated and highlighted as such... | |
813 | m_hint_wnd = new wxMiniFrame(m_frame, wxID_ANY, wxEmptyString, | |
814 | wxDefaultPosition, wxSize(1,1), | |
815 | wxFRAME_FLOAT_ON_PARENT | |
816 | | wxFRAME_TOOL_WINDOW ); | |
817 | ||
818 | // Can't set the bg colour of a Frame in wxMac | |
819 | wxPanel* p = new wxPanel(m_hint_wnd); | |
820 | ||
821 | // The default wxSYS_COLOUR_ACTIVECAPTION colour is a light silver | |
822 | // color that is really hard to see, especially transparent. | |
823 | // Until a better system color is decided upon we'll just use | |
824 | // blue. | |
825 | p->SetBackgroundColour(*wxBLUE); | |
826 | #endif | |
827 | ||
828 | } | |
829 | else | |
830 | { | |
831 | if ((m_flags & wxAUI_MGR_TRANSPARENT_HINT) != 0 || | |
832 | (m_flags & wxAUI_MGR_VENETIAN_BLINDS_HINT) != 0) | |
833 | { | |
834 | // system can't support transparent fade, or the venetian | |
835 | // blinds effect was explicitly requested | |
836 | m_hint_wnd = new wxPseudoTransparentFrame(m_frame, | |
837 | wxID_ANY, | |
838 | wxEmptyString, | |
839 | wxDefaultPosition, | |
840 | wxSize(1,1), | |
841 | wxFRAME_TOOL_WINDOW | | |
842 | wxFRAME_FLOAT_ON_PARENT | | |
843 | wxFRAME_NO_TASKBAR | | |
844 | wxNO_BORDER); | |
845 | m_hint_fademax = 128; | |
846 | } | |
847 | } | |
848 | } | |
849 | ||
850 | ||
851 | // SetManagedWindow() is usually called once when the frame | |
852 | // manager class is being initialized. "frame" specifies | |
853 | // the frame which should be managed by the frame mananger | |
854 | void wxAuiManager::SetManagedWindow(wxWindow* wnd) | |
855 | { | |
856 | wxASSERT_MSG(wnd, wxT("specified window must be non-NULL")); | |
857 | ||
858 | m_frame = wnd; | |
859 | m_frame->PushEventHandler(this); | |
860 | ||
861 | #if wxUSE_MDI | |
862 | // if the owner is going to manage an MDI parent frame, | |
863 | // we need to add the MDI client window as the default | |
864 | // center pane | |
865 | ||
866 | if (m_frame->IsKindOf(CLASSINFO(wxMDIParentFrame))) | |
867 | { | |
868 | wxMDIParentFrame* mdi_frame = (wxMDIParentFrame*)m_frame; | |
869 | wxWindow* client_window = mdi_frame->GetClientWindow(); | |
870 | ||
871 | wxASSERT_MSG(client_window, wxT("Client window is NULL!")); | |
872 | ||
873 | AddPane(client_window, | |
874 | wxAuiPaneInfo().Name(wxT("mdiclient")). | |
875 | CenterPane().PaneBorder(false)); | |
876 | } | |
877 | else if (m_frame->IsKindOf(CLASSINFO(wxAuiMDIParentFrame))) | |
878 | { | |
879 | wxAuiMDIParentFrame* mdi_frame = (wxAuiMDIParentFrame*)m_frame; | |
880 | wxAuiMDIClientWindow* client_window = mdi_frame->GetClientWindow(); | |
881 | wxASSERT_MSG(client_window, wxT("Client window is NULL!")); | |
882 | ||
883 | AddPane(client_window, | |
884 | wxAuiPaneInfo().Name(wxT("mdiclient")). | |
885 | CenterPane().PaneBorder(false)); | |
886 | } | |
887 | ||
888 | #endif | |
889 | ||
890 | UpdateHintWindowConfig(); | |
891 | } | |
892 | ||
893 | ||
894 | // UnInit() must be called, usually in the destructor | |
895 | // of the frame class. If it is not called, usually this | |
896 | // will result in a crash upon program exit | |
897 | void wxAuiManager::UnInit() | |
898 | { | |
899 | if (m_frame) | |
900 | { | |
901 | m_frame->RemoveEventHandler(this); | |
902 | } | |
903 | } | |
904 | ||
905 | // GetManagedWindow() returns the window pointer being managed | |
906 | wxWindow* wxAuiManager::GetManagedWindow() const | |
907 | { | |
908 | return m_frame; | |
909 | } | |
910 | ||
911 | wxAuiDockArt* wxAuiManager::GetArtProvider() const | |
912 | { | |
913 | return m_art; | |
914 | } | |
915 | ||
916 | void wxAuiManager::ProcessMgrEvent(wxAuiManagerEvent& event) | |
917 | { | |
918 | // first, give the owner frame a chance to override | |
919 | if (m_frame) | |
920 | { | |
921 | if (m_frame->ProcessEvent(event)) | |
922 | return; | |
923 | } | |
924 | ||
925 | ProcessEvent(event); | |
926 | } | |
927 | ||
928 | // SetArtProvider() instructs wxAuiManager to use the | |
929 | // specified art provider for all drawing calls. This allows | |
930 | // plugable look-and-feel features. The pointer that is | |
931 | // passed to this method subsequently belongs to wxAuiManager, | |
932 | // and is deleted in the frame manager destructor | |
933 | void wxAuiManager::SetArtProvider(wxAuiDockArt* art_provider) | |
934 | { | |
935 | // delete the last art provider, if any | |
936 | delete m_art; | |
937 | ||
938 | // assign the new art provider | |
939 | m_art = art_provider; | |
940 | } | |
941 | ||
942 | ||
943 | bool wxAuiManager::AddPane(wxWindow* window, const wxAuiPaneInfo& pane_info) | |
944 | { | |
945 | wxASSERT_MSG(window, wxT("NULL window ptrs are not allowed")); | |
946 | ||
947 | // check if the pane has a valid window | |
948 | if (!window) | |
949 | return false; | |
950 | ||
951 | // check if the window is already managed by us | |
952 | if (GetPane(pane_info.window).IsOk()) | |
953 | return false; | |
954 | ||
955 | // check if the pane name already exists, this could reveal a | |
956 | // bug in the library user's application | |
957 | bool already_exists = false; | |
958 | if (!pane_info.name.empty() && GetPane(pane_info.name).IsOk()) | |
959 | { | |
960 | wxFAIL_MSG(wxT("A pane with that name already exists in the manager!")); | |
961 | already_exists = true; | |
962 | } | |
963 | ||
964 | // if the new pane is docked then we should undo maximize | |
965 | if (pane_info.IsDocked()) | |
966 | RestoreMaximizedPane(); | |
967 | ||
968 | m_panes.Add(pane_info); | |
969 | ||
970 | wxAuiPaneInfo& pinfo = m_panes.Last(); | |
971 | ||
972 | // set the pane window | |
973 | pinfo.window = window; | |
974 | ||
975 | ||
976 | // if the pane's name identifier is blank, create a random string | |
977 | if (pinfo.name.empty() || already_exists) | |
978 | { | |
979 | pinfo.name.Printf(wxT("%08lx%08x%08x%08lx"), | |
980 | wxPtrToUInt(pinfo.window) & 0xffffffff, | |
981 | (unsigned int)time(NULL), | |
982 | #ifdef __WXWINCE__ | |
983 | (unsigned int)GetTickCount(), | |
984 | #else | |
985 | (unsigned int)clock(), | |
986 | #endif | |
987 | (unsigned long)m_panes.GetCount()); | |
988 | } | |
989 | ||
990 | // set initial proportion (if not already set) | |
991 | if (pinfo.dock_proportion == 0) | |
992 | pinfo.dock_proportion = 100000; | |
993 | ||
994 | if (pinfo.HasMaximizeButton()) | |
995 | { | |
996 | wxAuiPaneButton button; | |
997 | button.button_id = wxAUI_BUTTON_MAXIMIZE_RESTORE; | |
998 | pinfo.buttons.Add(button); | |
999 | } | |
1000 | ||
1001 | if (pinfo.HasPinButton()) | |
1002 | { | |
1003 | wxAuiPaneButton button; | |
1004 | button.button_id = wxAUI_BUTTON_PIN; | |
1005 | pinfo.buttons.Add(button); | |
1006 | } | |
1007 | ||
1008 | if (pinfo.HasCloseButton()) | |
1009 | { | |
1010 | wxAuiPaneButton button; | |
1011 | button.button_id = wxAUI_BUTTON_CLOSE; | |
1012 | pinfo.buttons.Add(button); | |
1013 | } | |
1014 | ||
1015 | if (pinfo.HasGripper()) | |
1016 | { | |
1017 | if (pinfo.window->IsKindOf(CLASSINFO(wxAuiToolBar))) | |
1018 | { | |
1019 | // prevent duplicate gripper -- both wxAuiManager and wxAuiToolBar | |
1020 | // have a gripper control. The toolbar's built-in gripper | |
1021 | // meshes better with the look and feel of the control than ours, | |
1022 | // so turn wxAuiManager's gripper off, and the toolbar's on. | |
1023 | ||
1024 | wxAuiToolBar* tb = static_cast<wxAuiToolBar*>(pinfo.window); | |
1025 | pinfo.SetFlag(wxAuiPaneInfo::optionGripper, false); | |
1026 | tb->SetGripperVisible(true); | |
1027 | } | |
1028 | } | |
1029 | ||
1030 | ||
1031 | if (pinfo.best_size == wxDefaultSize && | |
1032 | pinfo.window) | |
1033 | { | |
1034 | pinfo.best_size = pinfo.window->GetClientSize(); | |
1035 | ||
1036 | if (pinfo.window->IsKindOf(CLASSINFO(wxToolBar))) | |
1037 | { | |
1038 | // GetClientSize() doesn't get the best size for | |
1039 | // a toolbar under some newer versions of wxWidgets, | |
1040 | // so use GetBestSize() | |
1041 | pinfo.best_size = pinfo.window->GetBestSize(); | |
1042 | ||
1043 | // for some reason, wxToolBar::GetBestSize() is returning | |
1044 | // a size that is a pixel shy of the correct amount. | |
1045 | // I believe this to be the correct action, until | |
1046 | // wxToolBar::GetBestSize() is fixed. Is this assumption | |
1047 | // correct? | |
1048 | // commented out by JACS 2007-9-08 after having added a pixel in wxMSW's wxToolBar::DoGetBestSize() | |
1049 | // pinfo.best_size.y++; | |
1050 | } | |
1051 | ||
1052 | if (pinfo.min_size != wxDefaultSize) | |
1053 | { | |
1054 | if (pinfo.best_size.x < pinfo.min_size.x) | |
1055 | pinfo.best_size.x = pinfo.min_size.x; | |
1056 | if (pinfo.best_size.y < pinfo.min_size.y) | |
1057 | pinfo.best_size.y = pinfo.min_size.y; | |
1058 | } | |
1059 | } | |
1060 | ||
1061 | ||
1062 | ||
1063 | return true; | |
1064 | } | |
1065 | ||
1066 | bool wxAuiManager::AddPane(wxWindow* window, | |
1067 | int direction, | |
1068 | const wxString& caption) | |
1069 | { | |
1070 | wxAuiPaneInfo pinfo; | |
1071 | pinfo.Caption(caption); | |
1072 | switch (direction) | |
1073 | { | |
1074 | case wxTOP: pinfo.Top(); break; | |
1075 | case wxBOTTOM: pinfo.Bottom(); break; | |
1076 | case wxLEFT: pinfo.Left(); break; | |
1077 | case wxRIGHT: pinfo.Right(); break; | |
1078 | case wxCENTER: pinfo.CenterPane(); break; | |
1079 | } | |
1080 | return AddPane(window, pinfo); | |
1081 | } | |
1082 | ||
1083 | bool wxAuiManager::AddPane(wxWindow* window, | |
1084 | const wxAuiPaneInfo& pane_info, | |
1085 | const wxPoint& drop_pos) | |
1086 | { | |
1087 | if (!AddPane(window, pane_info)) | |
1088 | return false; | |
1089 | ||
1090 | wxAuiPaneInfo& pane = GetPane(window); | |
1091 | ||
1092 | DoDrop(m_docks, m_panes, pane, drop_pos, wxPoint(0,0)); | |
1093 | ||
1094 | return true; | |
1095 | } | |
1096 | ||
1097 | bool wxAuiManager::InsertPane(wxWindow* window, const wxAuiPaneInfo& pane_info, | |
1098 | int insert_level) | |
1099 | { | |
1100 | wxASSERT_MSG(window, wxT("NULL window ptrs are not allowed")); | |
1101 | ||
1102 | // shift the panes around, depending on the insert level | |
1103 | switch (insert_level) | |
1104 | { | |
1105 | case wxAUI_INSERT_PANE: | |
1106 | DoInsertPane(m_panes, | |
1107 | pane_info.dock_direction, | |
1108 | pane_info.dock_layer, | |
1109 | pane_info.dock_row, | |
1110 | pane_info.dock_pos); | |
1111 | break; | |
1112 | case wxAUI_INSERT_ROW: | |
1113 | DoInsertDockRow(m_panes, | |
1114 | pane_info.dock_direction, | |
1115 | pane_info.dock_layer, | |
1116 | pane_info.dock_row); | |
1117 | break; | |
1118 | case wxAUI_INSERT_DOCK: | |
1119 | DoInsertDockLayer(m_panes, | |
1120 | pane_info.dock_direction, | |
1121 | pane_info.dock_layer); | |
1122 | break; | |
1123 | } | |
1124 | ||
1125 | // if the window already exists, we are basically just moving/inserting the | |
1126 | // existing window. If it doesn't exist, we need to add it and insert it | |
1127 | wxAuiPaneInfo& existing_pane = GetPane(window); | |
1128 | if (!existing_pane.IsOk()) | |
1129 | { | |
1130 | return AddPane(window, pane_info); | |
1131 | } | |
1132 | else | |
1133 | { | |
1134 | if (pane_info.IsFloating()) | |
1135 | { | |
1136 | existing_pane.Float(); | |
1137 | if (pane_info.floating_pos != wxDefaultPosition) | |
1138 | existing_pane.FloatingPosition(pane_info.floating_pos); | |
1139 | if (pane_info.floating_size != wxDefaultSize) | |
1140 | existing_pane.FloatingSize(pane_info.floating_size); | |
1141 | } | |
1142 | else | |
1143 | { | |
1144 | // if the new pane is docked then we should undo maximize | |
1145 | RestoreMaximizedPane(); | |
1146 | ||
1147 | existing_pane.Direction(pane_info.dock_direction); | |
1148 | existing_pane.Layer(pane_info.dock_layer); | |
1149 | existing_pane.Row(pane_info.dock_row); | |
1150 | existing_pane.Position(pane_info.dock_pos); | |
1151 | } | |
1152 | } | |
1153 | ||
1154 | return true; | |
1155 | } | |
1156 | ||
1157 | ||
1158 | // DetachPane() removes a pane from the frame manager. This | |
1159 | // method will not destroy the window that is removed. | |
1160 | bool wxAuiManager::DetachPane(wxWindow* window) | |
1161 | { | |
1162 | wxASSERT_MSG(window, wxT("NULL window ptrs are not allowed")); | |
1163 | ||
1164 | int i, count; | |
1165 | for (i = 0, count = m_panes.GetCount(); i < count; ++i) | |
1166 | { | |
1167 | wxAuiPaneInfo& p = m_panes.Item(i); | |
1168 | if (p.window == window) | |
1169 | { | |
1170 | if (p.frame) | |
1171 | { | |
1172 | // we have a floating frame which is being detached. We need to | |
1173 | // reparent it to m_frame and destroy the floating frame | |
1174 | ||
1175 | // reduce flicker | |
1176 | p.window->SetSize(1,1); | |
1177 | ||
1178 | if (p.frame->IsShown()) | |
1179 | p.frame->Show(false); | |
1180 | ||
1181 | // reparent to m_frame and destroy the pane | |
1182 | if (m_action_window == p.frame) | |
1183 | { | |
1184 | m_action_window = NULL; | |
1185 | } | |
1186 | ||
1187 | p.window->Reparent(m_frame); | |
1188 | p.frame->SetSizer(NULL); | |
1189 | p.frame->Destroy(); | |
1190 | p.frame = NULL; | |
1191 | } | |
1192 | ||
1193 | // make sure there are no references to this pane in our uiparts, | |
1194 | // just in case the caller doesn't call Update() immediately after | |
1195 | // the DetachPane() call. This prevets obscure crashes which would | |
1196 | // happen at window repaint if the caller forgets to call Update() | |
1197 | int pi, part_count; | |
1198 | for (pi = 0, part_count = (int)m_uiparts.GetCount(); pi < part_count; ++pi) | |
1199 | { | |
1200 | wxAuiDockUIPart& part = m_uiparts.Item(pi); | |
1201 | if (part.pane == &p) | |
1202 | { | |
1203 | m_uiparts.RemoveAt(pi); | |
1204 | part_count--; | |
1205 | pi--; | |
1206 | continue; | |
1207 | } | |
1208 | } | |
1209 | ||
1210 | m_panes.RemoveAt(i); | |
1211 | return true; | |
1212 | } | |
1213 | } | |
1214 | return false; | |
1215 | } | |
1216 | ||
1217 | // ClosePane() destroys or hides the pane depending on its flags | |
1218 | void wxAuiManager::ClosePane(wxAuiPaneInfo& pane_info) | |
1219 | { | |
1220 | // if we were maximized, restore | |
1221 | if (pane_info.IsMaximized()) | |
1222 | { | |
1223 | RestorePane(pane_info); | |
1224 | } | |
1225 | ||
1226 | // first, hide the window | |
1227 | if (pane_info.window && pane_info.window->IsShown()) | |
1228 | { | |
1229 | pane_info.window->Show(false); | |
1230 | } | |
1231 | ||
1232 | // make sure that we are the parent of this window | |
1233 | if (pane_info.window && pane_info.window->GetParent() != m_frame) | |
1234 | { | |
1235 | pane_info.window->Reparent(m_frame); | |
1236 | } | |
1237 | ||
1238 | // if we have a frame, destroy it | |
1239 | if (pane_info.frame) | |
1240 | { | |
1241 | pane_info.frame->Destroy(); | |
1242 | pane_info.frame = NULL; | |
1243 | } | |
1244 | ||
1245 | // now we need to either destroy or hide the pane | |
1246 | if (pane_info.IsDestroyOnClose()) | |
1247 | { | |
1248 | wxWindow * window = pane_info.window; | |
1249 | DetachPane(window); | |
1250 | if (window) | |
1251 | { | |
1252 | window->Destroy(); | |
1253 | } | |
1254 | } | |
1255 | else | |
1256 | { | |
1257 | pane_info.Hide(); | |
1258 | } | |
1259 | } | |
1260 | ||
1261 | void wxAuiManager::MaximizePane(wxAuiPaneInfo& pane_info) | |
1262 | { | |
1263 | int i, pane_count; | |
1264 | ||
1265 | // un-maximize and hide all other panes | |
1266 | for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i) | |
1267 | { | |
1268 | wxAuiPaneInfo& p = m_panes.Item(i); | |
1269 | if (!p.IsToolbar()) | |
1270 | { | |
1271 | p.Restore(); | |
1272 | ||
1273 | // save hidden state | |
1274 | p.SetFlag(wxAuiPaneInfo::savedHiddenState, | |
1275 | p.HasFlag(wxAuiPaneInfo::optionHidden)); | |
1276 | ||
1277 | // hide the pane, because only the newly | |
1278 | // maximized pane should show | |
1279 | p.Hide(); | |
1280 | } | |
1281 | } | |
1282 | ||
1283 | // mark ourselves maximized | |
1284 | pane_info.Maximize(); | |
1285 | pane_info.Show(); | |
1286 | m_has_maximized = true; | |
1287 | ||
1288 | // last, show the window | |
1289 | if (pane_info.window && !pane_info.window->IsShown()) | |
1290 | { | |
1291 | pane_info.window->Show(true); | |
1292 | } | |
1293 | } | |
1294 | ||
1295 | void wxAuiManager::RestorePane(wxAuiPaneInfo& pane_info) | |
1296 | { | |
1297 | int i, pane_count; | |
1298 | ||
1299 | // restore all the panes | |
1300 | for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i) | |
1301 | { | |
1302 | wxAuiPaneInfo& p = m_panes.Item(i); | |
1303 | if (!p.IsToolbar()) | |
1304 | { | |
1305 | p.SetFlag(wxAuiPaneInfo::optionHidden, | |
1306 | p.HasFlag(wxAuiPaneInfo::savedHiddenState)); | |
1307 | } | |
1308 | } | |
1309 | ||
1310 | // mark ourselves non-maximized | |
1311 | pane_info.Restore(); | |
1312 | m_has_maximized = false; | |
1313 | ||
1314 | // last, show the window | |
1315 | if (pane_info.window && !pane_info.window->IsShown()) | |
1316 | { | |
1317 | pane_info.window->Show(true); | |
1318 | } | |
1319 | } | |
1320 | ||
1321 | void wxAuiManager::RestoreMaximizedPane() | |
1322 | { | |
1323 | int i, pane_count; | |
1324 | ||
1325 | // restore all the panes | |
1326 | for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i) | |
1327 | { | |
1328 | wxAuiPaneInfo& p = m_panes.Item(i); | |
1329 | if (p.IsMaximized()) | |
1330 | { | |
1331 | RestorePane(p); | |
1332 | break; | |
1333 | } | |
1334 | } | |
1335 | } | |
1336 | ||
1337 | // EscapeDelimiters() changes ";" into "\;" and "|" into "\|" | |
1338 | // in the input string. This is an internal functions which is | |
1339 | // used for saving perspectives | |
1340 | static wxString EscapeDelimiters(const wxString& s) | |
1341 | { | |
1342 | wxString result; | |
1343 | result.Alloc(s.length()); | |
1344 | const wxChar* ch = s.c_str(); | |
1345 | while (*ch) | |
1346 | { | |
1347 | if (*ch == wxT(';') || *ch == wxT('|')) | |
1348 | result += wxT('\\'); | |
1349 | result += *ch; | |
1350 | ++ch; | |
1351 | } | |
1352 | return result; | |
1353 | } | |
1354 | ||
1355 | wxString wxAuiManager::SavePaneInfo(wxAuiPaneInfo& pane) | |
1356 | { | |
1357 | wxString result = wxT("name="); | |
1358 | result += EscapeDelimiters(pane.name); | |
1359 | result += wxT(";"); | |
1360 | ||
1361 | result += wxT("caption="); | |
1362 | result += EscapeDelimiters(pane.caption); | |
1363 | result += wxT(";"); | |
1364 | ||
1365 | result += wxString::Format(wxT("state=%u;"), pane.state); | |
1366 | result += wxString::Format(wxT("dir=%d;"), pane.dock_direction); | |
1367 | result += wxString::Format(wxT("layer=%d;"), pane.dock_layer); | |
1368 | result += wxString::Format(wxT("row=%d;"), pane.dock_row); | |
1369 | result += wxString::Format(wxT("pos=%d;"), pane.dock_pos); | |
1370 | result += wxString::Format(wxT("prop=%d;"), pane.dock_proportion); | |
1371 | result += wxString::Format(wxT("bestw=%d;"), pane.best_size.x); | |
1372 | result += wxString::Format(wxT("besth=%d;"), pane.best_size.y); | |
1373 | result += wxString::Format(wxT("minw=%d;"), pane.min_size.x); | |
1374 | result += wxString::Format(wxT("minh=%d;"), pane.min_size.y); | |
1375 | result += wxString::Format(wxT("maxw=%d;"), pane.max_size.x); | |
1376 | result += wxString::Format(wxT("maxh=%d;"), pane.max_size.y); | |
1377 | result += wxString::Format(wxT("floatx=%d;"), pane.floating_pos.x); | |
1378 | result += wxString::Format(wxT("floaty=%d;"), pane.floating_pos.y); | |
1379 | result += wxString::Format(wxT("floatw=%d;"), pane.floating_size.x); | |
1380 | result += wxString::Format(wxT("floath=%d"), pane.floating_size.y); | |
1381 | ||
1382 | return result; | |
1383 | } | |
1384 | ||
1385 | // Load a "pane" with the pane infor settings in pane_part | |
1386 | void wxAuiManager::LoadPaneInfo(wxString pane_part, wxAuiPaneInfo &pane) | |
1387 | { | |
1388 | // replace escaped characters so we can | |
1389 | // split up the string easily | |
1390 | pane_part.Replace(wxT("\\|"), wxT("\a")); | |
1391 | pane_part.Replace(wxT("\\;"), wxT("\b")); | |
1392 | ||
1393 | while(1) | |
1394 | { | |
1395 | wxString val_part = pane_part.BeforeFirst(wxT(';')); | |
1396 | pane_part = pane_part.AfterFirst(wxT(';')); | |
1397 | wxString val_name = val_part.BeforeFirst(wxT('=')); | |
1398 | wxString value = val_part.AfterFirst(wxT('=')); | |
1399 | val_name.MakeLower(); | |
1400 | val_name.Trim(true); | |
1401 | val_name.Trim(false); | |
1402 | value.Trim(true); | |
1403 | value.Trim(false); | |
1404 | ||
1405 | if (val_name.empty()) | |
1406 | break; | |
1407 | ||
1408 | if (val_name == wxT("name")) | |
1409 | pane.name = value; | |
1410 | else if (val_name == wxT("caption")) | |
1411 | pane.caption = value; | |
1412 | else if (val_name == wxT("state")) | |
1413 | pane.state = (unsigned int)wxAtoi(value.c_str()); | |
1414 | else if (val_name == wxT("dir")) | |
1415 | pane.dock_direction = wxAtoi(value.c_str()); | |
1416 | else if (val_name == wxT("layer")) | |
1417 | pane.dock_layer = wxAtoi(value.c_str()); | |
1418 | else if (val_name == wxT("row")) | |
1419 | pane.dock_row = wxAtoi(value.c_str()); | |
1420 | else if (val_name == wxT("pos")) | |
1421 | pane.dock_pos = wxAtoi(value.c_str()); | |
1422 | else if (val_name == wxT("prop")) | |
1423 | pane.dock_proportion = wxAtoi(value.c_str()); | |
1424 | else if (val_name == wxT("bestw")) | |
1425 | pane.best_size.x = wxAtoi(value.c_str()); | |
1426 | else if (val_name == wxT("besth")) | |
1427 | pane.best_size.y = wxAtoi(value.c_str()); | |
1428 | else if (val_name == wxT("minw")) | |
1429 | pane.min_size.x = wxAtoi(value.c_str()); | |
1430 | else if (val_name == wxT("minh")) | |
1431 | pane.min_size.y = wxAtoi(value.c_str()); | |
1432 | else if (val_name == wxT("maxw")) | |
1433 | pane.max_size.x = wxAtoi(value.c_str()); | |
1434 | else if (val_name == wxT("maxh")) | |
1435 | pane.max_size.y = wxAtoi(value.c_str()); | |
1436 | else if (val_name == wxT("floatx")) | |
1437 | pane.floating_pos.x = wxAtoi(value.c_str()); | |
1438 | else if (val_name == wxT("floaty")) | |
1439 | pane.floating_pos.y = wxAtoi(value.c_str()); | |
1440 | else if (val_name == wxT("floatw")) | |
1441 | pane.floating_size.x = wxAtoi(value.c_str()); | |
1442 | else if (val_name == wxT("floath")) | |
1443 | pane.floating_size.y = wxAtoi(value.c_str()); | |
1444 | else { | |
1445 | wxFAIL_MSG(wxT("Bad Perspective String")); | |
1446 | } | |
1447 | } | |
1448 | ||
1449 | // replace escaped characters so we can | |
1450 | // split up the string easily | |
1451 | pane.name.Replace(wxT("\a"), wxT("|")); | |
1452 | pane.name.Replace(wxT("\b"), wxT(";")); | |
1453 | pane.caption.Replace(wxT("\a"), wxT("|")); | |
1454 | pane.caption.Replace(wxT("\b"), wxT(";")); | |
1455 | pane_part.Replace(wxT("\a"), wxT("|")); | |
1456 | pane_part.Replace(wxT("\b"), wxT(";")); | |
1457 | ||
1458 | return; | |
1459 | } | |
1460 | ||
1461 | ||
1462 | // SavePerspective() saves all pane information as a single string. | |
1463 | // This string may later be fed into LoadPerspective() to restore | |
1464 | // all pane settings. This save and load mechanism allows an | |
1465 | // exact pane configuration to be saved and restored at a later time | |
1466 | ||
1467 | wxString wxAuiManager::SavePerspective() | |
1468 | { | |
1469 | wxString result; | |
1470 | result.Alloc(500); | |
1471 | result = wxT("layout2|"); | |
1472 | ||
1473 | int pane_i, pane_count = m_panes.GetCount(); | |
1474 | for (pane_i = 0; pane_i < pane_count; ++pane_i) | |
1475 | { | |
1476 | wxAuiPaneInfo& pane = m_panes.Item(pane_i); | |
1477 | result += SavePaneInfo(pane)+wxT("|"); | |
1478 | } | |
1479 | ||
1480 | int dock_i, dock_count = m_docks.GetCount(); | |
1481 | for (dock_i = 0; dock_i < dock_count; ++dock_i) | |
1482 | { | |
1483 | wxAuiDockInfo& dock = m_docks.Item(dock_i); | |
1484 | ||
1485 | result += wxString::Format(wxT("dock_size(%d,%d,%d)=%d|"), | |
1486 | dock.dock_direction, dock.dock_layer, | |
1487 | dock.dock_row, dock.size); | |
1488 | } | |
1489 | ||
1490 | return result; | |
1491 | } | |
1492 | ||
1493 | // LoadPerspective() loads a layout which was saved with SavePerspective() | |
1494 | // If the "update" flag parameter is true, the GUI will immediately be updated | |
1495 | ||
1496 | bool wxAuiManager::LoadPerspective(const wxString& layout, bool update) | |
1497 | { | |
1498 | wxString input = layout; | |
1499 | wxString part; | |
1500 | ||
1501 | // check layout string version | |
1502 | // 'layout1' = wxAUI 0.9.0 - wxAUI 0.9.2 | |
1503 | // 'layout2' = wxAUI 0.9.2 (wxWidgets 2.8) | |
1504 | part = input.BeforeFirst(wxT('|')); | |
1505 | input = input.AfterFirst(wxT('|')); | |
1506 | part.Trim(true); | |
1507 | part.Trim(false); | |
1508 | if (part != wxT("layout2")) | |
1509 | return false; | |
1510 | ||
1511 | // mark all panes currently managed as docked and hidden | |
1512 | int pane_i, pane_count = m_panes.GetCount(); | |
1513 | for (pane_i = 0; pane_i < pane_count; ++pane_i) | |
1514 | m_panes.Item(pane_i).Dock().Hide(); | |
1515 | ||
1516 | // clear out the dock array; this will be reconstructed | |
1517 | m_docks.Clear(); | |
1518 | ||
1519 | // replace escaped characters so we can | |
1520 | // split up the string easily | |
1521 | input.Replace(wxT("\\|"), wxT("\a")); | |
1522 | input.Replace(wxT("\\;"), wxT("\b")); | |
1523 | ||
1524 | while (1) | |
1525 | { | |
1526 | wxAuiPaneInfo pane; | |
1527 | ||
1528 | wxString pane_part = input.BeforeFirst(wxT('|')); | |
1529 | input = input.AfterFirst(wxT('|')); | |
1530 | pane_part.Trim(true); | |
1531 | ||
1532 | // if the string is empty, we're done parsing | |
1533 | if (pane_part.empty()) | |
1534 | break; | |
1535 | ||
1536 | if (pane_part.Left(9) == wxT("dock_size")) | |
1537 | { | |
1538 | wxString val_name = pane_part.BeforeFirst(wxT('=')); | |
1539 | wxString value = pane_part.AfterFirst(wxT('=')); | |
1540 | ||
1541 | long dir, layer, row, size; | |
1542 | wxString piece = val_name.AfterFirst(wxT('(')); | |
1543 | piece = piece.BeforeLast(wxT(')')); | |
1544 | piece.BeforeFirst(wxT(',')).ToLong(&dir); | |
1545 | piece = piece.AfterFirst(wxT(',')); | |
1546 | piece.BeforeFirst(wxT(',')).ToLong(&layer); | |
1547 | piece.AfterFirst(wxT(',')).ToLong(&row); | |
1548 | value.ToLong(&size); | |
1549 | ||
1550 | wxAuiDockInfo dock; | |
1551 | dock.dock_direction = dir; | |
1552 | dock.dock_layer = layer; | |
1553 | dock.dock_row = row; | |
1554 | dock.size = size; | |
1555 | m_docks.Add(dock); | |
1556 | continue; | |
1557 | } | |
1558 | ||
1559 | // Undo our escaping as LoadPaneInfo needs to take an unescaped | |
1560 | // name so it can be called by external callers | |
1561 | pane_part.Replace(wxT("\a"), wxT("|")); | |
1562 | pane_part.Replace(wxT("\b"), wxT(";")); | |
1563 | ||
1564 | LoadPaneInfo(pane_part, pane); | |
1565 | ||
1566 | wxAuiPaneInfo& p = GetPane(pane.name); | |
1567 | if (!p.IsOk()) | |
1568 | { | |
1569 | // the pane window couldn't be found | |
1570 | // in the existing layout -- skip it | |
1571 | continue; | |
1572 | } | |
1573 | ||
1574 | p.SafeSet(pane); | |
1575 | } | |
1576 | ||
1577 | if (update) | |
1578 | Update(); | |
1579 | ||
1580 | return true; | |
1581 | } | |
1582 | ||
1583 | void wxAuiManager::GetPanePositionsAndSizes(wxAuiDockInfo& dock, | |
1584 | wxArrayInt& positions, | |
1585 | wxArrayInt& sizes) | |
1586 | { | |
1587 | int caption_size = m_art->GetMetric(wxAUI_DOCKART_CAPTION_SIZE); | |
1588 | int pane_border_size = m_art->GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE); | |
1589 | int gripper_size = m_art->GetMetric(wxAUI_DOCKART_GRIPPER_SIZE); | |
1590 | ||
1591 | positions.Empty(); | |
1592 | sizes.Empty(); | |
1593 | ||
1594 | int offset, action_pane = -1; | |
1595 | int pane_i, pane_count = dock.panes.GetCount(); | |
1596 | ||
1597 | // find the pane marked as our action pane | |
1598 | for (pane_i = 0; pane_i < pane_count; ++pane_i) | |
1599 | { | |
1600 | wxAuiPaneInfo& pane = *(dock.panes.Item(pane_i)); | |
1601 | ||
1602 | if (pane.state & wxAuiPaneInfo::actionPane) | |
1603 | { | |
1604 | wxASSERT_MSG(action_pane==-1, wxT("Too many fixed action panes")); | |
1605 | action_pane = pane_i; | |
1606 | } | |
1607 | } | |
1608 | ||
1609 | // set up each panes default position, and | |
1610 | // determine the size (width or height, depending | |
1611 | // on the dock's orientation) of each pane | |
1612 | for (pane_i = 0; pane_i < pane_count; ++pane_i) | |
1613 | { | |
1614 | wxAuiPaneInfo& pane = *(dock.panes.Item(pane_i)); | |
1615 | positions.Add(pane.dock_pos); | |
1616 | int size = 0; | |
1617 | ||
1618 | if (pane.HasBorder()) | |
1619 | size += (pane_border_size*2); | |
1620 | ||
1621 | if (dock.IsHorizontal()) | |
1622 | { | |
1623 | if (pane.HasGripper() && !pane.HasGripperTop()) | |
1624 | size += gripper_size; | |
1625 | size += pane.best_size.x; | |
1626 | } | |
1627 | else | |
1628 | { | |
1629 | if (pane.HasGripper() && pane.HasGripperTop()) | |
1630 | size += gripper_size; | |
1631 | ||
1632 | if (pane.HasCaption()) | |
1633 | size += caption_size; | |
1634 | size += pane.best_size.y; | |
1635 | } | |
1636 | ||
1637 | sizes.Add(size); | |
1638 | } | |
1639 | ||
1640 | // if there is no action pane, just return the default | |
1641 | // positions (as specified in pane.pane_pos) | |
1642 | if (action_pane == -1) | |
1643 | return; | |
1644 | ||
1645 | offset = 0; | |
1646 | for (pane_i = action_pane-1; pane_i >= 0; --pane_i) | |
1647 | { | |
1648 | int amount = positions[pane_i+1] - (positions[pane_i] + sizes[pane_i]); | |
1649 | ||
1650 | if (amount >= 0) | |
1651 | offset += amount; | |
1652 | else | |
1653 | positions[pane_i] -= -amount; | |
1654 | ||
1655 | offset += sizes[pane_i]; | |
1656 | } | |
1657 | ||
1658 | // if the dock mode is fixed, make sure none of the panes | |
1659 | // overlap; we will bump panes that overlap | |
1660 | offset = 0; | |
1661 | for (pane_i = action_pane; pane_i < pane_count; ++pane_i) | |
1662 | { | |
1663 | int amount = positions[pane_i] - offset; | |
1664 | if (amount >= 0) | |
1665 | offset += amount; | |
1666 | else | |
1667 | positions[pane_i] += -amount; | |
1668 | ||
1669 | offset += sizes[pane_i]; | |
1670 | } | |
1671 | } | |
1672 | ||
1673 | ||
1674 | void wxAuiManager::LayoutAddPane(wxSizer* cont, | |
1675 | wxAuiDockInfo& dock, | |
1676 | wxAuiPaneInfo& pane, | |
1677 | wxAuiDockUIPartArray& uiparts, | |
1678 | bool spacer_only) | |
1679 | { | |
1680 | wxAuiDockUIPart part; | |
1681 | wxSizerItem* sizer_item; | |
1682 | ||
1683 | int caption_size = m_art->GetMetric(wxAUI_DOCKART_CAPTION_SIZE); | |
1684 | int gripper_size = m_art->GetMetric(wxAUI_DOCKART_GRIPPER_SIZE); | |
1685 | int pane_border_size = m_art->GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE); | |
1686 | int pane_button_size = m_art->GetMetric(wxAUI_DOCKART_PANE_BUTTON_SIZE); | |
1687 | ||
1688 | // find out the orientation of the item (orientation for panes | |
1689 | // is the same as the dock's orientation) | |
1690 | int orientation; | |
1691 | if (dock.IsHorizontal()) | |
1692 | orientation = wxHORIZONTAL; | |
1693 | else | |
1694 | orientation = wxVERTICAL; | |
1695 | ||
1696 | // this variable will store the proportion | |
1697 | // value that the pane will receive | |
1698 | int pane_proportion = pane.dock_proportion; | |
1699 | ||
1700 | wxBoxSizer* horz_pane_sizer = new wxBoxSizer(wxHORIZONTAL); | |
1701 | wxBoxSizer* vert_pane_sizer = new wxBoxSizer(wxVERTICAL); | |
1702 | ||
1703 | if (pane.HasGripper()) | |
1704 | { | |
1705 | if (pane.HasGripperTop()) | |
1706 | sizer_item = vert_pane_sizer ->Add(1, gripper_size, 0, wxEXPAND); | |
1707 | else | |
1708 | sizer_item = horz_pane_sizer ->Add(gripper_size, 1, 0, wxEXPAND); | |
1709 | ||
1710 | part.type = wxAuiDockUIPart::typeGripper; | |
1711 | part.dock = &dock; | |
1712 | part.pane = &pane; | |
1713 | part.button = NULL; | |
1714 | part.orientation = orientation; | |
1715 | part.cont_sizer = horz_pane_sizer; | |
1716 | part.sizer_item = sizer_item; | |
1717 | uiparts.Add(part); | |
1718 | } | |
1719 | ||
1720 | if (pane.HasCaption()) | |
1721 | { | |
1722 | // create the caption sizer | |
1723 | wxBoxSizer* caption_sizer = new wxBoxSizer(wxHORIZONTAL); | |
1724 | ||
1725 | sizer_item = caption_sizer->Add(1, caption_size, 1, wxEXPAND); | |
1726 | ||
1727 | part.type = wxAuiDockUIPart::typeCaption; | |
1728 | part.dock = &dock; | |
1729 | part.pane = &pane; | |
1730 | part.button = NULL; | |
1731 | part.orientation = orientation; | |
1732 | part.cont_sizer = vert_pane_sizer; | |
1733 | part.sizer_item = sizer_item; | |
1734 | int caption_part_idx = uiparts.GetCount(); | |
1735 | uiparts.Add(part); | |
1736 | ||
1737 | // add pane buttons to the caption | |
1738 | int i, button_count; | |
1739 | for (i = 0, button_count = pane.buttons.GetCount(); | |
1740 | i < button_count; ++i) | |
1741 | { | |
1742 | wxAuiPaneButton& button = pane.buttons.Item(i); | |
1743 | ||
1744 | sizer_item = caption_sizer->Add(pane_button_size, | |
1745 | caption_size, | |
1746 | 0, wxEXPAND); | |
1747 | ||
1748 | part.type = wxAuiDockUIPart::typePaneButton; | |
1749 | part.dock = &dock; | |
1750 | part.pane = &pane; | |
1751 | part.button = &button; | |
1752 | part.orientation = orientation; | |
1753 | part.cont_sizer = caption_sizer; | |
1754 | part.sizer_item = sizer_item; | |
1755 | uiparts.Add(part); | |
1756 | } | |
1757 | ||
1758 | // if we have buttons, add a little space to the right | |
1759 | // of them to ease visual crowding | |
1760 | if (button_count >= 1) | |
1761 | { | |
1762 | caption_sizer->Add(3,1); | |
1763 | } | |
1764 | ||
1765 | // add the caption sizer | |
1766 | sizer_item = vert_pane_sizer->Add(caption_sizer, 0, wxEXPAND); | |
1767 | ||
1768 | uiparts.Item(caption_part_idx).sizer_item = sizer_item; | |
1769 | } | |
1770 | ||
1771 | // add the pane window itself | |
1772 | if (spacer_only) | |
1773 | { | |
1774 | sizer_item = vert_pane_sizer->Add(1, 1, 1, wxEXPAND); | |
1775 | } | |
1776 | else | |
1777 | { | |
1778 | sizer_item = vert_pane_sizer->Add(pane.window, 1, wxEXPAND); | |
1779 | // Don't do this because it breaks the pane size in floating windows | |
1780 | // BIW: Right now commenting this out is causing problems with | |
1781 | // an mdi client window as the center pane. | |
1782 | vert_pane_sizer->SetItemMinSize(pane.window, 1, 1); | |
1783 | } | |
1784 | ||
1785 | part.type = wxAuiDockUIPart::typePane; | |
1786 | part.dock = &dock; | |
1787 | part.pane = &pane; | |
1788 | part.button = NULL; | |
1789 | part.orientation = orientation; | |
1790 | part.cont_sizer = vert_pane_sizer; | |
1791 | part.sizer_item = sizer_item; | |
1792 | uiparts.Add(part); | |
1793 | ||
1794 | ||
1795 | // determine if the pane should have a minimum size; if the pane is | |
1796 | // non-resizable (fixed) then we must set a minimum size. Alternatively, | |
1797 | // if the pane.min_size is set, we must use that value as well | |
1798 | ||
1799 | wxSize min_size = pane.min_size; | |
1800 | if (pane.IsFixed()) | |
1801 | { | |
1802 | if (min_size == wxDefaultSize) | |
1803 | { | |
1804 | min_size = pane.best_size; | |
1805 | pane_proportion = 0; | |
1806 | } | |
1807 | } | |
1808 | ||
1809 | if (min_size != wxDefaultSize) | |
1810 | { | |
1811 | vert_pane_sizer->SetItemMinSize( | |
1812 | vert_pane_sizer->GetChildren().GetCount()-1, | |
1813 | min_size.x, min_size.y); | |
1814 | } | |
1815 | ||
1816 | ||
1817 | // add the verticle sizer (caption, pane window) to the | |
1818 | // horizontal sizer (gripper, verticle sizer) | |
1819 | horz_pane_sizer->Add(vert_pane_sizer, 1, wxEXPAND); | |
1820 | ||
1821 | // finally, add the pane sizer to the dock sizer | |
1822 | ||
1823 | if (pane.HasBorder()) | |
1824 | { | |
1825 | // allowing space for the pane's border | |
1826 | sizer_item = cont->Add(horz_pane_sizer, pane_proportion, | |
1827 | wxEXPAND | wxALL, pane_border_size); | |
1828 | ||
1829 | part.type = wxAuiDockUIPart::typePaneBorder; | |
1830 | part.dock = &dock; | |
1831 | part.pane = &pane; | |
1832 | part.button = NULL; | |
1833 | part.orientation = orientation; | |
1834 | part.cont_sizer = cont; | |
1835 | part.sizer_item = sizer_item; | |
1836 | uiparts.Add(part); | |
1837 | } | |
1838 | else | |
1839 | { | |
1840 | sizer_item = cont->Add(horz_pane_sizer, pane_proportion, wxEXPAND); | |
1841 | } | |
1842 | } | |
1843 | ||
1844 | void wxAuiManager::LayoutAddDock(wxSizer* cont, | |
1845 | wxAuiDockInfo& dock, | |
1846 | wxAuiDockUIPartArray& uiparts, | |
1847 | bool spacer_only) | |
1848 | { | |
1849 | wxSizerItem* sizer_item; | |
1850 | wxAuiDockUIPart part; | |
1851 | ||
1852 | int sash_size = m_art->GetMetric(wxAUI_DOCKART_SASH_SIZE); | |
1853 | int orientation = dock.IsHorizontal() ? wxHORIZONTAL : wxVERTICAL; | |
1854 | ||
1855 | // resizable bottom and right docks have a sash before them | |
1856 | if (!m_has_maximized && !dock.fixed && (dock.dock_direction == wxAUI_DOCK_BOTTOM || | |
1857 | dock.dock_direction == wxAUI_DOCK_RIGHT)) | |
1858 | { | |
1859 | sizer_item = cont->Add(sash_size, sash_size, 0, wxEXPAND); | |
1860 | ||
1861 | part.type = wxAuiDockUIPart::typeDockSizer; | |
1862 | part.orientation = orientation; | |
1863 | part.dock = &dock; | |
1864 | part.pane = NULL; | |
1865 | part.button = NULL; | |
1866 | part.cont_sizer = cont; | |
1867 | part.sizer_item = sizer_item; | |
1868 | uiparts.Add(part); | |
1869 | } | |
1870 | ||
1871 | // create the sizer for the dock | |
1872 | wxSizer* dock_sizer = new wxBoxSizer(orientation); | |
1873 | ||
1874 | // add each pane to the dock | |
1875 | bool has_maximized_pane = false; | |
1876 | int pane_i, pane_count = dock.panes.GetCount(); | |
1877 | ||
1878 | if (dock.fixed) | |
1879 | { | |
1880 | wxArrayInt pane_positions, pane_sizes; | |
1881 | ||
1882 | // figure out the real pane positions we will | |
1883 | // use, without modifying the each pane's pane_pos member | |
1884 | GetPanePositionsAndSizes(dock, pane_positions, pane_sizes); | |
1885 | ||
1886 | int offset = 0; | |
1887 | for (pane_i = 0; pane_i < pane_count; ++pane_i) | |
1888 | { | |
1889 | wxAuiPaneInfo& pane = *(dock.panes.Item(pane_i)); | |
1890 | int pane_pos = pane_positions.Item(pane_i); | |
1891 | ||
1892 | if (pane.IsMaximized()) | |
1893 | has_maximized_pane = true; | |
1894 | ||
1895 | ||
1896 | int amount = pane_pos - offset; | |
1897 | if (amount > 0) | |
1898 | { | |
1899 | if (dock.IsVertical()) | |
1900 | sizer_item = dock_sizer->Add(1, amount, 0, wxEXPAND); | |
1901 | else | |
1902 | sizer_item = dock_sizer->Add(amount, 1, 0, wxEXPAND); | |
1903 | ||
1904 | part.type = wxAuiDockUIPart::typeBackground; | |
1905 | part.dock = &dock; | |
1906 | part.pane = NULL; | |
1907 | part.button = NULL; | |
1908 | part.orientation = (orientation==wxHORIZONTAL) ? wxVERTICAL:wxHORIZONTAL; | |
1909 | part.cont_sizer = dock_sizer; | |
1910 | part.sizer_item = sizer_item; | |
1911 | uiparts.Add(part); | |
1912 | ||
1913 | offset += amount; | |
1914 | } | |
1915 | ||
1916 | LayoutAddPane(dock_sizer, dock, pane, uiparts, spacer_only); | |
1917 | ||
1918 | offset += pane_sizes.Item(pane_i); | |
1919 | } | |
1920 | ||
1921 | // at the end add a very small stretchable background area | |
1922 | sizer_item = dock_sizer->Add(0,0, 1, wxEXPAND); | |
1923 | ||
1924 | part.type = wxAuiDockUIPart::typeBackground; | |
1925 | part.dock = &dock; | |
1926 | part.pane = NULL; | |
1927 | part.button = NULL; | |
1928 | part.orientation = orientation; | |
1929 | part.cont_sizer = dock_sizer; | |
1930 | part.sizer_item = sizer_item; | |
1931 | uiparts.Add(part); | |
1932 | } | |
1933 | else | |
1934 | { | |
1935 | for (pane_i = 0; pane_i < pane_count; ++pane_i) | |
1936 | { | |
1937 | wxAuiPaneInfo& pane = *(dock.panes.Item(pane_i)); | |
1938 | ||
1939 | if (pane.IsMaximized()) | |
1940 | has_maximized_pane = true; | |
1941 | ||
1942 | // if this is not the first pane being added, | |
1943 | // we need to add a pane sizer | |
1944 | if (!m_has_maximized && pane_i > 0) | |
1945 | { | |
1946 | sizer_item = dock_sizer->Add(sash_size, sash_size, 0, wxEXPAND); | |
1947 | ||
1948 | part.type = wxAuiDockUIPart::typePaneSizer; | |
1949 | part.dock = &dock; | |
1950 | part.pane = dock.panes.Item(pane_i-1); | |
1951 | part.button = NULL; | |
1952 | part.orientation = (orientation==wxHORIZONTAL) ? wxVERTICAL:wxHORIZONTAL; | |
1953 | part.cont_sizer = dock_sizer; | |
1954 | part.sizer_item = sizer_item; | |
1955 | uiparts.Add(part); | |
1956 | } | |
1957 | ||
1958 | LayoutAddPane(dock_sizer, dock, pane, uiparts, spacer_only); | |
1959 | } | |
1960 | } | |
1961 | ||
1962 | if (dock.dock_direction == wxAUI_DOCK_CENTER || has_maximized_pane) | |
1963 | sizer_item = cont->Add(dock_sizer, 1, wxEXPAND); | |
1964 | else | |
1965 | sizer_item = cont->Add(dock_sizer, 0, wxEXPAND); | |
1966 | ||
1967 | part.type = wxAuiDockUIPart::typeDock; | |
1968 | part.dock = &dock; | |
1969 | part.pane = NULL; | |
1970 | part.button = NULL; | |
1971 | part.orientation = orientation; | |
1972 | part.cont_sizer = cont; | |
1973 | part.sizer_item = sizer_item; | |
1974 | uiparts.Add(part); | |
1975 | ||
1976 | if (dock.IsHorizontal()) | |
1977 | cont->SetItemMinSize(dock_sizer, 0, dock.size); | |
1978 | else | |
1979 | cont->SetItemMinSize(dock_sizer, dock.size, 0); | |
1980 | ||
1981 | // top and left docks have a sash after them | |
1982 | if (!m_has_maximized && | |
1983 | !dock.fixed && | |
1984 | (dock.dock_direction == wxAUI_DOCK_TOP || | |
1985 | dock.dock_direction == wxAUI_DOCK_LEFT)) | |
1986 | { | |
1987 | sizer_item = cont->Add(sash_size, sash_size, 0, wxEXPAND); | |
1988 | ||
1989 | part.type = wxAuiDockUIPart::typeDockSizer; | |
1990 | part.dock = &dock; | |
1991 | part.pane = NULL; | |
1992 | part.button = NULL; | |
1993 | part.orientation = orientation; | |
1994 | part.cont_sizer = cont; | |
1995 | part.sizer_item = sizer_item; | |
1996 | uiparts.Add(part); | |
1997 | } | |
1998 | } | |
1999 | ||
2000 | wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes, | |
2001 | wxAuiDockInfoArray& docks, | |
2002 | wxAuiDockUIPartArray& uiparts, | |
2003 | bool spacer_only) | |
2004 | { | |
2005 | wxBoxSizer* container = new wxBoxSizer(wxVERTICAL); | |
2006 | ||
2007 | int pane_border_size = m_art->GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE); | |
2008 | int caption_size = m_art->GetMetric(wxAUI_DOCKART_CAPTION_SIZE); | |
2009 | wxSize cli_size = m_frame->GetClientSize(); | |
2010 | int i, dock_count, pane_count; | |
2011 | ||
2012 | ||
2013 | // empty all docks out | |
2014 | for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i) | |
2015 | { | |
2016 | wxAuiDockInfo& dock = docks.Item(i); | |
2017 | ||
2018 | // empty out all panes, as they will be readded below | |
2019 | dock.panes.Empty(); | |
2020 | ||
2021 | if (dock.fixed) | |
2022 | { | |
2023 | // always reset fixed docks' sizes, because | |
2024 | // the contained windows may have been resized | |
2025 | dock.size = 0; | |
2026 | } | |
2027 | } | |
2028 | ||
2029 | ||
2030 | // iterate through all known panes, filing each | |
2031 | // of them into the appropriate dock. If the | |
2032 | // pane does not exist in the dock, add it | |
2033 | for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i) | |
2034 | { | |
2035 | wxAuiPaneInfo& p = panes.Item(i); | |
2036 | ||
2037 | // find any docks with the same dock direction, dock layer, and | |
2038 | // dock row as the pane we are working on | |
2039 | wxAuiDockInfo* dock; | |
2040 | wxAuiDockInfoPtrArray arr; | |
2041 | FindDocks(docks, p.dock_direction, p.dock_layer, p.dock_row, arr); | |
2042 | ||
2043 | if (arr.GetCount() > 0) | |
2044 | { | |
2045 | // found the right dock | |
2046 | dock = arr.Item(0); | |
2047 | } | |
2048 | else | |
2049 | { | |
2050 | // dock was not found, so we need to create a new one | |
2051 | wxAuiDockInfo d; | |
2052 | d.dock_direction = p.dock_direction; | |
2053 | d.dock_layer = p.dock_layer; | |
2054 | d.dock_row = p.dock_row; | |
2055 | docks.Add(d); | |
2056 | dock = &docks.Last(); | |
2057 | } | |
2058 | ||
2059 | ||
2060 | if (p.IsDocked() && p.IsShown()) | |
2061 | { | |
2062 | // remove the pane from any existing docks except this one | |
2063 | RemovePaneFromDocks(docks, p, dock); | |
2064 | ||
2065 | // pane needs to be added to the dock, | |
2066 | // if it doesn't already exist | |
2067 | if (!FindPaneInDock(*dock, p.window)) | |
2068 | dock->panes.Add(&p); | |
2069 | } | |
2070 | else | |
2071 | { | |
2072 | // remove the pane from any existing docks | |
2073 | RemovePaneFromDocks(docks, p); | |
2074 | } | |
2075 | ||
2076 | } | |
2077 | ||
2078 | // remove any empty docks | |
2079 | for (i = docks.GetCount()-1; i >= 0; --i) | |
2080 | { | |
2081 | if (docks.Item(i).panes.GetCount() == 0) | |
2082 | docks.RemoveAt(i); | |
2083 | } | |
2084 | ||
2085 | // configure the docks further | |
2086 | for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i) | |
2087 | { | |
2088 | wxAuiDockInfo& dock = docks.Item(i); | |
2089 | int j, dock_pane_count = dock.panes.GetCount(); | |
2090 | ||
2091 | // sort the dock pane array by the pane's | |
2092 | // dock position (dock_pos), in ascending order | |
2093 | dock.panes.Sort(PaneSortFunc); | |
2094 | ||
2095 | // for newly created docks, set up their initial size | |
2096 | if (dock.size == 0) | |
2097 | { | |
2098 | int size = 0; | |
2099 | ||
2100 | for (j = 0; j < dock_pane_count; ++j) | |
2101 | { | |
2102 | wxAuiPaneInfo& pane = *dock.panes.Item(j); | |
2103 | wxSize pane_size = pane.best_size; | |
2104 | if (pane_size == wxDefaultSize) | |
2105 | pane_size = pane.min_size; | |
2106 | if (pane_size == wxDefaultSize) | |
2107 | pane_size = pane.window->GetSize(); | |
2108 | ||
2109 | if (dock.IsHorizontal()) | |
2110 | size = wxMax(pane_size.y, size); | |
2111 | else | |
2112 | size = wxMax(pane_size.x, size); | |
2113 | } | |
2114 | ||
2115 | // add space for the border (two times), but only | |
2116 | // if at least one pane inside the dock has a pane border | |
2117 | for (j = 0; j < dock_pane_count; ++j) | |
2118 | { | |
2119 | if (dock.panes.Item(j)->HasBorder()) | |
2120 | { | |
2121 | size += (pane_border_size*2); | |
2122 | break; | |
2123 | } | |
2124 | } | |
2125 | ||
2126 | // if pane is on the top or bottom, add the caption height, | |
2127 | // but only if at least one pane inside the dock has a caption | |
2128 | if (dock.IsHorizontal()) | |
2129 | { | |
2130 | for (j = 0; j < dock_pane_count; ++j) | |
2131 | { | |
2132 | if (dock.panes.Item(j)->HasCaption()) | |
2133 | { | |
2134 | size += caption_size; | |
2135 | break; | |
2136 | } | |
2137 | } | |
2138 | } | |
2139 | ||
2140 | ||
2141 | // new dock's size may not be more than the dock constraint | |
2142 | // parameter specifies. See SetDockSizeConstraint() | |
2143 | ||
2144 | int max_dock_x_size = (int)(m_dock_constraint_x * ((double)cli_size.x)); | |
2145 | int max_dock_y_size = (int)(m_dock_constraint_y * ((double)cli_size.y)); | |
2146 | ||
2147 | if (dock.IsHorizontal()) | |
2148 | size = wxMin(size, max_dock_y_size); | |
2149 | else | |
2150 | size = wxMin(size, max_dock_x_size); | |
2151 | ||
2152 | // absolute minimum size for a dock is 10 pixels | |
2153 | if (size < 10) | |
2154 | size = 10; | |
2155 | ||
2156 | dock.size = size; | |
2157 | } | |
2158 | ||
2159 | ||
2160 | // determine the dock's minimum size | |
2161 | bool plus_border = false; | |
2162 | bool plus_caption = false; | |
2163 | int dock_min_size = 0; | |
2164 | for (j = 0; j < dock_pane_count; ++j) | |
2165 | { | |
2166 | wxAuiPaneInfo& pane = *dock.panes.Item(j); | |
2167 | if (pane.min_size != wxDefaultSize) | |
2168 | { | |
2169 | if (pane.HasBorder()) | |
2170 | plus_border = true; | |
2171 | if (pane.HasCaption()) | |
2172 | plus_caption = true; | |
2173 | if (dock.IsHorizontal()) | |
2174 | { | |
2175 | if (pane.min_size.y > dock_min_size) | |
2176 | dock_min_size = pane.min_size.y; | |
2177 | } | |
2178 | else | |
2179 | { | |
2180 | if (pane.min_size.x > dock_min_size) | |
2181 | dock_min_size = pane.min_size.x; | |
2182 | } | |
2183 | } | |
2184 | } | |
2185 | ||
2186 | if (plus_border) | |
2187 | dock_min_size += (pane_border_size*2); | |
2188 | if (plus_caption && dock.IsHorizontal()) | |
2189 | dock_min_size += (caption_size); | |
2190 | ||
2191 | dock.min_size = dock_min_size; | |
2192 | ||
2193 | ||
2194 | // if the pane's current size is less than it's | |
2195 | // minimum, increase the dock's size to it's minimum | |
2196 | if (dock.size < dock.min_size) | |
2197 | dock.size = dock.min_size; | |
2198 | ||
2199 | ||
2200 | // determine the dock's mode (fixed or proportional); | |
2201 | // determine whether the dock has only toolbars | |
2202 | bool action_pane_marked = false; | |
2203 | dock.fixed = true; | |
2204 | dock.toolbar = true; | |
2205 | for (j = 0; j < dock_pane_count; ++j) | |
2206 | { | |
2207 | wxAuiPaneInfo& pane = *dock.panes.Item(j); | |
2208 | if (!pane.IsFixed()) | |
2209 | dock.fixed = false; | |
2210 | if (!pane.IsToolbar()) | |
2211 | dock.toolbar = false; | |
2212 | if (pane.HasFlag(wxAuiPaneInfo::optionDockFixed)) | |
2213 | dock.fixed = true; | |
2214 | if (pane.state & wxAuiPaneInfo::actionPane) | |
2215 | action_pane_marked = true; | |
2216 | } | |
2217 | ||
2218 | ||
2219 | // if the dock mode is proportional and not fixed-pixel, | |
2220 | // reassign the dock_pos to the sequential 0, 1, 2, 3; | |
2221 | // e.g. remove gaps like 1, 2, 30, 500 | |
2222 | if (!dock.fixed) | |
2223 | { | |
2224 | for (j = 0; j < dock_pane_count; ++j) | |
2225 | { | |
2226 | wxAuiPaneInfo& pane = *dock.panes.Item(j); | |
2227 | pane.dock_pos = j; | |
2228 | } | |
2229 | } | |
2230 | ||
2231 | // if the dock mode is fixed, and none of the panes | |
2232 | // are being moved right now, make sure the panes | |
2233 | // do not overlap each other. If they do, we will | |
2234 | // adjust the positions of the panes | |
2235 | if (dock.fixed && !action_pane_marked) | |
2236 | { | |
2237 | wxArrayInt pane_positions, pane_sizes; | |
2238 | GetPanePositionsAndSizes(dock, pane_positions, pane_sizes); | |
2239 | ||
2240 | int offset = 0; | |
2241 | for (j = 0; j < dock_pane_count; ++j) | |
2242 | { | |
2243 | wxAuiPaneInfo& pane = *(dock.panes.Item(j)); | |
2244 | pane.dock_pos = pane_positions[j]; | |
2245 | ||
2246 | int amount = pane.dock_pos - offset; | |
2247 | if (amount >= 0) | |
2248 | offset += amount; | |
2249 | else | |
2250 | pane.dock_pos += -amount; | |
2251 | ||
2252 | offset += pane_sizes[j]; | |
2253 | } | |
2254 | } | |
2255 | } | |
2256 | ||
2257 | // discover the maximum dock layer | |
2258 | int max_layer = 0; | |
2259 | for (i = 0; i < dock_count; ++i) | |
2260 | max_layer = wxMax(max_layer, docks.Item(i).dock_layer); | |
2261 | ||
2262 | ||
2263 | // clear out uiparts | |
2264 | uiparts.Empty(); | |
2265 | ||
2266 | // create a bunch of box sizers, | |
2267 | // from the innermost level outwards. | |
2268 | wxSizer* cont = NULL; | |
2269 | wxSizer* middle = NULL; | |
2270 | int layer = 0; | |
2271 | int row, row_count; | |
2272 | ||
2273 | for (layer = 0; layer <= max_layer; ++layer) | |
2274 | { | |
2275 | wxAuiDockInfoPtrArray arr; | |
2276 | ||
2277 | // find any docks in this layer | |
2278 | FindDocks(docks, -1, layer, -1, arr); | |
2279 | ||
2280 | // if there aren't any, skip to the next layer | |
2281 | if (arr.IsEmpty()) | |
2282 | continue; | |
2283 | ||
2284 | wxSizer* old_cont = cont; | |
2285 | ||
2286 | // create a container which will hold this layer's | |
2287 | // docks (top, bottom, left, right) | |
2288 | cont = new wxBoxSizer(wxVERTICAL); | |
2289 | ||
2290 | ||
2291 | // find any top docks in this layer | |
2292 | FindDocks(docks, wxAUI_DOCK_TOP, layer, -1, arr); | |
2293 | if (!arr.IsEmpty()) | |
2294 | { | |
2295 | for (row = 0, row_count = arr.GetCount(); row < row_count; ++row) | |
2296 | LayoutAddDock(cont, *arr.Item(row), uiparts, spacer_only); | |
2297 | } | |
2298 | ||
2299 | ||
2300 | // fill out the middle layer (which consists | |
2301 | // of left docks, content area and right docks) | |
2302 | ||
2303 | middle = new wxBoxSizer(wxHORIZONTAL); | |
2304 | ||
2305 | // find any left docks in this layer | |
2306 | FindDocks(docks, wxAUI_DOCK_LEFT, layer, -1, arr); | |
2307 | if (!arr.IsEmpty()) | |
2308 | { | |
2309 | for (row = 0, row_count = arr.GetCount(); row < row_count; ++row) | |
2310 | LayoutAddDock(middle, *arr.Item(row), uiparts, spacer_only); | |
2311 | } | |
2312 | ||
2313 | // add content dock (or previous layer's sizer | |
2314 | // to the middle | |
2315 | if (!old_cont) | |
2316 | { | |
2317 | // find any center docks | |
2318 | FindDocks(docks, wxAUI_DOCK_CENTER, -1, -1, arr); | |
2319 | if (!arr.IsEmpty()) | |
2320 | { | |
2321 | for (row = 0,row_count = arr.GetCount(); row<row_count; ++row) | |
2322 | LayoutAddDock(middle, *arr.Item(row), uiparts, spacer_only); | |
2323 | } | |
2324 | else if (!m_has_maximized) | |
2325 | { | |
2326 | // there are no center docks, add a background area | |
2327 | wxSizerItem* sizer_item = middle->Add(1,1, 1, wxEXPAND); | |
2328 | wxAuiDockUIPart part; | |
2329 | part.type = wxAuiDockUIPart::typeBackground; | |
2330 | part.pane = NULL; | |
2331 | part.dock = NULL; | |
2332 | part.button = NULL; | |
2333 | part.cont_sizer = middle; | |
2334 | part.sizer_item = sizer_item; | |
2335 | uiparts.Add(part); | |
2336 | } | |
2337 | } | |
2338 | else | |
2339 | { | |
2340 | middle->Add(old_cont, 1, wxEXPAND); | |
2341 | } | |
2342 | ||
2343 | // find any right docks in this layer | |
2344 | FindDocks(docks, wxAUI_DOCK_RIGHT, layer, -1, arr); | |
2345 | if (!arr.IsEmpty()) | |
2346 | { | |
2347 | for (row = arr.GetCount()-1; row >= 0; --row) | |
2348 | LayoutAddDock(middle, *arr.Item(row), uiparts, spacer_only); | |
2349 | } | |
2350 | ||
2351 | if (middle->GetChildren().GetCount() > 0) | |
2352 | cont->Add(middle, 1, wxEXPAND); | |
2353 | else | |
2354 | delete middle; | |
2355 | ||
2356 | ||
2357 | ||
2358 | // find any bottom docks in this layer | |
2359 | FindDocks(docks, wxAUI_DOCK_BOTTOM, layer, -1, arr); | |
2360 | if (!arr.IsEmpty()) | |
2361 | { | |
2362 | for (row = arr.GetCount()-1; row >= 0; --row) | |
2363 | LayoutAddDock(cont, *arr.Item(row), uiparts, spacer_only); | |
2364 | } | |
2365 | ||
2366 | } | |
2367 | ||
2368 | if (!cont) | |
2369 | { | |
2370 | // no sizer available, because there are no docks, | |
2371 | // therefore we will create a simple background area | |
2372 | cont = new wxBoxSizer(wxVERTICAL); | |
2373 | wxSizerItem* sizer_item = cont->Add(1,1, 1, wxEXPAND); | |
2374 | wxAuiDockUIPart part; | |
2375 | part.type = wxAuiDockUIPart::typeBackground; | |
2376 | part.pane = NULL; | |
2377 | part.dock = NULL; | |
2378 | part.button = NULL; | |
2379 | part.cont_sizer = middle; | |
2380 | part.sizer_item = sizer_item; | |
2381 | uiparts.Add(part); | |
2382 | } | |
2383 | ||
2384 | container->Add(cont, 1, wxEXPAND); | |
2385 | return container; | |
2386 | } | |
2387 | ||
2388 | ||
2389 | // SetDockSizeConstraint() allows the dock constraints to be set. For example, | |
2390 | // specifying values of 0.5, 0.5 will mean that upon dock creation, a dock may | |
2391 | // not be larger than half of the window's size | |
2392 | ||
2393 | void wxAuiManager::SetDockSizeConstraint(double width_pct, double height_pct) | |
2394 | { | |
2395 | m_dock_constraint_x = wxMax(0.0, wxMin(1.0, width_pct)); | |
2396 | m_dock_constraint_y = wxMax(0.0, wxMin(1.0, height_pct)); | |
2397 | } | |
2398 | ||
2399 | void wxAuiManager::GetDockSizeConstraint(double* width_pct, double* height_pct) const | |
2400 | { | |
2401 | if (width_pct) | |
2402 | *width_pct = m_dock_constraint_x; | |
2403 | ||
2404 | if (height_pct) | |
2405 | *height_pct = m_dock_constraint_y; | |
2406 | } | |
2407 | ||
2408 | ||
2409 | ||
2410 | // Update() updates the layout. Whenever changes are made to | |
2411 | // one or more panes, this function should be called. It is the | |
2412 | // external entry point for running the layout engine. | |
2413 | ||
2414 | void wxAuiManager::Update() | |
2415 | { | |
2416 | m_hover_button = NULL; | |
2417 | m_action_part = NULL; | |
2418 | ||
2419 | wxSizer* sizer; | |
2420 | int i, pane_count = m_panes.GetCount(); | |
2421 | ||
2422 | ||
2423 | // destroy floating panes which have been | |
2424 | // redocked or are becoming non-floating | |
2425 | for (i = 0; i < pane_count; ++i) | |
2426 | { | |
2427 | wxAuiPaneInfo& p = m_panes.Item(i); | |
2428 | ||
2429 | if (!p.IsFloating() && p.frame) | |
2430 | { | |
2431 | // because the pane is no longer in a floating, we need to | |
2432 | // reparent it to m_frame and destroy the floating frame | |
2433 | ||
2434 | // reduce flicker | |
2435 | p.window->SetSize(1,1); | |
2436 | ||
2437 | ||
2438 | // the following block is a workaround for bug #1531361 | |
2439 | // (see wxWidgets sourceforge page). On wxGTK (only), when | |
2440 | // a frame is shown/hidden, a move event unfortunately | |
2441 | // also gets fired. Because we may be dragging around | |
2442 | // a pane, we need to cancel that action here to prevent | |
2443 | // a spurious crash. | |
2444 | if (m_action_window == p.frame) | |
2445 | { | |
2446 | if (wxWindow::GetCapture() == m_frame) | |
2447 | m_frame->ReleaseMouse(); | |
2448 | m_action = actionNone; | |
2449 | m_action_window = NULL; | |
2450 | } | |
2451 | ||
2452 | // hide the frame | |
2453 | if (p.frame->IsShown()) | |
2454 | p.frame->Show(false); | |
2455 | ||
2456 | // reparent to m_frame and destroy the pane | |
2457 | if (m_action_window == p.frame) | |
2458 | { | |
2459 | m_action_window = NULL; | |
2460 | } | |
2461 | ||
2462 | p.window->Reparent(m_frame); | |
2463 | p.frame->SetSizer(NULL); | |
2464 | p.frame->Destroy(); | |
2465 | p.frame = NULL; | |
2466 | } | |
2467 | } | |
2468 | ||
2469 | ||
2470 | // delete old sizer first | |
2471 | m_frame->SetSizer(NULL); | |
2472 | ||
2473 | // create a layout for all of the panes | |
2474 | sizer = LayoutAll(m_panes, m_docks, m_uiparts, false); | |
2475 | ||
2476 | // hide or show panes as necessary, | |
2477 | // and float panes as necessary | |
2478 | for (i = 0; i < pane_count; ++i) | |
2479 | { | |
2480 | wxAuiPaneInfo& p = m_panes.Item(i); | |
2481 | ||
2482 | if (p.IsFloating()) | |
2483 | { | |
2484 | if (p.frame == NULL) | |
2485 | { | |
2486 | // we need to create a frame for this | |
2487 | // pane, which has recently been floated | |
2488 | wxAuiFloatingFrame* frame = CreateFloatingFrame(m_frame, p); | |
2489 | ||
2490 | // on MSW and Mac, if the owner desires transparent dragging, and | |
2491 | // the dragging is happening right now, then the floating | |
2492 | // window should have this style by default | |
2493 | if (m_action == actionDragFloatingPane && | |
2494 | (m_flags & wxAUI_MGR_TRANSPARENT_DRAG)) | |
2495 | frame->SetTransparent(150); | |
2496 | ||
2497 | frame->SetPaneWindow(p); | |
2498 | p.frame = frame; | |
2499 | ||
2500 | if (p.IsShown() && !frame->IsShown()) | |
2501 | frame->Show(); | |
2502 | } | |
2503 | else | |
2504 | { | |
2505 | // frame already exists, make sure it's position | |
2506 | // and size reflect the information in wxAuiPaneInfo | |
2507 | if ((p.frame->GetPosition() != p.floating_pos) || (p.frame->GetSize() != p.floating_size)) | |
2508 | { | |
2509 | p.frame->SetSize(p.floating_pos.x, p.floating_pos.y, | |
2510 | p.floating_size.x, p.floating_size.y, | |
2511 | wxSIZE_USE_EXISTING); | |
2512 | /* | |
2513 | p.frame->SetSize(p.floating_pos.x, p.floating_pos.y, | |
2514 | wxDefaultCoord, wxDefaultCoord, | |
2515 | wxSIZE_USE_EXISTING); | |
2516 | //p.frame->Move(p.floating_pos.x, p.floating_pos.y); | |
2517 | */ | |
2518 | } | |
2519 | ||
2520 | if (p.frame->IsShown() != p.IsShown()) | |
2521 | p.frame->Show(p.IsShown()); | |
2522 | } | |
2523 | } | |
2524 | else | |
2525 | { | |
2526 | if (p.window->IsShown() != p.IsShown()) | |
2527 | p.window->Show(p.IsShown()); | |
2528 | } | |
2529 | ||
2530 | // if "active panes" are no longer allowed, clear | |
2531 | // any optionActive values from the pane states | |
2532 | if ((m_flags & wxAUI_MGR_ALLOW_ACTIVE_PANE) == 0) | |
2533 | { | |
2534 | p.state &= ~wxAuiPaneInfo::optionActive; | |
2535 | } | |
2536 | } | |
2537 | ||
2538 | ||
2539 | // keep track of the old window rectangles so we can | |
2540 | // refresh those windows whose rect has changed | |
2541 | wxAuiRectArray old_pane_rects; | |
2542 | for (i = 0; i < pane_count; ++i) | |
2543 | { | |
2544 | wxRect r; | |
2545 | wxAuiPaneInfo& p = m_panes.Item(i); | |
2546 | ||
2547 | if (p.window && p.IsShown() && p.IsDocked()) | |
2548 | r = p.rect; | |
2549 | ||
2550 | old_pane_rects.Add(r); | |
2551 | } | |
2552 | ||
2553 | ||
2554 | ||
2555 | ||
2556 | // apply the new sizer | |
2557 | m_frame->SetSizer(sizer); | |
2558 | m_frame->SetAutoLayout(false); | |
2559 | DoFrameLayout(); | |
2560 | ||
2561 | ||
2562 | ||
2563 | // now that the frame layout is done, we need to check | |
2564 | // the new pane rectangles against the old rectangles that | |
2565 | // we saved a few lines above here. If the rectangles have | |
2566 | // changed, the corresponding panes must also be updated | |
2567 | for (i = 0; i < pane_count; ++i) | |
2568 | { | |
2569 | wxAuiPaneInfo& p = m_panes.Item(i); | |
2570 | if (p.window && p.window->IsShown() && p.IsDocked()) | |
2571 | { | |
2572 | if (p.rect != old_pane_rects[i]) | |
2573 | { | |
2574 | p.window->Refresh(); | |
2575 | p.window->Update(); | |
2576 | } | |
2577 | } | |
2578 | } | |
2579 | ||
2580 | ||
2581 | Repaint(); | |
2582 | ||
2583 | // set frame's minimum size | |
2584 | ||
2585 | /* | |
2586 | // N.B. More work needs to be done on frame minimum sizes; | |
2587 | // this is some intresting code that imposes the minimum size, | |
2588 | // but we may want to include a more flexible mechanism or | |
2589 | // options for multiple minimum-size modes, e.g. strict or lax | |
2590 | wxSize min_size = sizer->GetMinSize(); | |
2591 | wxSize frame_size = m_frame->GetSize(); | |
2592 | wxSize client_size = m_frame->GetClientSize(); | |
2593 | ||
2594 | wxSize minframe_size(min_size.x+frame_size.x-client_size.x, | |
2595 | min_size.y+frame_size.y-client_size.y ); | |
2596 | ||
2597 | m_frame->SetMinSize(minframe_size); | |
2598 | ||
2599 | if (frame_size.x < minframe_size.x || | |
2600 | frame_size.y < minframe_size.y) | |
2601 | sizer->Fit(m_frame); | |
2602 | */ | |
2603 | } | |
2604 | ||
2605 | ||
2606 | // DoFrameLayout() is an internal function which invokes wxSizer::Layout | |
2607 | // on the frame's main sizer, then measures all the various UI items | |
2608 | // and updates their internal rectangles. This should always be called | |
2609 | // instead of calling m_frame->Layout() directly | |
2610 | ||
2611 | void wxAuiManager::DoFrameLayout() | |
2612 | { | |
2613 | m_frame->Layout(); | |
2614 | ||
2615 | int i, part_count; | |
2616 | for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i) | |
2617 | { | |
2618 | wxAuiDockUIPart& part = m_uiparts.Item(i); | |
2619 | ||
2620 | // get the rectangle of the UI part | |
2621 | // originally, this code looked like this: | |
2622 | // part.rect = wxRect(part.sizer_item->GetPosition(), | |
2623 | // part.sizer_item->GetSize()); | |
2624 | // this worked quite well, with one exception: the mdi | |
2625 | // client window had a "deferred" size variable | |
2626 | // that returned the wrong size. It looks like | |
2627 | // a bug in wx, because the former size of the window | |
2628 | // was being returned. So, we will retrieve the part's | |
2629 | // rectangle via other means | |
2630 | ||
2631 | ||
2632 | part.rect = part.sizer_item->GetRect(); | |
2633 | int flag = part.sizer_item->GetFlag(); | |
2634 | int border = part.sizer_item->GetBorder(); | |
2635 | if (flag & wxTOP) | |
2636 | { | |
2637 | part.rect.y -= border; | |
2638 | part.rect.height += border; | |
2639 | } | |
2640 | if (flag & wxLEFT) | |
2641 | { | |
2642 | part.rect.x -= border; | |
2643 | part.rect.width += border; | |
2644 | } | |
2645 | if (flag & wxBOTTOM) | |
2646 | part.rect.height += border; | |
2647 | if (flag & wxRIGHT) | |
2648 | part.rect.width += border; | |
2649 | ||
2650 | ||
2651 | if (part.type == wxAuiDockUIPart::typeDock) | |
2652 | part.dock->rect = part.rect; | |
2653 | if (part.type == wxAuiDockUIPart::typePane) | |
2654 | part.pane->rect = part.rect; | |
2655 | } | |
2656 | } | |
2657 | ||
2658 | // GetPanePart() looks up the pane the pane border UI part (or the regular | |
2659 | // pane part if there is no border). This allows the caller to get the exact | |
2660 | // rectangle of the pane in question, including decorations like | |
2661 | // caption and border (if any). | |
2662 | ||
2663 | wxAuiDockUIPart* wxAuiManager::GetPanePart(wxWindow* wnd) | |
2664 | { | |
2665 | int i, part_count; | |
2666 | for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i) | |
2667 | { | |
2668 | wxAuiDockUIPart& part = m_uiparts.Item(i); | |
2669 | if (part.type == wxAuiDockUIPart::typePaneBorder && | |
2670 | part.pane && part.pane->window == wnd) | |
2671 | return ∂ | |
2672 | } | |
2673 | for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i) | |
2674 | { | |
2675 | wxAuiDockUIPart& part = m_uiparts.Item(i); | |
2676 | if (part.type == wxAuiDockUIPart::typePane && | |
2677 | part.pane && part.pane->window == wnd) | |
2678 | return ∂ | |
2679 | } | |
2680 | return NULL; | |
2681 | } | |
2682 | ||
2683 | ||
2684 | ||
2685 | // GetDockPixelOffset() is an internal function which returns | |
2686 | // a dock's offset in pixels from the left side of the window | |
2687 | // (for horizontal docks) or from the top of the window (for | |
2688 | // vertical docks). This value is necessary for calculating | |
2689 | // fixel-pane/toolbar offsets when they are dragged. | |
2690 | ||
2691 | int wxAuiManager::GetDockPixelOffset(wxAuiPaneInfo& test) | |
2692 | { | |
2693 | // the only way to accurately calculate the dock's | |
2694 | // offset is to actually run a theoretical layout | |
2695 | ||
2696 | int i, part_count, dock_count; | |
2697 | wxAuiDockInfoArray docks; | |
2698 | wxAuiPaneInfoArray panes; | |
2699 | wxAuiDockUIPartArray uiparts; | |
2700 | CopyDocksAndPanes(docks, panes, m_docks, m_panes); | |
2701 | panes.Add(test); | |
2702 | ||
2703 | wxSizer* sizer = LayoutAll(panes, docks, uiparts, true); | |
2704 | wxSize client_size = m_frame->GetClientSize(); | |
2705 | sizer->SetDimension(0, 0, client_size.x, client_size.y); | |
2706 | sizer->Layout(); | |
2707 | ||
2708 | for (i = 0, part_count = uiparts.GetCount(); i < part_count; ++i) | |
2709 | { | |
2710 | wxAuiDockUIPart& part = uiparts.Item(i); | |
2711 | part.rect = wxRect(part.sizer_item->GetPosition(), | |
2712 | part.sizer_item->GetSize()); | |
2713 | if (part.type == wxAuiDockUIPart::typeDock) | |
2714 | part.dock->rect = part.rect; | |
2715 | } | |
2716 | ||
2717 | delete sizer; | |
2718 | ||
2719 | for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i) | |
2720 | { | |
2721 | wxAuiDockInfo& dock = docks.Item(i); | |
2722 | if (test.dock_direction == dock.dock_direction && | |
2723 | test.dock_layer==dock.dock_layer && test.dock_row==dock.dock_row) | |
2724 | { | |
2725 | if (dock.IsVertical()) | |
2726 | return dock.rect.y; | |
2727 | else | |
2728 | return dock.rect.x; | |
2729 | } | |
2730 | } | |
2731 | ||
2732 | return 0; | |
2733 | } | |
2734 | ||
2735 | ||
2736 | ||
2737 | // ProcessDockResult() is a utility function used by DoDrop() - it checks | |
2738 | // if a dock operation is allowed, the new dock position is copied into | |
2739 | // the target info. If the operation was allowed, the function returns true. | |
2740 | ||
2741 | bool wxAuiManager::ProcessDockResult(wxAuiPaneInfo& target, | |
2742 | const wxAuiPaneInfo& new_pos) | |
2743 | { | |
2744 | bool allowed = false; | |
2745 | switch (new_pos.dock_direction) | |
2746 | { | |
2747 | case wxAUI_DOCK_TOP: allowed = target.IsTopDockable(); break; | |
2748 | case wxAUI_DOCK_BOTTOM: allowed = target.IsBottomDockable(); break; | |
2749 | case wxAUI_DOCK_LEFT: allowed = target.IsLeftDockable(); break; | |
2750 | case wxAUI_DOCK_RIGHT: allowed = target.IsRightDockable(); break; | |
2751 | } | |
2752 | ||
2753 | if (allowed) | |
2754 | target = new_pos; | |
2755 | ||
2756 | return allowed; | |
2757 | } | |
2758 | ||
2759 | ||
2760 | // DoDrop() is an important function. It basically takes a mouse position, | |
2761 | // and determines where the pane's new position would be. If the pane is to be | |
2762 | // dropped, it performs the drop operation using the specified dock and pane | |
2763 | // arrays. By specifying copied dock and pane arrays when calling, a "what-if" | |
2764 | // scenario can be performed, giving precise coordinates for drop hints. | |
2765 | // If, however, wxAuiManager:m_docks and wxAuiManager::m_panes are specified | |
2766 | // as parameters, the changes will be made to the main state arrays | |
2767 | ||
2768 | const int auiInsertRowPixels = 10; | |
2769 | const int auiNewRowPixels = 40; | |
2770 | const int auiLayerInsertPixels = 40; | |
2771 | const int auiLayerInsertOffset = 5; | |
2772 | ||
2773 | bool wxAuiManager::DoDrop(wxAuiDockInfoArray& docks, | |
2774 | wxAuiPaneInfoArray& panes, | |
2775 | wxAuiPaneInfo& target, | |
2776 | const wxPoint& pt, | |
2777 | const wxPoint& offset) | |
2778 | { | |
2779 | wxSize cli_size = m_frame->GetClientSize(); | |
2780 | ||
2781 | wxAuiPaneInfo drop = target; | |
2782 | ||
2783 | ||
2784 | // The result should always be shown | |
2785 | drop.Show(); | |
2786 | ||
2787 | ||
2788 | // Check to see if the pane has been dragged outside of the window | |
2789 | // (or near to the outside of the window), if so, dock it along the edge | |
2790 | ||
2791 | ||
2792 | int layer_insert_offset = auiLayerInsertOffset; | |
2793 | if (drop.IsToolbar()) | |
2794 | layer_insert_offset = 0; | |
2795 | ||
2796 | ||
2797 | if (pt.x < layer_insert_offset && | |
2798 | pt.x > layer_insert_offset-auiLayerInsertPixels) | |
2799 | { | |
2800 | int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_LEFT), | |
2801 | GetMaxLayer(docks, wxAUI_DOCK_BOTTOM)), | |
2802 | GetMaxLayer(docks, wxAUI_DOCK_TOP)) + 1; | |
2803 | ||
2804 | if (drop.IsToolbar()) | |
2805 | new_layer = auiToolBarLayer; | |
2806 | ||
2807 | drop.Dock().Left(). | |
2808 | Layer(new_layer). | |
2809 | Row(0). | |
2810 | Position(pt.y - GetDockPixelOffset(drop) - offset.y); | |
2811 | return ProcessDockResult(target, drop); | |
2812 | } | |
2813 | else if (pt.y < layer_insert_offset && | |
2814 | pt.y > layer_insert_offset-auiLayerInsertPixels) | |
2815 | { | |
2816 | int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_TOP), | |
2817 | GetMaxLayer(docks, wxAUI_DOCK_LEFT)), | |
2818 | GetMaxLayer(docks, wxAUI_DOCK_RIGHT)) + 1; | |
2819 | ||
2820 | if (drop.IsToolbar()) | |
2821 | new_layer = auiToolBarLayer; | |
2822 | ||
2823 | drop.Dock().Top(). | |
2824 | Layer(new_layer). | |
2825 | Row(0). | |
2826 | Position(pt.x - GetDockPixelOffset(drop) - offset.x); | |
2827 | return ProcessDockResult(target, drop); | |
2828 | } | |
2829 | else if (pt.x >= cli_size.x - layer_insert_offset && | |
2830 | pt.x < cli_size.x - layer_insert_offset + auiLayerInsertPixels) | |
2831 | { | |
2832 | int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_RIGHT), | |
2833 | GetMaxLayer(docks, wxAUI_DOCK_TOP)), | |
2834 | GetMaxLayer(docks, wxAUI_DOCK_BOTTOM)) + 1; | |
2835 | ||
2836 | if (drop.IsToolbar()) | |
2837 | new_layer = auiToolBarLayer; | |
2838 | ||
2839 | drop.Dock().Right(). | |
2840 | Layer(new_layer). | |
2841 | Row(0). | |
2842 | Position(pt.y - GetDockPixelOffset(drop) - offset.y); | |
2843 | return ProcessDockResult(target, drop); | |
2844 | } | |
2845 | else if (pt.y >= cli_size.y - layer_insert_offset && | |
2846 | pt.y < cli_size.y - layer_insert_offset + auiLayerInsertPixels) | |
2847 | { | |
2848 | int new_layer = wxMax( wxMax( GetMaxLayer(docks, wxAUI_DOCK_BOTTOM), | |
2849 | GetMaxLayer(docks, wxAUI_DOCK_LEFT)), | |
2850 | GetMaxLayer(docks, wxAUI_DOCK_RIGHT)) + 1; | |
2851 | ||
2852 | if (drop.IsToolbar()) | |
2853 | new_layer = auiToolBarLayer; | |
2854 | ||
2855 | drop.Dock().Bottom(). | |
2856 | Layer(new_layer). | |
2857 | Row(0). | |
2858 | Position(pt.x - GetDockPixelOffset(drop) - offset.x); | |
2859 | return ProcessDockResult(target, drop); | |
2860 | } | |
2861 | ||
2862 | ||
2863 | wxAuiDockUIPart* part = HitTest(pt.x, pt.y); | |
2864 | ||
2865 | ||
2866 | if (drop.IsToolbar()) | |
2867 | { | |
2868 | if (!part || !part->dock) | |
2869 | return false; | |
2870 | ||
2871 | // calculate the offset from where the dock begins | |
2872 | // to the point where the user dropped the pane | |
2873 | int dock_drop_offset = 0; | |
2874 | if (part->dock->IsHorizontal()) | |
2875 | dock_drop_offset = pt.x - part->dock->rect.x - offset.x; | |
2876 | else | |
2877 | dock_drop_offset = pt.y - part->dock->rect.y - offset.y; | |
2878 | ||
2879 | ||
2880 | // toolbars may only be moved in and to fixed-pane docks, | |
2881 | // otherwise we will try to float the pane. Also, the pane | |
2882 | // should float if being dragged over center pane windows | |
2883 | if (!part->dock->fixed || part->dock->dock_direction == wxAUI_DOCK_CENTER) | |
2884 | { | |
2885 | if (m_last_rect.IsEmpty() || m_last_rect.Contains(pt.x, pt.y )) | |
2886 | { | |
2887 | m_skipping = true; | |
2888 | } | |
2889 | else | |
2890 | { | |
2891 | if ((m_flags & wxAUI_MGR_ALLOW_FLOATING) && | |
2892 | (drop.IsFloatable() || | |
2893 | (part->dock->dock_direction != wxAUI_DOCK_CENTER && | |
2894 | part->dock->dock_direction != wxAUI_DOCK_NONE))) | |
2895 | { | |
2896 | if (drop.IsFloatable()) | |
2897 | drop.Float(); | |
2898 | } | |
2899 | ||
2900 | m_skipping = false; | |
2901 | ||
2902 | return ProcessDockResult(target, drop); | |
2903 | } | |
2904 | ||
2905 | drop.Position(pt.x - GetDockPixelOffset(drop) - offset.x); | |
2906 | ||
2907 | return ProcessDockResult(target, drop); | |
2908 | } | |
2909 | ||
2910 | m_skipping = false; | |
2911 | ||
2912 | m_last_rect = part->dock->rect; | |
2913 | m_last_rect.Inflate( 15, 15 ); | |
2914 | ||
2915 | drop.Dock(). | |
2916 | Direction(part->dock->dock_direction). | |
2917 | Layer(part->dock->dock_layer). | |
2918 | Row(part->dock->dock_row). | |
2919 | Position(dock_drop_offset); | |
2920 | ||
2921 | if (( | |
2922 | ((pt.y < part->dock->rect.y + 1) && part->dock->IsHorizontal()) || | |
2923 | ((pt.x < part->dock->rect.x + 1) && part->dock->IsVertical()) | |
2924 | ) && part->dock->panes.GetCount() > 1) | |
2925 | { | |
2926 | if ((part->dock->dock_direction == wxAUI_DOCK_TOP) || | |
2927 | (part->dock->dock_direction == wxAUI_DOCK_LEFT)) | |
2928 | { | |
2929 | int row = drop.dock_row; | |
2930 | DoInsertDockRow(panes, part->dock->dock_direction, | |
2931 | part->dock->dock_layer, | |
2932 | part->dock->dock_row); | |
2933 | drop.dock_row = row; | |
2934 | } | |
2935 | else | |
2936 | { | |
2937 | DoInsertDockRow(panes, part->dock->dock_direction, | |
2938 | part->dock->dock_layer, | |
2939 | part->dock->dock_row+1); | |
2940 | drop.dock_row = part->dock->dock_row+1; | |
2941 | } | |
2942 | } | |
2943 | ||
2944 | if (( | |
2945 | ((pt.y > part->dock->rect.y + part->dock->rect.height - 2 ) && part->dock->IsHorizontal()) || | |
2946 | ((pt.x > part->dock->rect.x + part->dock->rect.width - 2 ) && part->dock->IsVertical()) | |
2947 | ) && part->dock->panes.GetCount() > 1) | |
2948 | { | |
2949 | if ((part->dock->dock_direction == wxAUI_DOCK_TOP) || | |
2950 | (part->dock->dock_direction == wxAUI_DOCK_LEFT)) | |
2951 | { | |
2952 | DoInsertDockRow(panes, part->dock->dock_direction, | |
2953 | part->dock->dock_layer, | |
2954 | part->dock->dock_row+1); | |
2955 | drop.dock_row = part->dock->dock_row+1; | |
2956 | } | |
2957 | else | |
2958 | { | |
2959 | int row = drop.dock_row; | |
2960 | DoInsertDockRow(panes, part->dock->dock_direction, | |
2961 | part->dock->dock_layer, | |
2962 | part->dock->dock_row); | |
2963 | drop.dock_row = row; | |
2964 | } | |
2965 | } | |
2966 | ||
2967 | return ProcessDockResult(target, drop); | |
2968 | } | |
2969 | ||
2970 | ||
2971 | ||
2972 | ||
2973 | if (!part) | |
2974 | return false; | |
2975 | ||
2976 | if (part->type == wxAuiDockUIPart::typePaneBorder || | |
2977 | part->type == wxAuiDockUIPart::typeCaption || | |
2978 | part->type == wxAuiDockUIPart::typeGripper || | |
2979 | part->type == wxAuiDockUIPart::typePaneButton || | |
2980 | part->type == wxAuiDockUIPart::typePane || | |
2981 | part->type == wxAuiDockUIPart::typePaneSizer || | |
2982 | part->type == wxAuiDockUIPart::typeDockSizer || | |
2983 | part->type == wxAuiDockUIPart::typeBackground) | |
2984 | { | |
2985 | if (part->type == wxAuiDockUIPart::typeDockSizer) | |
2986 | { | |
2987 | if (part->dock->panes.GetCount() != 1) | |
2988 | return false; | |
2989 | part = GetPanePart(part->dock->panes.Item(0)->window); | |
2990 | if (!part) | |
2991 | return false; | |
2992 | } | |
2993 | ||
2994 | ||
2995 | ||
2996 | // If a normal frame is being dragged over a toolbar, insert it | |
2997 | // along the edge under the toolbar, but over all other panes. | |
2998 | // (this could be done much better, but somehow factoring this | |
2999 | // calculation with the one at the beginning of this function) | |
3000 | if (part->dock && part->dock->toolbar) | |
3001 | { | |
3002 | int layer = 0; | |
3003 | ||
3004 | switch (part->dock->dock_direction) | |
3005 | { | |
3006 | case wxAUI_DOCK_LEFT: | |
3007 | layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_LEFT), | |
3008 | GetMaxLayer(docks, wxAUI_DOCK_BOTTOM)), | |
3009 | GetMaxLayer(docks, wxAUI_DOCK_TOP)); | |
3010 | break; | |
3011 | case wxAUI_DOCK_TOP: | |
3012 | layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_TOP), | |
3013 | GetMaxLayer(docks, wxAUI_DOCK_LEFT)), | |
3014 | GetMaxLayer(docks, wxAUI_DOCK_RIGHT)); | |
3015 | break; | |
3016 | case wxAUI_DOCK_RIGHT: | |
3017 | layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_RIGHT), | |
3018 | GetMaxLayer(docks, wxAUI_DOCK_TOP)), | |
3019 | GetMaxLayer(docks, wxAUI_DOCK_BOTTOM)); | |
3020 | break; | |
3021 | case wxAUI_DOCK_BOTTOM: | |
3022 | layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_BOTTOM), | |
3023 | GetMaxLayer(docks, wxAUI_DOCK_LEFT)), | |
3024 | GetMaxLayer(docks, wxAUI_DOCK_RIGHT)); | |
3025 | break; | |
3026 | } | |
3027 | ||
3028 | DoInsertDockRow(panes, part->dock->dock_direction, | |
3029 | layer, 0); | |
3030 | drop.Dock(). | |
3031 | Direction(part->dock->dock_direction). | |
3032 | Layer(layer).Row(0).Position(0); | |
3033 | return ProcessDockResult(target, drop); | |
3034 | } | |
3035 | ||
3036 | ||
3037 | if (!part->pane) | |
3038 | return false; | |
3039 | ||
3040 | part = GetPanePart(part->pane->window); | |
3041 | if (!part) | |
3042 | return false; | |
3043 | ||
3044 | bool insert_dock_row = false; | |
3045 | int insert_row = part->pane->dock_row; | |
3046 | int insert_dir = part->pane->dock_direction; | |
3047 | int insert_layer = part->pane->dock_layer; | |
3048 | ||
3049 | switch (part->pane->dock_direction) | |
3050 | { | |
3051 | case wxAUI_DOCK_TOP: | |
3052 | if (pt.y >= part->rect.y && | |
3053 | pt.y < part->rect.y+auiInsertRowPixels) | |
3054 | insert_dock_row = true; | |
3055 | break; | |
3056 | case wxAUI_DOCK_BOTTOM: | |
3057 | if (pt.y > part->rect.y+part->rect.height-auiInsertRowPixels && | |
3058 | pt.y <= part->rect.y + part->rect.height) | |
3059 | insert_dock_row = true; | |
3060 | break; | |
3061 | case wxAUI_DOCK_LEFT: | |
3062 | if (pt.x >= part->rect.x && | |
3063 | pt.x < part->rect.x+auiInsertRowPixels) | |
3064 | insert_dock_row = true; | |
3065 | break; | |
3066 | case wxAUI_DOCK_RIGHT: | |
3067 | if (pt.x > part->rect.x+part->rect.width-auiInsertRowPixels && | |
3068 | pt.x <= part->rect.x+part->rect.width) | |
3069 | insert_dock_row = true; | |
3070 | break; | |
3071 | case wxAUI_DOCK_CENTER: | |
3072 | { | |
3073 | // "new row pixels" will be set to the default, but | |
3074 | // must never exceed 20% of the window size | |
3075 | int new_row_pixels_x = auiNewRowPixels; | |
3076 | int new_row_pixels_y = auiNewRowPixels; | |
3077 | ||
3078 | if (new_row_pixels_x > (part->rect.width*20)/100) | |
3079 | new_row_pixels_x = (part->rect.width*20)/100; | |
3080 | ||
3081 | if (new_row_pixels_y > (part->rect.height*20)/100) | |
3082 | new_row_pixels_y = (part->rect.height*20)/100; | |
3083 | ||
3084 | ||
3085 | // determine if the mouse pointer is in a location that | |
3086 | // will cause a new row to be inserted. The hot spot positions | |
3087 | // are along the borders of the center pane | |
3088 | ||
3089 | insert_layer = 0; | |
3090 | insert_dock_row = true; | |
3091 | const wxRect& pr = part->rect; | |
3092 | if (pt.x >= pr.x && pt.x < pr.x + new_row_pixels_x) | |
3093 | insert_dir = wxAUI_DOCK_LEFT; | |
3094 | else if (pt.y >= pr.y && pt.y < pr.y + new_row_pixels_y) | |
3095 | insert_dir = wxAUI_DOCK_TOP; | |
3096 | else if (pt.x >= pr.x + pr.width - new_row_pixels_x && | |
3097 | pt.x < pr.x + pr.width) | |
3098 | insert_dir = wxAUI_DOCK_RIGHT; | |
3099 | else if (pt.y >= pr.y+ pr.height - new_row_pixels_y && | |
3100 | pt.y < pr.y + pr.height) | |
3101 | insert_dir = wxAUI_DOCK_BOTTOM; | |
3102 | else | |
3103 | return false; | |
3104 | ||
3105 | insert_row = GetMaxRow(panes, insert_dir, insert_layer) + 1; | |
3106 | } | |
3107 | } | |
3108 | ||
3109 | if (insert_dock_row) | |
3110 | { | |
3111 | DoInsertDockRow(panes, insert_dir, insert_layer, insert_row); | |
3112 | drop.Dock().Direction(insert_dir). | |
3113 | Layer(insert_layer). | |
3114 | Row(insert_row). | |
3115 | Position(0); | |
3116 | return ProcessDockResult(target, drop); | |
3117 | } | |
3118 | ||
3119 | // determine the mouse offset and the pane size, both in the | |
3120 | // direction of the dock itself, and perpendicular to the dock | |
3121 | ||
3122 | int offset, size; | |
3123 | ||
3124 | if (part->orientation == wxVERTICAL) | |
3125 | { | |
3126 | offset = pt.y - part->rect.y; | |
3127 | size = part->rect.GetHeight(); | |
3128 | } | |
3129 | else | |
3130 | { | |
3131 | offset = pt.x - part->rect.x; | |
3132 | size = part->rect.GetWidth(); | |
3133 | } | |
3134 | ||
3135 | int drop_position = part->pane->dock_pos; | |
3136 | ||
3137 | // if we are in the top/left part of the pane, | |
3138 | // insert the pane before the pane being hovered over | |
3139 | if (offset <= size/2) | |
3140 | { | |
3141 | drop_position = part->pane->dock_pos; | |
3142 | DoInsertPane(panes, | |
3143 | part->pane->dock_direction, | |
3144 | part->pane->dock_layer, | |
3145 | part->pane->dock_row, | |
3146 | part->pane->dock_pos); | |
3147 | } | |
3148 | ||
3149 | // if we are in the bottom/right part of the pane, | |
3150 | // insert the pane before the pane being hovered over | |
3151 | if (offset > size/2) | |
3152 | { | |
3153 | drop_position = part->pane->dock_pos+1; | |
3154 | DoInsertPane(panes, | |
3155 | part->pane->dock_direction, | |
3156 | part->pane->dock_layer, | |
3157 | part->pane->dock_row, | |
3158 | part->pane->dock_pos+1); | |
3159 | } | |
3160 | ||
3161 | drop.Dock(). | |
3162 | Direction(part->dock->dock_direction). | |
3163 | Layer(part->dock->dock_layer). | |
3164 | Row(part->dock->dock_row). | |
3165 | Position(drop_position); | |
3166 | return ProcessDockResult(target, drop); | |
3167 | } | |
3168 | ||
3169 | return false; | |
3170 | } | |
3171 | ||
3172 | ||
3173 | void wxAuiManager::OnHintFadeTimer(wxTimerEvent& WXUNUSED(event)) | |
3174 | { | |
3175 | if (!m_hint_wnd || m_hint_fadeamt >= m_hint_fademax) | |
3176 | { | |
3177 | m_hint_fadetimer.Stop(); | |
3178 | return; | |
3179 | } | |
3180 | ||
3181 | m_hint_fadeamt += 4; | |
3182 | m_hint_wnd->SetTransparent(m_hint_fadeamt); | |
3183 | } | |
3184 | ||
3185 | void wxAuiManager::ShowHint(const wxRect& rect) | |
3186 | { | |
3187 | if (m_hint_wnd) | |
3188 | { | |
3189 | // if the hint rect is the same as last time, don't do anything | |
3190 | if (m_last_hint == rect) | |
3191 | return; | |
3192 | m_last_hint = rect; | |
3193 | ||
3194 | m_hint_fadeamt = m_hint_fademax; | |
3195 | ||
3196 | if ((m_flags & wxAUI_MGR_HINT_FADE) | |
3197 | && !((m_hint_wnd->IsKindOf(CLASSINFO(wxPseudoTransparentFrame))) && | |
3198 | (m_flags & wxAUI_MGR_NO_VENETIAN_BLINDS_FADE)) | |
3199 | ) | |
3200 | m_hint_fadeamt = 0; | |
3201 | ||
3202 | m_hint_wnd->SetSize(rect); | |
3203 | m_hint_wnd->SetTransparent(m_hint_fadeamt); | |
3204 | ||
3205 | if (!m_hint_wnd->IsShown()) | |
3206 | m_hint_wnd->Show(); | |
3207 | ||
3208 | // if we are dragging a floating pane, set the focus | |
3209 | // back to that floating pane (otherwise it becomes unfocused) | |
3210 | if (m_action == actionDragFloatingPane && m_action_window) | |
3211 | m_action_window->SetFocus(); | |
3212 | ||
3213 | m_hint_wnd->Raise(); | |
3214 | ||
3215 | ||
3216 | if (m_hint_fadeamt != m_hint_fademax) // Only fade if we need to | |
3217 | { | |
3218 | // start fade in timer | |
3219 | m_hint_fadetimer.SetOwner(this, 101); | |
3220 | m_hint_fadetimer.Start(5); | |
3221 | } | |
3222 | } | |
3223 | else // Not using a transparent hint window... | |
3224 | { | |
3225 | if (!(m_flags & wxAUI_MGR_RECTANGLE_HINT)) | |
3226 | return; | |
3227 | ||
3228 | if (m_last_hint != rect) | |
3229 | { | |
3230 | // remove the last hint rectangle | |
3231 | m_last_hint = rect; | |
3232 | m_frame->Refresh(); | |
3233 | m_frame->Update(); | |
3234 | } | |
3235 | ||
3236 | wxScreenDC screendc; | |
3237 | wxRegion clip(1, 1, 10000, 10000); | |
3238 | ||
3239 | // clip all floating windows, so we don't draw over them | |
3240 | int i, pane_count; | |
3241 | for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i) | |
3242 | { | |
3243 | wxAuiPaneInfo& pane = m_panes.Item(i); | |
3244 | ||
3245 | if (pane.IsFloating() && | |
3246 | pane.frame->IsShown()) | |
3247 | { | |
3248 | wxRect rect = pane.frame->GetRect(); | |
3249 | #ifdef __WXGTK__ | |
3250 | // wxGTK returns the client size, not the whole frame size | |
3251 | rect.width += 15; | |
3252 | rect.height += 35; | |
3253 | rect.Inflate(5); | |
3254 | #endif | |
3255 | ||
3256 | clip.Subtract(rect); | |
3257 | } | |
3258 | } | |
3259 | ||
3260 | // As we can only hide the hint by redrawing the managed window, we | |
3261 | // need to clip the region to the managed window too or we get | |
3262 | // nasty redrawn problems. | |
3263 | clip.Intersect(m_frame->GetRect()); | |
3264 | ||
3265 | screendc.SetDeviceClippingRegion(clip); | |
3266 | ||
3267 | wxBitmap stipple = wxPaneCreateStippleBitmap(); | |
3268 | wxBrush brush(stipple); | |
3269 | screendc.SetBrush(brush); | |
3270 | screendc.SetPen(*wxTRANSPARENT_PEN); | |
3271 | ||
3272 | screendc.DrawRectangle(rect.x, rect.y, 5, rect.height); | |
3273 | screendc.DrawRectangle(rect.x+5, rect.y, rect.width-10, 5); | |
3274 | screendc.DrawRectangle(rect.x+rect.width-5, rect.y, 5, rect.height); | |
3275 | screendc.DrawRectangle(rect.x+5, rect.y+rect.height-5, rect.width-10, 5); | |
3276 | } | |
3277 | } | |
3278 | ||
3279 | void wxAuiManager::HideHint() | |
3280 | { | |
3281 | // hides a transparent window hint, if there is one | |
3282 | if (m_hint_wnd) | |
3283 | { | |
3284 | if (m_hint_wnd->IsShown()) | |
3285 | m_hint_wnd->Show(false); | |
3286 | m_hint_wnd->SetTransparent(0); | |
3287 | m_hint_fadetimer.Stop(); | |
3288 | m_last_hint = wxRect(); | |
3289 | return; | |
3290 | } | |
3291 | ||
3292 | // hides a painted hint by redrawing the frame window | |
3293 | if (!m_last_hint.IsEmpty()) | |
3294 | { | |
3295 | m_frame->Refresh(); | |
3296 | m_frame->Update(); | |
3297 | m_last_hint = wxRect(); | |
3298 | } | |
3299 | } | |
3300 | ||
3301 | ||
3302 | ||
3303 | void wxAuiManager::StartPaneDrag(wxWindow* pane_window, | |
3304 | const wxPoint& offset) | |
3305 | { | |
3306 | wxAuiPaneInfo& pane = GetPane(pane_window); | |
3307 | if (!pane.IsOk()) | |
3308 | return; | |
3309 | ||
3310 | if (pane.IsToolbar()) | |
3311 | { | |
3312 | m_action = actionDragToolbarPane; | |
3313 | } | |
3314 | else | |
3315 | { | |
3316 | m_action = actionDragFloatingPane; | |
3317 | } | |
3318 | ||
3319 | m_action_window = pane_window; | |
3320 | m_action_offset = offset; | |
3321 | m_frame->CaptureMouse(); | |
3322 | } | |
3323 | ||
3324 | ||
3325 | // CalculateHintRect() calculates the drop hint rectangle. The method | |
3326 | // first calls DoDrop() to determine the exact position the pane would | |
3327 | // be at were if dropped. If the pane would indeed become docked at the | |
3328 | // specified drop point, the the rectangle hint will be returned in | |
3329 | // screen coordinates. Otherwise, an empty rectangle is returned. | |
3330 | // |pane_window| is the window pointer of the pane being dragged, |pt| is | |
3331 | // the mouse position, in client coordinates. |offset| describes the offset | |
3332 | // that the mouse is from the upper-left corner of the item being dragged | |
3333 | ||
3334 | wxRect wxAuiManager::CalculateHintRect(wxWindow* pane_window, | |
3335 | const wxPoint& pt, | |
3336 | const wxPoint& offset) | |
3337 | { | |
3338 | wxRect rect; | |
3339 | ||
3340 | // we need to paint a hint rectangle; to find out the exact hint rectangle, | |
3341 | // we will create a new temporary layout and then measure the resulting | |
3342 | // rectangle; we will create a copy of the docking structures (m_dock) | |
3343 | // so that we don't modify the real thing on screen | |
3344 | ||
3345 | int i, pane_count, part_count; | |
3346 | wxAuiDockInfoArray docks; | |
3347 | wxAuiPaneInfoArray panes; | |
3348 | wxAuiDockUIPartArray uiparts; | |
3349 | wxAuiPaneInfo hint = GetPane(pane_window); | |
3350 | hint.name = wxT("__HINT__"); | |
3351 | hint.PaneBorder(true); | |
3352 | hint.Show(); | |
3353 | ||
3354 | if (!hint.IsOk()) | |
3355 | return rect; | |
3356 | ||
3357 | CopyDocksAndPanes(docks, panes, m_docks, m_panes); | |
3358 | ||
3359 | // remove any pane already there which bears the same window; | |
3360 | // this happens when you are moving a pane around in a dock | |
3361 | for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i) | |
3362 | { | |
3363 | if (panes.Item(i).window == pane_window) | |
3364 | { | |
3365 | RemovePaneFromDocks(docks, panes.Item(i)); | |
3366 | panes.RemoveAt(i); | |
3367 | break; | |
3368 | } | |
3369 | } | |
3370 | ||
3371 | // find out where the new pane would be | |
3372 | if (!DoDrop(docks, panes, hint, pt, offset)) | |
3373 | { | |
3374 | return rect; | |
3375 | } | |
3376 | ||
3377 | panes.Add(hint); | |
3378 | ||
3379 | wxSizer* sizer = LayoutAll(panes, docks, uiparts, true); | |
3380 | wxSize client_size = m_frame->GetClientSize(); | |
3381 | sizer->SetDimension(0, 0, client_size.x, client_size.y); | |
3382 | sizer->Layout(); | |
3383 | ||
3384 | for (i = 0, part_count = uiparts.GetCount(); | |
3385 | i < part_count; ++i) | |
3386 | { | |
3387 | wxAuiDockUIPart& part = uiparts.Item(i); | |
3388 | ||
3389 | if (part.type == wxAuiDockUIPart::typePaneBorder && | |
3390 | part.pane && part.pane->name == wxT("__HINT__")) | |
3391 | { | |
3392 | rect = wxRect(part.sizer_item->GetPosition(), | |
3393 | part.sizer_item->GetSize()); | |
3394 | break; | |
3395 | } | |
3396 | } | |
3397 | ||
3398 | delete sizer; | |
3399 | ||
3400 | if (rect.IsEmpty()) | |
3401 | { | |
3402 | return rect; | |
3403 | } | |
3404 | ||
3405 | // actually show the hint rectangle on the screen | |
3406 | m_frame->ClientToScreen(&rect.x, &rect.y); | |
3407 | ||
3408 | if ( m_frame->GetLayoutDirection() == wxLayout_RightToLeft ) | |
3409 | { | |
3410 | // Mirror rectangle in RTL mode | |
3411 | rect.x -= rect.GetWidth(); | |
3412 | } | |
3413 | ||
3414 | return rect; | |
3415 | } | |
3416 | ||
3417 | // DrawHintRect() calculates the hint rectangle by calling | |
3418 | // CalculateHintRect(). If there is a rectangle, it shows it | |
3419 | // by calling ShowHint(), otherwise it hides any hint | |
3420 | // rectangle currently shown | |
3421 | void wxAuiManager::DrawHintRect(wxWindow* pane_window, | |
3422 | const wxPoint& pt, | |
3423 | const wxPoint& offset) | |
3424 | { | |
3425 | wxRect rect = CalculateHintRect(pane_window, pt, offset); | |
3426 | ||
3427 | if (rect.IsEmpty()) | |
3428 | { | |
3429 | HideHint(); | |
3430 | } | |
3431 | else | |
3432 | { | |
3433 | ShowHint(rect); | |
3434 | } | |
3435 | } | |
3436 | ||
3437 | void wxAuiManager::OnFloatingPaneMoveStart(wxWindow* wnd) | |
3438 | { | |
3439 | // try to find the pane | |
3440 | wxAuiPaneInfo& pane = GetPane(wnd); | |
3441 | wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found")); | |
3442 | ||
3443 | if (m_flags & wxAUI_MGR_TRANSPARENT_DRAG) | |
3444 | pane.frame->SetTransparent(150); | |
3445 | } | |
3446 | ||
3447 | void wxAuiManager::OnFloatingPaneMoving(wxWindow* wnd, wxDirection dir) | |
3448 | { | |
3449 | // try to find the pane | |
3450 | wxAuiPaneInfo& pane = GetPane(wnd); | |
3451 | wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found")); | |
3452 | ||
3453 | wxPoint pt = ::wxGetMousePosition(); | |
3454 | ||
3455 | #if 0 | |
3456 | // Adapt pt to direction | |
3457 | if (dir == wxNORTH) | |
3458 | { | |
3459 | // move to pane's upper border | |
3460 | wxPoint pos( 0,0 ); | |
3461 | pos = wnd->ClientToScreen( pos ); | |
3462 | pt.y = pos.y; | |
3463 | // and some more pixels for the title bar | |
3464 | pt.y -= 5; | |
3465 | } | |
3466 | else if (dir == wxWEST) | |
3467 | { | |
3468 | // move to pane's left border | |
3469 | wxPoint pos( 0,0 ); | |
3470 | pos = wnd->ClientToScreen( pos ); | |
3471 | pt.x = pos.x; | |
3472 | } | |
3473 | else if (dir == wxEAST) | |
3474 | { | |
3475 | // move to pane's right border | |
3476 | wxPoint pos( wnd->GetSize().x, 0 ); | |
3477 | pos = wnd->ClientToScreen( pos ); | |
3478 | pt.x = pos.x; | |
3479 | } | |
3480 | else if (dir == wxSOUTH) | |
3481 | { | |
3482 | // move to pane's bottom border | |
3483 | wxPoint pos( 0, wnd->GetSize().y ); | |
3484 | pos = wnd->ClientToScreen( pos ); | |
3485 | pt.y = pos.y; | |
3486 | } | |
3487 | #else | |
3488 | wxUnusedVar(dir); | |
3489 | #endif | |
3490 | ||
3491 | wxPoint client_pt = m_frame->ScreenToClient(pt); | |
3492 | ||
3493 | // calculate the offset from the upper left-hand corner | |
3494 | // of the frame to the mouse pointer | |
3495 | wxPoint frame_pos = pane.frame->GetPosition(); | |
3496 | wxPoint action_offset(pt.x-frame_pos.x, pt.y-frame_pos.y); | |
3497 | ||
3498 | // no hint for toolbar floating windows | |
3499 | if (pane.IsToolbar() && m_action == actionDragFloatingPane) | |
3500 | { | |
3501 | wxAuiDockInfoArray docks; | |
3502 | wxAuiPaneInfoArray panes; | |
3503 | wxAuiDockUIPartArray uiparts; | |
3504 | wxAuiPaneInfo hint = pane; | |
3505 | ||
3506 | CopyDocksAndPanes(docks, panes, m_docks, m_panes); | |
3507 | ||
3508 | // find out where the new pane would be | |
3509 | if (!DoDrop(docks, panes, hint, client_pt)) | |
3510 | return; | |
3511 | if (hint.IsFloating()) | |
3512 | return; | |
3513 | ||
3514 | pane = hint; | |
3515 | m_action = actionDragToolbarPane; | |
3516 | m_action_window = pane.window; | |
3517 | ||
3518 | Update(); | |
3519 | ||
3520 | return; | |
3521 | } | |
3522 | ||
3523 | ||
3524 | // if a key modifier is pressed while dragging the frame, | |
3525 | // don't dock the window | |
3526 | if (!CanDockPanel(pane)) | |
3527 | { | |
3528 | HideHint(); | |
3529 | return; | |
3530 | } | |
3531 | ||
3532 | ||
3533 | DrawHintRect(wnd, client_pt, action_offset); | |
3534 | ||
3535 | #ifdef __WXGTK__ | |
3536 | // this cleans up some screen artifacts that are caused on GTK because | |
3537 | // we aren't getting the exact size of the window (see comment | |
3538 | // in DrawHintRect) | |
3539 | //Refresh(); | |
3540 | #endif | |
3541 | ||
3542 | ||
3543 | // reduces flicker | |
3544 | m_frame->Update(); | |
3545 | } | |
3546 | ||
3547 | void wxAuiManager::OnFloatingPaneMoved(wxWindow* wnd, wxDirection dir) | |
3548 | { | |
3549 | // try to find the pane | |
3550 | wxAuiPaneInfo& pane = GetPane(wnd); | |
3551 | wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found")); | |
3552 | ||
3553 | wxPoint pt = ::wxGetMousePosition(); | |
3554 | ||
3555 | #if 0 | |
3556 | // Adapt pt to direction | |
3557 | if (dir == wxNORTH) | |
3558 | { | |
3559 | // move to pane's upper border | |
3560 | wxPoint pos( 0,0 ); | |
3561 | pos = wnd->ClientToScreen( pos ); | |
3562 | pt.y = pos.y; | |
3563 | // and some more pixels for the title bar | |
3564 | pt.y -= 10; | |
3565 | } | |
3566 | else if (dir == wxWEST) | |
3567 | { | |
3568 | // move to pane's left border | |
3569 | wxPoint pos( 0,0 ); | |
3570 | pos = wnd->ClientToScreen( pos ); | |
3571 | pt.x = pos.x; | |
3572 | } | |
3573 | else if (dir == wxEAST) | |
3574 | { | |
3575 | // move to pane's right border | |
3576 | wxPoint pos( wnd->GetSize().x, 0 ); | |
3577 | pos = wnd->ClientToScreen( pos ); | |
3578 | pt.x = pos.x; | |
3579 | } | |
3580 | else if (dir == wxSOUTH) | |
3581 | { | |
3582 | // move to pane's bottom border | |
3583 | wxPoint pos( 0, wnd->GetSize().y ); | |
3584 | pos = wnd->ClientToScreen( pos ); | |
3585 | pt.y = pos.y; | |
3586 | } | |
3587 | #else | |
3588 | wxUnusedVar(dir); | |
3589 | #endif | |
3590 | ||
3591 | wxPoint client_pt = m_frame->ScreenToClient(pt); | |
3592 | ||
3593 | // calculate the offset from the upper left-hand corner | |
3594 | // of the frame to the mouse pointer | |
3595 | wxPoint frame_pos = pane.frame->GetPosition(); | |
3596 | wxPoint action_offset(pt.x-frame_pos.x, pt.y-frame_pos.y); | |
3597 | ||
3598 | // if a key modifier is pressed while dragging the frame, | |
3599 | // don't dock the window | |
3600 | if (CanDockPanel(pane)) | |
3601 | { | |
3602 | // do the drop calculation | |
3603 | DoDrop(m_docks, m_panes, pane, client_pt, action_offset); | |
3604 | } | |
3605 | ||
3606 | // if the pane is still floating, update it's floating | |
3607 | // position (that we store) | |
3608 | if (pane.IsFloating()) | |
3609 | { | |
3610 | pane.floating_pos = pane.frame->GetPosition(); | |
3611 | ||
3612 | if (m_flags & wxAUI_MGR_TRANSPARENT_DRAG) | |
3613 | pane.frame->SetTransparent(255); | |
3614 | } | |
3615 | else if (m_has_maximized) | |
3616 | { | |
3617 | RestoreMaximizedPane(); | |
3618 | } | |
3619 | ||
3620 | Update(); | |
3621 | ||
3622 | HideHint(); | |
3623 | } | |
3624 | ||
3625 | void wxAuiManager::OnFloatingPaneResized(wxWindow* wnd, const wxSize& size) | |
3626 | { | |
3627 | // try to find the pane | |
3628 | wxAuiPaneInfo& pane = GetPane(wnd); | |
3629 | wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found")); | |
3630 | ||
3631 | pane.floating_size = size; | |
3632 | } | |
3633 | ||
3634 | ||
3635 | void wxAuiManager::OnFloatingPaneClosed(wxWindow* wnd, wxCloseEvent& evt) | |
3636 | { | |
3637 | // try to find the pane | |
3638 | wxAuiPaneInfo& pane = GetPane(wnd); | |
3639 | wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found")); | |
3640 | ||
3641 | ||
3642 | // fire pane close event | |
3643 | wxAuiManagerEvent e(wxEVT_AUI_PANE_CLOSE); | |
3644 | e.SetPane(&pane); | |
3645 | e.SetCanVeto(evt.CanVeto()); | |
3646 | ProcessMgrEvent(e); | |
3647 | ||
3648 | if (e.GetVeto()) | |
3649 | { | |
3650 | evt.Veto(); | |
3651 | return; | |
3652 | } | |
3653 | else | |
3654 | { | |
3655 | // close the pane, but check that it | |
3656 | // still exists in our pane array first | |
3657 | // (the event handler above might have removed it) | |
3658 | ||
3659 | wxAuiPaneInfo& check = GetPane(wnd); | |
3660 | if (check.IsOk()) | |
3661 | { | |
3662 | ClosePane(pane); | |
3663 | } | |
3664 | } | |
3665 | } | |
3666 | ||
3667 | ||
3668 | ||
3669 | void wxAuiManager::OnFloatingPaneActivated(wxWindow* wnd) | |
3670 | { | |
3671 | if ((GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE) && GetPane(wnd).IsOk()) | |
3672 | { | |
3673 | SetActivePane(m_panes, wnd); | |
3674 | Repaint(); | |
3675 | } | |
3676 | } | |
3677 | ||
3678 | // OnRender() draws all of the pane captions, sashes, | |
3679 | // backgrounds, captions, grippers, pane borders and buttons. | |
3680 | // It renders the entire user interface. | |
3681 | ||
3682 | void wxAuiManager::OnRender(wxAuiManagerEvent& evt) | |
3683 | { | |
3684 | // if the frame is about to be deleted, don't bother | |
3685 | if (!m_frame || wxPendingDelete.Member(m_frame)) | |
3686 | return; | |
3687 | ||
3688 | wxDC* dc = evt.GetDC(); | |
3689 | ||
3690 | #ifdef __WXMAC__ | |
3691 | dc->Clear() ; | |
3692 | #endif | |
3693 | int i, part_count; | |
3694 | for (i = 0, part_count = m_uiparts.GetCount(); | |
3695 | i < part_count; ++i) | |
3696 | { | |
3697 | wxAuiDockUIPart& part = m_uiparts.Item(i); | |
3698 | ||
3699 | // don't draw hidden pane items or items that aren't windows | |
3700 | if (part.sizer_item && ((!part.sizer_item->IsWindow() && !part.sizer_item->IsSpacer() && !part.sizer_item->IsSizer()) || !part.sizer_item->IsShown())) | |
3701 | continue; | |
3702 | ||
3703 | switch (part.type) | |
3704 | { | |
3705 | case wxAuiDockUIPart::typeDockSizer: | |
3706 | case wxAuiDockUIPart::typePaneSizer: | |
3707 | m_art->DrawSash(*dc, m_frame, part.orientation, part.rect); | |
3708 | break; | |
3709 | case wxAuiDockUIPart::typeBackground: | |
3710 | m_art->DrawBackground(*dc, m_frame, part.orientation, part.rect); | |
3711 | break; | |
3712 | case wxAuiDockUIPart::typeCaption: | |
3713 | m_art->DrawCaption(*dc, m_frame, part.pane->caption, part.rect, *part.pane); | |
3714 | break; | |
3715 | case wxAuiDockUIPart::typeGripper: | |
3716 | m_art->DrawGripper(*dc, m_frame, part.rect, *part.pane); | |
3717 | break; | |
3718 | case wxAuiDockUIPart::typePaneBorder: | |
3719 | m_art->DrawBorder(*dc, m_frame, part.rect, *part.pane); | |
3720 | break; | |
3721 | case wxAuiDockUIPart::typePaneButton: | |
3722 | m_art->DrawPaneButton(*dc, m_frame, part.button->button_id, | |
3723 | wxAUI_BUTTON_STATE_NORMAL, part.rect, *part.pane); | |
3724 | break; | |
3725 | } | |
3726 | } | |
3727 | } | |
3728 | ||
3729 | ||
3730 | // Render() fire a render event, which is normally handled by | |
3731 | // wxAuiManager::OnRender(). This allows the render function to | |
3732 | // be overridden via the render event. This can be useful for paintin | |
3733 | // custom graphics in the main window. Default behavior can be | |
3734 | // invoked in the overridden function by calling OnRender() | |
3735 | ||
3736 | void wxAuiManager::Render(wxDC* dc) | |
3737 | { | |
3738 | wxAuiManagerEvent e(wxEVT_AUI_RENDER); | |
3739 | e.SetManager(this); | |
3740 | e.SetDC(dc); | |
3741 | ProcessMgrEvent(e); | |
3742 | } | |
3743 | ||
3744 | void wxAuiManager::Repaint(wxDC* dc) | |
3745 | { | |
3746 | #ifdef __WXMAC__ | |
3747 | if ( dc == NULL ) | |
3748 | { | |
3749 | m_frame->Refresh() ; | |
3750 | m_frame->Update() ; | |
3751 | return ; | |
3752 | } | |
3753 | #endif | |
3754 | int w, h; | |
3755 | m_frame->GetClientSize(&w, &h); | |
3756 | ||
3757 | // figure out which dc to use; if one | |
3758 | // has been specified, use it, otherwise | |
3759 | // make a client dc | |
3760 | wxClientDC* client_dc = NULL; | |
3761 | if (!dc) | |
3762 | { | |
3763 | client_dc = new wxClientDC(m_frame); | |
3764 | dc = client_dc; | |
3765 | } | |
3766 | ||
3767 | // if the frame has a toolbar, the client area | |
3768 | // origin will not be (0,0). | |
3769 | wxPoint pt = m_frame->GetClientAreaOrigin(); | |
3770 | if (pt.x != 0 || pt.y != 0) | |
3771 | dc->SetDeviceOrigin(pt.x, pt.y); | |
3772 | ||
3773 | // render all the items | |
3774 | Render(dc); | |
3775 | ||
3776 | // if we created a client_dc, delete it | |
3777 | if (client_dc) | |
3778 | delete client_dc; | |
3779 | } | |
3780 | ||
3781 | void wxAuiManager::OnPaint(wxPaintEvent& WXUNUSED(event)) | |
3782 | { | |
3783 | wxPaintDC dc(m_frame); | |
3784 | Repaint(&dc); | |
3785 | } | |
3786 | ||
3787 | void wxAuiManager::OnEraseBackground(wxEraseEvent& event) | |
3788 | { | |
3789 | #ifdef __WXMAC__ | |
3790 | event.Skip() ; | |
3791 | #else | |
3792 | wxUnusedVar(event); | |
3793 | #endif | |
3794 | } | |
3795 | ||
3796 | void wxAuiManager::OnSize(wxSizeEvent& event) | |
3797 | { | |
3798 | if (m_frame) | |
3799 | { | |
3800 | DoFrameLayout(); | |
3801 | Repaint(); | |
3802 | ||
3803 | #if wxUSE_MDI | |
3804 | if (m_frame->IsKindOf(CLASSINFO(wxMDIParentFrame))) | |
3805 | { | |
3806 | // for MDI parent frames, this event must not | |
3807 | // be "skipped". In other words, the parent frame | |
3808 | // must not be allowed to resize the client window | |
3809 | // after we are finished processing sizing changes | |
3810 | return; | |
3811 | } | |
3812 | #endif | |
3813 | } | |
3814 | event.Skip(); | |
3815 | } | |
3816 | ||
3817 | void wxAuiManager::OnFindManager(wxAuiManagerEvent& evt) | |
3818 | { | |
3819 | // get the window we are managing, if none, return NULL | |
3820 | wxWindow* window = GetManagedWindow(); | |
3821 | if (!window) | |
3822 | { | |
3823 | evt.SetManager(NULL); | |
3824 | return; | |
3825 | } | |
3826 | ||
3827 | // if we are managing a child frame, get the 'real' manager | |
3828 | if (window->IsKindOf(CLASSINFO(wxAuiFloatingFrame))) | |
3829 | { | |
3830 | wxAuiFloatingFrame* float_frame = static_cast<wxAuiFloatingFrame*>(window); | |
3831 | evt.SetManager(float_frame->GetOwnerManager()); | |
3832 | return; | |
3833 | } | |
3834 | ||
3835 | // return pointer to ourself | |
3836 | evt.SetManager(this); | |
3837 | } | |
3838 | ||
3839 | void wxAuiManager::OnSetCursor(wxSetCursorEvent& event) | |
3840 | { | |
3841 | // determine cursor | |
3842 | wxAuiDockUIPart* part = HitTest(event.GetX(), event.GetY()); | |
3843 | wxCursor cursor = wxNullCursor; | |
3844 | ||
3845 | if (part) | |
3846 | { | |
3847 | if (part->type == wxAuiDockUIPart::typeDockSizer || | |
3848 | part->type == wxAuiDockUIPart::typePaneSizer) | |
3849 | { | |
3850 | // a dock may not be resized if it has a single | |
3851 | // pane which is not resizable | |
3852 | if (part->type == wxAuiDockUIPart::typeDockSizer && part->dock && | |
3853 | part->dock->panes.GetCount() == 1 && | |
3854 | part->dock->panes.Item(0)->IsFixed()) | |
3855 | return; | |
3856 | ||
3857 | // panes that may not be resized do not get a sizing cursor | |
3858 | if (part->pane && part->pane->IsFixed()) | |
3859 | return; | |
3860 | ||
3861 | if (part->orientation == wxVERTICAL) | |
3862 | cursor = wxCursor(wxCURSOR_SIZEWE); | |
3863 | else | |
3864 | cursor = wxCursor(wxCURSOR_SIZENS); | |
3865 | } | |
3866 | else if (part->type == wxAuiDockUIPart::typeGripper) | |
3867 | { | |
3868 | cursor = wxCursor(wxCURSOR_SIZING); | |
3869 | } | |
3870 | } | |
3871 | ||
3872 | event.SetCursor(cursor); | |
3873 | } | |
3874 | ||
3875 | ||
3876 | ||
3877 | void wxAuiManager::UpdateButtonOnScreen(wxAuiDockUIPart* button_ui_part, | |
3878 | const wxMouseEvent& event) | |
3879 | { | |
3880 | wxAuiDockUIPart* hit_test = HitTest(event.GetX(), event.GetY()); | |
3881 | if (!hit_test || !button_ui_part) | |
3882 | return; | |
3883 | ||
3884 | int state = wxAUI_BUTTON_STATE_NORMAL; | |
3885 | ||
3886 | if (hit_test == button_ui_part) | |
3887 | { | |
3888 | if (event.LeftDown()) | |
3889 | state = wxAUI_BUTTON_STATE_PRESSED; | |
3890 | else | |
3891 | state = wxAUI_BUTTON_STATE_HOVER; | |
3892 | } | |
3893 | else | |
3894 | { | |
3895 | if (event.LeftDown()) | |
3896 | state = wxAUI_BUTTON_STATE_HOVER; | |
3897 | } | |
3898 | ||
3899 | // now repaint the button with hover state | |
3900 | wxClientDC cdc(m_frame); | |
3901 | ||
3902 | // if the frame has a toolbar, the client area | |
3903 | // origin will not be (0,0). | |
3904 | wxPoint pt = m_frame->GetClientAreaOrigin(); | |
3905 | if (pt.x != 0 || pt.y != 0) | |
3906 | cdc.SetDeviceOrigin(pt.x, pt.y); | |
3907 | ||
3908 | if (hit_test->pane) | |
3909 | { | |
3910 | m_art->DrawPaneButton(cdc, m_frame, | |
3911 | button_ui_part->button->button_id, | |
3912 | state, | |
3913 | button_ui_part->rect, | |
3914 | *hit_test->pane); | |
3915 | } | |
3916 | } | |
3917 | ||
3918 | void wxAuiManager::OnLeftDown(wxMouseEvent& event) | |
3919 | { | |
3920 | wxAuiDockUIPart* part = HitTest(event.GetX(), event.GetY()); | |
3921 | if (part) | |
3922 | { | |
3923 | if (part->type == wxAuiDockUIPart::typeDockSizer || | |
3924 | part->type == wxAuiDockUIPart::typePaneSizer) | |
3925 | { | |
3926 | // Removing this restriction so that a centre pane can be resized | |
3927 | //if (part->dock && part->dock->dock_direction == wxAUI_DOCK_CENTER) | |
3928 | // return; | |
3929 | ||
3930 | // a dock may not be resized if it has a single | |
3931 | // pane which is not resizable | |
3932 | if (part->type == wxAuiDockUIPart::typeDockSizer && part->dock && | |
3933 | part->dock->panes.GetCount() == 1 && | |
3934 | part->dock->panes.Item(0)->IsFixed()) | |
3935 | return; | |
3936 | ||
3937 | // panes that may not be resized should be ignored here | |
3938 | if (part->pane && part->pane->IsFixed()) | |
3939 | return; | |
3940 | ||
3941 | m_action = actionResize; | |
3942 | m_action_part = part; | |
3943 | m_action_hintrect = wxRect(); | |
3944 | m_action_start = wxPoint(event.m_x, event.m_y); | |
3945 | m_action_offset = wxPoint(event.m_x - part->rect.x, | |
3946 | event.m_y - part->rect.y); | |
3947 | m_frame->CaptureMouse(); | |
3948 | } | |
3949 | else if (part->type == wxAuiDockUIPart::typePaneButton) | |
3950 | { | |
3951 | m_action = actionClickButton; | |
3952 | m_action_part = part; | |
3953 | m_action_start = wxPoint(event.m_x, event.m_y); | |
3954 | m_frame->CaptureMouse(); | |
3955 | ||
3956 | UpdateButtonOnScreen(part, event); | |
3957 | } | |
3958 | else if (part->type == wxAuiDockUIPart::typeCaption || | |
3959 | part->type == wxAuiDockUIPart::typeGripper) | |
3960 | { | |
3961 | // if we are managing a wxAuiFloatingFrame window, then | |
3962 | // we are an embedded wxAuiManager inside the wxAuiFloatingFrame. | |
3963 | // We want to initiate a toolbar drag in our owner manager | |
3964 | wxWindow* managed_wnd = GetManagedWindow(); | |
3965 | ||
3966 | if (part->pane && | |
3967 | part->pane->window && | |
3968 | managed_wnd && | |
3969 | managed_wnd->IsKindOf(CLASSINFO(wxAuiFloatingFrame))) | |
3970 | { | |
3971 | wxAuiFloatingFrame* floating_frame = (wxAuiFloatingFrame*)managed_wnd; | |
3972 | wxAuiManager* owner_mgr = floating_frame->GetOwnerManager(); | |
3973 | owner_mgr->StartPaneDrag(part->pane->window, | |
3974 | wxPoint(event.m_x - part->rect.x, | |
3975 | event.m_y - part->rect.y)); | |
3976 | return; | |
3977 | } | |
3978 | ||
3979 | ||
3980 | ||
3981 | if (GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE) | |
3982 | { | |
3983 | // set the caption as active | |
3984 | SetActivePane(m_panes, part->pane->window); | |
3985 | Repaint(); | |
3986 | } | |
3987 | ||
3988 | if (part->dock && part->dock->dock_direction == wxAUI_DOCK_CENTER) | |
3989 | return; | |
3990 | ||
3991 | m_action = actionClickCaption; | |
3992 | m_action_part = part; | |
3993 | m_action_start = wxPoint(event.m_x, event.m_y); | |
3994 | m_action_offset = wxPoint(event.m_x - part->rect.x, | |
3995 | event.m_y - part->rect.y); | |
3996 | m_frame->CaptureMouse(); | |
3997 | } | |
3998 | #ifdef __WXMAC__ | |
3999 | else | |
4000 | { | |
4001 | event.Skip(); | |
4002 | } | |
4003 | #endif | |
4004 | } | |
4005 | #ifdef __WXMAC__ | |
4006 | else | |
4007 | { | |
4008 | event.Skip(); | |
4009 | } | |
4010 | #else | |
4011 | event.Skip(); | |
4012 | #endif | |
4013 | } | |
4014 | ||
4015 | ||
4016 | void wxAuiManager::OnLeftUp(wxMouseEvent& event) | |
4017 | { | |
4018 | if (m_action == actionResize) | |
4019 | { | |
4020 | m_frame->ReleaseMouse(); | |
4021 | ||
4022 | // get rid of the hint rectangle | |
4023 | wxScreenDC dc; | |
4024 | DrawResizeHint(dc, m_action_hintrect); | |
4025 | ||
4026 | // resize the dock or the pane | |
4027 | if (m_action_part && m_action_part->type==wxAuiDockUIPart::typeDockSizer) | |
4028 | { | |
4029 | wxRect& rect = m_action_part->dock->rect; | |
4030 | ||
4031 | wxPoint new_pos(event.m_x - m_action_offset.x, | |
4032 | event.m_y - m_action_offset.y); | |
4033 | ||
4034 | switch (m_action_part->dock->dock_direction) | |
4035 | { | |
4036 | case wxAUI_DOCK_LEFT: | |
4037 | m_action_part->dock->size = new_pos.x - rect.x; | |
4038 | break; | |
4039 | case wxAUI_DOCK_TOP: | |
4040 | m_action_part->dock->size = new_pos.y - rect.y; | |
4041 | break; | |
4042 | case wxAUI_DOCK_RIGHT: | |
4043 | m_action_part->dock->size = rect.x + rect.width - | |
4044 | new_pos.x - m_action_part->rect.GetWidth(); | |
4045 | break; | |
4046 | case wxAUI_DOCK_BOTTOM: | |
4047 | m_action_part->dock->size = rect.y + rect.height - | |
4048 | new_pos.y - m_action_part->rect.GetHeight(); | |
4049 | break; | |
4050 | } | |
4051 | ||
4052 | Update(); | |
4053 | Repaint(NULL); | |
4054 | } | |
4055 | else if (m_action_part && | |
4056 | m_action_part->type == wxAuiDockUIPart::typePaneSizer) | |
4057 | { | |
4058 | wxAuiDockInfo& dock = *m_action_part->dock; | |
4059 | wxAuiPaneInfo& pane = *m_action_part->pane; | |
4060 | ||
4061 | int total_proportion = 0; | |
4062 | int dock_pixels = 0; | |
4063 | int new_pixsize = 0; | |
4064 | ||
4065 | int caption_size = m_art->GetMetric(wxAUI_DOCKART_CAPTION_SIZE); | |
4066 | int pane_border_size = m_art->GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE); | |
4067 | int sash_size = m_art->GetMetric(wxAUI_DOCKART_SASH_SIZE); | |
4068 | ||
4069 | wxPoint new_pos(event.m_x - m_action_offset.x, | |
4070 | event.m_y - m_action_offset.y); | |
4071 | ||
4072 | // determine the pane rectangle by getting the pane part | |
4073 | wxAuiDockUIPart* pane_part = GetPanePart(pane.window); | |
4074 | wxASSERT_MSG(pane_part, | |
4075 | wxT("Pane border part not found -- shouldn't happen")); | |
4076 | ||
4077 | // determine the new pixel size that the user wants; | |
4078 | // this will help us recalculate the pane's proportion | |
4079 | if (dock.IsHorizontal()) | |
4080 | new_pixsize = new_pos.x - pane_part->rect.x; | |
4081 | else | |
4082 | new_pixsize = new_pos.y - pane_part->rect.y; | |
4083 | ||
4084 | // determine the size of the dock, based on orientation | |
4085 | if (dock.IsHorizontal()) | |
4086 | dock_pixels = dock.rect.GetWidth(); | |
4087 | else | |
4088 | dock_pixels = dock.rect.GetHeight(); | |
4089 | ||
4090 | // determine the total proportion of all resizable panes, | |
4091 | // and the total size of the dock minus the size of all | |
4092 | // the fixed panes | |
4093 | int i, dock_pane_count = dock.panes.GetCount(); | |
4094 | int pane_position = -1; | |
4095 | for (i = 0; i < dock_pane_count; ++i) | |
4096 | { | |
4097 | wxAuiPaneInfo& p = *dock.panes.Item(i); | |
4098 | if (p.window == pane.window) | |
4099 | pane_position = i; | |
4100 | ||
4101 | // while we're at it, subtract the pane sash | |
4102 | // width from the dock width, because this would | |
4103 | // skew our proportion calculations | |
4104 | if (i > 0) | |
4105 | dock_pixels -= sash_size; | |
4106 | ||
4107 | // also, the whole size (including decorations) of | |
4108 | // all fixed panes must also be subtracted, because they | |
4109 | // are not part of the proportion calculation | |
4110 | if (p.IsFixed()) | |
4111 | { | |
4112 | if (dock.IsHorizontal()) | |
4113 | dock_pixels -= p.best_size.x; | |
4114 | else | |
4115 | dock_pixels -= p.best_size.y; | |
4116 | } | |
4117 | else | |
4118 | { | |
4119 | total_proportion += p.dock_proportion; | |
4120 | } | |
4121 | } | |
4122 | ||
4123 | // find a pane in our dock to 'steal' space from or to 'give' | |
4124 | // space to -- this is essentially what is done when a pane is | |
4125 | // resized; the pane should usually be the first non-fixed pane | |
4126 | // to the right of the action pane | |
4127 | int borrow_pane = -1; | |
4128 | for (i = pane_position+1; i < dock_pane_count; ++i) | |
4129 | { | |
4130 | wxAuiPaneInfo& p = *dock.panes.Item(i); | |
4131 | if (!p.IsFixed()) | |
4132 | { | |
4133 | borrow_pane = i; | |
4134 | break; | |
4135 | } | |
4136 | } | |
4137 | ||
4138 | ||
4139 | // demand that the pane being resized is found in this dock | |
4140 | // (this assert really never should be raised) | |
4141 | wxASSERT_MSG(pane_position != -1, wxT("Pane not found in dock")); | |
4142 | ||
4143 | // prevent division by zero | |
4144 | if (dock_pixels == 0 || total_proportion == 0 || borrow_pane == -1) | |
4145 | { | |
4146 | m_action = actionNone; | |
4147 | return; | |
4148 | } | |
4149 | ||
4150 | // calculate the new proportion of the pane | |
4151 | int new_proportion = (new_pixsize*total_proportion)/dock_pixels; | |
4152 | ||
4153 | // default minimum size | |
4154 | int min_size = 0; | |
4155 | ||
4156 | // check against the pane's minimum size, if specified. please note | |
4157 | // that this is not enough to ensure that the minimum size will | |
4158 | // not be violated, because the whole frame might later be shrunk, | |
4159 | // causing the size of the pane to violate it's minimum size | |
4160 | if (pane.min_size.IsFullySpecified()) | |
4161 | { | |
4162 | min_size = 0; | |
4163 | ||
4164 | if (pane.HasBorder()) | |
4165 | min_size += (pane_border_size*2); | |
4166 | ||
4167 | // calculate minimum size with decorations (border,caption) | |
4168 | if (pane_part->orientation == wxVERTICAL) | |
4169 | { | |
4170 | min_size += pane.min_size.y; | |
4171 | if (pane.HasCaption()) | |
4172 | min_size += caption_size; | |
4173 | } | |
4174 | else | |
4175 | { | |
4176 | min_size += pane.min_size.x; | |
4177 | } | |
4178 | } | |
4179 | ||
4180 | ||
4181 | // for some reason, an arithmatic error somewhere is causing | |
4182 | // the proportion calculations to always be off by 1 pixel; | |
4183 | // for now we will add the 1 pixel on, but we really should | |
4184 | // determine what's causing this. | |
4185 | min_size++; | |
4186 | ||
4187 | int min_proportion = (min_size*total_proportion)/dock_pixels; | |
4188 | ||
4189 | if (new_proportion < min_proportion) | |
4190 | new_proportion = min_proportion; | |
4191 | ||
4192 | ||
4193 | ||
4194 | int prop_diff = new_proportion - pane.dock_proportion; | |
4195 | ||
4196 | // borrow the space from our neighbor pane to the | |
4197 | // right or bottom (depending on orientation) | |
4198 | dock.panes.Item(borrow_pane)->dock_proportion -= prop_diff; | |
4199 | pane.dock_proportion = new_proportion; | |
4200 | ||
4201 | // repaint | |
4202 | Update(); | |
4203 | Repaint(NULL); | |
4204 | } | |
4205 | } | |
4206 | else if (m_action == actionClickButton) | |
4207 | { | |
4208 | m_hover_button = NULL; | |
4209 | m_frame->ReleaseMouse(); | |
4210 | ||
4211 | if (m_action_part) | |
4212 | { | |
4213 | UpdateButtonOnScreen(m_action_part, event); | |
4214 | ||
4215 | // make sure we're still over the item that was originally clicked | |
4216 | if (m_action_part == HitTest(event.GetX(), event.GetY())) | |
4217 | { | |
4218 | // fire button-click event | |
4219 | wxAuiManagerEvent e(wxEVT_AUI_PANE_BUTTON); | |
4220 | e.SetManager(this); | |
4221 | e.SetPane(m_action_part->pane); | |
4222 | e.SetButton(m_action_part->button->button_id); | |
4223 | ProcessMgrEvent(e); | |
4224 | } | |
4225 | } | |
4226 | } | |
4227 | else if (m_action == actionClickCaption) | |
4228 | { | |
4229 | m_frame->ReleaseMouse(); | |
4230 | } | |
4231 | else if (m_action == actionDragFloatingPane) | |
4232 | { | |
4233 | m_frame->ReleaseMouse(); | |
4234 | } | |
4235 | else if (m_action == actionDragToolbarPane) | |
4236 | { | |
4237 | m_frame->ReleaseMouse(); | |
4238 | ||
4239 | wxAuiPaneInfo& pane = GetPane(m_action_window); | |
4240 | wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found")); | |
4241 | ||
4242 | // save the new positions | |
4243 | wxAuiDockInfoPtrArray docks; | |
4244 | FindDocks(m_docks, pane.dock_direction, | |
4245 | pane.dock_layer, pane.dock_row, docks); | |
4246 | if (docks.GetCount() == 1) | |
4247 | { | |
4248 | wxAuiDockInfo& dock = *docks.Item(0); | |
4249 | ||
4250 | wxArrayInt pane_positions, pane_sizes; | |
4251 | GetPanePositionsAndSizes(dock, pane_positions, pane_sizes); | |
4252 | ||
4253 | int i, dock_pane_count = dock.panes.GetCount(); | |
4254 | for (i = 0; i < dock_pane_count; ++i) | |
4255 | dock.panes.Item(i)->dock_pos = pane_positions[i]; | |
4256 | } | |
4257 | ||
4258 | pane.state &= ~wxAuiPaneInfo::actionPane; | |
4259 | Update(); | |
4260 | } | |
4261 | else | |
4262 | { | |
4263 | event.Skip(); | |
4264 | } | |
4265 | ||
4266 | m_action = actionNone; | |
4267 | m_last_mouse_move = wxPoint(); // see comment in OnMotion() | |
4268 | } | |
4269 | ||
4270 | ||
4271 | void wxAuiManager::OnMotion(wxMouseEvent& event) | |
4272 | { | |
4273 | // sometimes when Update() is called from inside this method, | |
4274 | // a spurious mouse move event is generated; this check will make | |
4275 | // sure that only real mouse moves will get anywhere in this method; | |
4276 | // this appears to be a bug somewhere, and I don't know where the | |
4277 | // mouse move event is being generated. only verified on MSW | |
4278 | ||
4279 | wxPoint mouse_pos = event.GetPosition(); | |
4280 | if (m_last_mouse_move == mouse_pos) | |
4281 | return; | |
4282 | m_last_mouse_move = mouse_pos; | |
4283 | ||
4284 | ||
4285 | if (m_action == actionResize) | |
4286 | { | |
4287 | if (m_action_part) | |
4288 | { | |
4289 | wxPoint pos = m_action_part->rect.GetPosition(); | |
4290 | if (m_action_part->orientation == wxHORIZONTAL) | |
4291 | pos.y = wxMax(0, event.m_y - m_action_offset.y); | |
4292 | else | |
4293 | pos.x = wxMax(0, event.m_x - m_action_offset.x); | |
4294 | ||
4295 | wxRect rect(m_frame->ClientToScreen(pos), | |
4296 | m_action_part->rect.GetSize()); | |
4297 | ||
4298 | wxScreenDC dc; | |
4299 | if (!m_action_hintrect.IsEmpty()) | |
4300 | DrawResizeHint(dc, m_action_hintrect); | |
4301 | DrawResizeHint(dc, rect); | |
4302 | m_action_hintrect = rect; | |
4303 | } | |
4304 | } | |
4305 | else if (m_action == actionClickCaption) | |
4306 | { | |
4307 | int drag_x_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_X); | |
4308 | int drag_y_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_Y); | |
4309 | ||
4310 | // caption has been clicked. we need to check if the mouse | |
4311 | // is now being dragged. if it is, we need to change the | |
4312 | // mouse action to 'drag' | |
4313 | if (m_action_part && | |
4314 | (abs(event.m_x - m_action_start.x) > drag_x_threshold || | |
4315 | abs(event.m_y - m_action_start.y) > drag_y_threshold)) | |
4316 | { | |
4317 | wxAuiPaneInfo* pane_info = m_action_part->pane; | |
4318 | ||
4319 | if (!pane_info->IsToolbar()) | |
4320 | { | |
4321 | if ((m_flags & wxAUI_MGR_ALLOW_FLOATING) && | |
4322 | pane_info->IsFloatable()) | |
4323 | { | |
4324 | m_action = actionDragFloatingPane; | |
4325 | ||
4326 | // set initial float position | |
4327 | wxPoint pt = m_frame->ClientToScreen(event.GetPosition()); | |
4328 | pane_info->floating_pos = wxPoint(pt.x - m_action_offset.x, | |
4329 | pt.y - m_action_offset.y); | |
4330 | ||
4331 | // float the window | |
4332 | if (pane_info->IsMaximized()) | |
4333 | RestorePane(*pane_info); | |
4334 | pane_info->Float(); | |
4335 | Update(); | |
4336 | ||
4337 | m_action_window = pane_info->frame; | |
4338 | ||
4339 | // action offset is used here to make it feel "natural" to the user | |
4340 | // to drag a docked pane and suddenly have it become a floating frame. | |
4341 | // Sometimes, however, the offset where the user clicked on the docked | |
4342 | // caption is bigger than the width of the floating frame itself, so | |
4343 | // in that case we need to set the action offset to a sensible value | |
4344 | wxSize frame_size = m_action_window->GetSize(); | |
4345 | if (frame_size.x <= m_action_offset.x) | |
4346 | m_action_offset.x = 30; | |
4347 | } | |
4348 | } | |
4349 | else | |
4350 | { | |
4351 | m_action = actionDragToolbarPane; | |
4352 | m_action_window = pane_info->window; | |
4353 | } | |
4354 | } | |
4355 | } | |
4356 | else if (m_action == actionDragFloatingPane) | |
4357 | { | |
4358 | if (m_action_window) | |
4359 | { | |
4360 | wxPoint pt = m_frame->ClientToScreen(event.GetPosition()); | |
4361 | m_action_window->Move(pt.x - m_action_offset.x, | |
4362 | pt.y - m_action_offset.y); | |
4363 | } | |
4364 | } | |
4365 | else if (m_action == actionDragToolbarPane) | |
4366 | { | |
4367 | wxAuiPaneInfo& pane = GetPane(m_action_window); | |
4368 | wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found")); | |
4369 | ||
4370 | pane.state |= wxAuiPaneInfo::actionPane; | |
4371 | ||
4372 | wxPoint pt = event.GetPosition(); | |
4373 | DoDrop(m_docks, m_panes, pane, pt, m_action_offset); | |
4374 | ||
4375 | // if DoDrop() decided to float the pane, set up | |
4376 | // the floating pane's initial position | |
4377 | if (pane.IsFloating()) | |
4378 | { | |
4379 | wxPoint pt = m_frame->ClientToScreen(event.GetPosition()); | |
4380 | pane.floating_pos = wxPoint(pt.x - m_action_offset.x, | |
4381 | pt.y - m_action_offset.y); | |
4382 | } | |
4383 | ||
4384 | // this will do the actiual move operation; | |
4385 | // in the case that the pane has been floated, | |
4386 | // this call will create the floating pane | |
4387 | // and do the reparenting | |
4388 | Update(); | |
4389 | ||
4390 | // if the pane has been floated, change the mouse | |
4391 | // action actionDragFloatingPane so that subsequent | |
4392 | // EVT_MOTION() events will move the floating pane | |
4393 | if (pane.IsFloating()) | |
4394 | { | |
4395 | pane.state &= ~wxAuiPaneInfo::actionPane; | |
4396 | m_action = actionDragFloatingPane; | |
4397 | m_action_window = pane.frame; | |
4398 | } | |
4399 | } | |
4400 | else | |
4401 | { | |
4402 | wxAuiDockUIPart* part = HitTest(event.GetX(), event.GetY()); | |
4403 | if (part && part->type == wxAuiDockUIPart::typePaneButton) | |
4404 | { | |
4405 | if (part != m_hover_button) | |
4406 | { | |
4407 | // make the old button normal | |
4408 | if (m_hover_button) | |
4409 | { | |
4410 | UpdateButtonOnScreen(m_hover_button, event); | |
4411 | Repaint(); | |
4412 | } | |
4413 | ||
4414 | // mouse is over a button, so repaint the | |
4415 | // button in hover mode | |
4416 | UpdateButtonOnScreen(part, event); | |
4417 | m_hover_button = part; | |
4418 | ||
4419 | } | |
4420 | } | |
4421 | else | |
4422 | { | |
4423 | if (m_hover_button) | |
4424 | { | |
4425 | m_hover_button = NULL; | |
4426 | Repaint(); | |
4427 | } | |
4428 | else | |
4429 | { | |
4430 | event.Skip(); | |
4431 | } | |
4432 | } | |
4433 | } | |
4434 | } | |
4435 | ||
4436 | void wxAuiManager::OnLeaveWindow(wxMouseEvent& WXUNUSED(event)) | |
4437 | { | |
4438 | if (m_hover_button) | |
4439 | { | |
4440 | m_hover_button = NULL; | |
4441 | Repaint(); | |
4442 | } | |
4443 | } | |
4444 | ||
4445 | void wxAuiManager::OnCaptureLost(wxMouseCaptureLostEvent& WXUNUSED(event)) | |
4446 | { | |
4447 | // cancel the operation in progress, if any | |
4448 | if ( m_action != actionNone ) | |
4449 | { | |
4450 | m_action = actionNone; | |
4451 | HideHint(); | |
4452 | } | |
4453 | } | |
4454 | ||
4455 | void wxAuiManager::OnChildFocus(wxChildFocusEvent& event) | |
4456 | { | |
4457 | // when a child pane has it's focus set, we should change the | |
4458 | // pane's active state to reflect this. (this is only true if | |
4459 | // active panes are allowed by the owner) | |
4460 | if (GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE) | |
4461 | { | |
4462 | wxAuiPaneInfo& pane = GetPane(event.GetWindow()); | |
4463 | if (pane.IsOk() && (pane.state & wxAuiPaneInfo::optionActive) == 0) | |
4464 | { | |
4465 | SetActivePane(m_panes, event.GetWindow()); | |
4466 | m_frame->Refresh(); | |
4467 | } | |
4468 | } | |
4469 | ||
4470 | event.Skip(); | |
4471 | } | |
4472 | ||
4473 | ||
4474 | // OnPaneButton() is an event handler that is called | |
4475 | // when a pane button has been pressed. | |
4476 | void wxAuiManager::OnPaneButton(wxAuiManagerEvent& evt) | |
4477 | { | |
4478 | wxASSERT_MSG(evt.pane, wxT("Pane Info passed to wxAuiManager::OnPaneButton must be non-null")); | |
4479 | ||
4480 | wxAuiPaneInfo& pane = *(evt.pane); | |
4481 | ||
4482 | if (evt.button == wxAUI_BUTTON_CLOSE) | |
4483 | { | |
4484 | // fire pane close event | |
4485 | wxAuiManagerEvent e(wxEVT_AUI_PANE_CLOSE); | |
4486 | e.SetManager(this); | |
4487 | e.SetPane(evt.pane); | |
4488 | ProcessMgrEvent(e); | |
4489 | ||
4490 | if (!e.GetVeto()) | |
4491 | { | |
4492 | // close the pane, but check that it | |
4493 | // still exists in our pane array first | |
4494 | // (the event handler above might have removed it) | |
4495 | ||
4496 | wxAuiPaneInfo& check = GetPane(pane.window); | |
4497 | if (check.IsOk()) | |
4498 | { | |
4499 | ClosePane(pane); | |
4500 | } | |
4501 | ||
4502 | Update(); | |
4503 | } | |
4504 | } | |
4505 | else if (evt.button == wxAUI_BUTTON_MAXIMIZE_RESTORE && !pane.IsMaximized()) | |
4506 | { | |
4507 | // fire pane close event | |
4508 | wxAuiManagerEvent e(wxEVT_AUI_PANE_MAXIMIZE); | |
4509 | e.SetManager(this); | |
4510 | e.SetPane(evt.pane); | |
4511 | ProcessMgrEvent(e); | |
4512 | ||
4513 | if (!e.GetVeto()) | |
4514 | { | |
4515 | MaximizePane(pane); | |
4516 | Update(); | |
4517 | } | |
4518 | } | |
4519 | else if (evt.button == wxAUI_BUTTON_MAXIMIZE_RESTORE && pane.IsMaximized()) | |
4520 | { | |
4521 | // fire pane close event | |
4522 | wxAuiManagerEvent e(wxEVT_AUI_PANE_RESTORE); | |
4523 | e.SetManager(this); | |
4524 | e.SetPane(evt.pane); | |
4525 | ProcessMgrEvent(e); | |
4526 | ||
4527 | if (!e.GetVeto()) | |
4528 | { | |
4529 | RestorePane(pane); | |
4530 | Update(); | |
4531 | } | |
4532 | } | |
4533 | else if (evt.button == wxAUI_BUTTON_PIN) | |
4534 | { | |
4535 | if ((m_flags & wxAUI_MGR_ALLOW_FLOATING) && | |
4536 | pane.IsFloatable()) | |
4537 | pane.Float(); | |
4538 | Update(); | |
4539 | } | |
4540 | } | |
4541 | ||
4542 | #endif // wxUSE_AUI |