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