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