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