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