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