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