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