]> git.saurik.com Git - wxWidgets.git/blob - src/aui/framemanager.cpp
wxColour lost its Create method, use direct creation for XTI
[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/settings.h"
34 #include "wx/app.h"
35 #include "wx/dcclient.h"
36 #include "wx/dcscreen.h"
37 #include "wx/toolbar.h"
38 #include "wx/mdi.h"
39 #include "wx/image.h"
40 #endif
41
42 WX_CHECK_BUILD_OPTIONS("wxAUI")
43
44 #include "wx/arrimpl.cpp"
45 WX_DECLARE_OBJARRAY(wxRect, wxAuiRectArray);
46 WX_DEFINE_OBJARRAY(wxAuiRectArray)
47 WX_DEFINE_OBJARRAY(wxDockUIPartArray)
48 WX_DEFINE_OBJARRAY(wxDockInfoArray)
49 WX_DEFINE_OBJARRAY(wxPaneButtonArray)
50 WX_DEFINE_OBJARRAY(wxPaneInfoArray)
51
52 wxPaneInfo wxNullPaneInfo;
53 wxDockInfo wxNullDockInfo;
54 DEFINE_EVENT_TYPE(wxEVT_AUI_PANEBUTTON)
55
56 #ifdef __WXMAC__
57 // a few defines to avoid nameclashes
58 #define __MAC_OS_X_MEMORY_MANAGER_CLEAN__ 1
59 #define __AIFF__
60 #include "wx/mac/private.h"
61 #endif
62
63
64 // -- static utility functions --
65
66 static wxBitmap wxPaneCreateStippleBitmap()
67 {
68 unsigned char data[] = { 0,0,0,192,192,192, 192,192,192,0,0,0 };
69 wxImage img(2,2,data,true);
70 return wxBitmap(img);
71 }
72
73 static void DrawResizeHint(wxDC& dc, const wxRect& rect)
74 {
75 wxBitmap stipple = wxPaneCreateStippleBitmap();
76 wxBrush brush(stipple);
77 dc.SetBrush(brush);
78 dc.SetPen(*wxTRANSPARENT_PEN);
79
80 dc.SetLogicalFunction(wxXOR);
81 dc.DrawRectangle(rect);
82 }
83
84 #ifdef __WXMSW__
85
86 // on supported windows systems (Win2000 and greater), this function
87 // will make a frame window transparent by a certain amount
88 static void MakeWindowTransparent(wxWindow* wnd, int amount)
89 {
90 // this API call is not in all SDKs, only the newer ones, so
91 // we will runtime bind this
92 typedef DWORD (WINAPI *PSETLAYEREDWINDOWATTR)(HWND, DWORD, BYTE, DWORD);
93 static PSETLAYEREDWINDOWATTR pSetLayeredWindowAttributes = NULL;
94 static HMODULE h = NULL;
95 HWND hwnd = (HWND)wnd->GetHWND();
96
97 if (!h)
98 h = LoadLibrary(_T("user32"));
99
100 if (!pSetLayeredWindowAttributes)
101 {
102 pSetLayeredWindowAttributes =
103 (PSETLAYEREDWINDOWATTR)GetProcAddress(h,
104 #ifdef __WXWINCE__
105 wxT("SetLayeredWindowAttributes")
106 #else
107 "SetLayeredWindowAttributes"
108 #endif
109 );
110 }
111
112 if (pSetLayeredWindowAttributes == NULL)
113 return;
114
115 LONG exstyle = GetWindowLong(hwnd, GWL_EXSTYLE);
116 if (0 == (exstyle & 0x80000) /*WS_EX_LAYERED*/)
117 SetWindowLong(hwnd, GWL_EXSTYLE, exstyle | 0x80000 /*WS_EX_LAYERED*/);
118
119 pSetLayeredWindowAttributes(hwnd, 0, (BYTE)amount, 2 /*LWA_ALPHA*/);
120 }
121
122 #endif
123
124
125 // CopyDocksAndPanes() - this utility function creates copies of
126 // the dock and pane info. wxDockInfo's usually contain pointers
127 // to wxPaneInfo classes, thus this function is necessary to reliably
128 // reconstruct that relationship in the new dock info and pane info arrays
129
130 static void CopyDocksAndPanes(wxDockInfoArray& dest_docks,
131 wxPaneInfoArray& dest_panes,
132 const wxDockInfoArray& src_docks,
133 const wxPaneInfoArray& src_panes)
134 {
135 dest_docks = src_docks;
136 dest_panes = src_panes;
137 int i, j, k, dock_count, pc1, pc2;
138 for (i = 0, dock_count = dest_docks.GetCount(); i < dock_count; ++i)
139 {
140 wxDockInfo& dock = dest_docks.Item(i);
141 for (j = 0, pc1 = dock.panes.GetCount(); j < pc1; ++j)
142 for (k = 0, pc2 = src_panes.GetCount(); k < pc2; ++k)
143 if (dock.panes.Item(j) == &src_panes.Item(k))
144 dock.panes.Item(j) = &dest_panes.Item(k);
145 }
146 }
147
148 // GetMaxLayer() is an internal function which returns
149 // the highest layer inside the specified dock
150 static int GetMaxLayer(const wxDockInfoArray& docks, int dock_direction)
151 {
152 int i, dock_count, max_layer = 0;
153 for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
154 {
155 wxDockInfo& dock = docks.Item(i);
156 if (dock.dock_direction == dock_direction &&
157 dock.dock_layer > max_layer && !dock.fixed)
158 max_layer = dock.dock_layer;
159 }
160 return max_layer;
161 }
162
163
164 // GetMaxRow() is an internal function which returns
165 // the highest layer inside the specified dock
166 static int GetMaxRow(const wxPaneInfoArray& panes, int direction, int layer)
167 {
168 int i, pane_count, max_row = 0;
169 for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
170 {
171 wxPaneInfo& pane = panes.Item(i);
172 if (pane.dock_direction == direction &&
173 pane.dock_layer == layer &&
174 pane.dock_row > max_row)
175 max_row = pane.dock_row;
176 }
177 return max_row;
178 }
179
180
181
182 // DoInsertDockLayer() is an internal function that inserts a new dock
183 // layer by incrementing all existing dock layer values by one
184 static void DoInsertDockLayer(wxPaneInfoArray& panes,
185 int dock_direction,
186 int dock_layer)
187 {
188 int i, pane_count;
189 for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
190 {
191 wxPaneInfo& pane = panes.Item(i);
192 if (!pane.IsFloating() &&
193 pane.dock_direction == dock_direction &&
194 pane.dock_layer >= dock_layer)
195 pane.dock_layer++;
196 }
197 }
198
199 // DoInsertDockLayer() is an internal function that inserts a new dock
200 // row by incrementing all existing dock row values by one
201 static void DoInsertDockRow(wxPaneInfoArray& panes,
202 int dock_direction,
203 int dock_layer,
204 int dock_row)
205 {
206 int i, pane_count;
207 for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
208 {
209 wxPaneInfo& pane = panes.Item(i);
210 if (!pane.IsFloating() &&
211 pane.dock_direction == dock_direction &&
212 pane.dock_layer == dock_layer &&
213 pane.dock_row >= dock_row)
214 pane.dock_row++;
215 }
216 }
217
218 // DoInsertDockLayer() is an internal function that inserts a space for
219 // another dock pane by incrementing all existing dock row values by one
220 static void DoInsertPane(wxPaneInfoArray& panes,
221 int dock_direction,
222 int dock_layer,
223 int dock_row,
224 int dock_pos)
225 {
226 int i, pane_count;
227 for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
228 {
229 wxPaneInfo& pane = panes.Item(i);
230 if (!pane.IsFloating() &&
231 pane.dock_direction == dock_direction &&
232 pane.dock_layer == dock_layer &&
233 pane.dock_row == dock_row &&
234 pane.dock_pos >= dock_pos)
235 pane.dock_pos++;
236 }
237 }
238
239 // FindDocks() is an internal function that returns a list of docks which meet
240 // the specified conditions in the parameters and returns a sorted array
241 // (sorted by layer and then row)
242 static void FindDocks(wxDockInfoArray& docks,
243 int dock_direction,
244 int dock_layer,
245 int dock_row,
246 wxDockInfoPtrArray& arr)
247 {
248 int begin_layer = dock_layer;
249 int end_layer = dock_layer;
250 int begin_row = dock_row;
251 int end_row = dock_row;
252 int dock_count = docks.GetCount();
253 int layer, row, i, max_row = 0, max_layer = 0;
254
255 // discover the maximum dock layer and the max row
256 for (i = 0; i < dock_count; ++i)
257 {
258 max_row = wxMax(max_row, docks.Item(i).dock_row);
259 max_layer = wxMax(max_layer, docks.Item(i).dock_layer);
260 }
261
262 // if no dock layer was specified, search all dock layers
263 if (dock_layer == -1)
264 {
265 begin_layer = 0;
266 end_layer = max_layer;
267 }
268
269 // if no dock row was specified, search all dock row
270 if (dock_row == -1)
271 {
272 begin_row = 0;
273 end_row = max_row;
274 }
275
276 arr.Clear();
277
278 for (layer = begin_layer; layer <= end_layer; ++layer)
279 for (row = begin_row; row <= end_row; ++row)
280 for (i = 0; i < dock_count; ++i)
281 {
282 wxDockInfo& d = docks.Item(i);
283 if (dock_direction == -1 || dock_direction == d.dock_direction)
284 {
285 if (d.dock_layer == layer && d.dock_row == row)
286 arr.Add(&d);
287 }
288 }
289 }
290
291 // FindPaneInDock() looks up a specified window pointer inside a dock.
292 // If found, the corresponding wxPaneInfo pointer is returned, otherwise NULL.
293 static wxPaneInfo* FindPaneInDock(const wxDockInfo& dock, wxWindow* window)
294 {
295 int i, count = dock.panes.GetCount();
296 for (i = 0; i < count; ++i)
297 {
298 wxPaneInfo* p = dock.panes.Item(i);
299 if (p->window == window)
300 return p;
301 }
302 return NULL;
303 }
304
305 // RemovePaneFromDocks() removes a pane window from all docks
306 // with a possible exception specified by parameter "except"
307 static void RemovePaneFromDocks(wxDockInfoArray& docks,
308 wxPaneInfo& pane,
309 wxDockInfo* except = NULL)
310 {
311 int i, dock_count;
312 for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
313 {
314 wxDockInfo& d = docks.Item(i);
315 if (&d == except)
316 continue;
317 wxPaneInfo* pi = FindPaneInDock(d, pane.window);
318 if (pi)
319 d.panes.Remove(pi);
320 }
321 }
322
323 // RenumberDockRows() takes a dock and assigns sequential numbers
324 // to existing rows. Basically it takes out the gaps; so if a
325 // dock has rows with numbers 0,2,5, they will become 0,1,2
326 static void RenumberDockRows(wxDockInfoPtrArray& docks)
327 {
328 int i, dock_count, j, pane_count;
329 for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
330 {
331 wxDockInfo& dock = *docks.Item(i);
332 dock.dock_row = i;
333 for (j = 0, pane_count = dock.panes.GetCount(); j < pane_count; ++j)
334 dock.panes.Item(j)->dock_row = i;
335 }
336 }
337
338
339 // SetActivePane() sets the active pane, as well as cycles through
340 // every other pane and makes sure that all others' active flags
341 // are turned off
342 static void SetActivePane(wxPaneInfoArray& panes, wxWindow* active_pane)
343 {
344 int i, pane_count;
345 for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
346 {
347 wxPaneInfo& pane = panes.Item(i);
348 pane.state &= ~wxPaneInfo::optionActive;
349 if (pane.window == active_pane)
350 pane.state |= wxPaneInfo::optionActive;
351 }
352 }
353
354
355 // this function is used to sort panes by dock position
356 static int PaneSortFunc(wxPaneInfo** p1, wxPaneInfo** p2)
357 {
358 return ((*p1)->dock_pos < (*p2)->dock_pos) ? -1 : 1;
359 }
360
361
362 // -- wxFrameManager class implementation --
363
364
365 BEGIN_EVENT_TABLE(wxFrameManager, wxEvtHandler)
366 EVT_AUI_PANEBUTTON(wxFrameManager::OnPaneButton)
367 EVT_PAINT(wxFrameManager::OnPaint)
368 EVT_ERASE_BACKGROUND(wxFrameManager::OnEraseBackground)
369 EVT_SIZE(wxFrameManager::OnSize)
370 EVT_SET_CURSOR(wxFrameManager::OnSetCursor)
371 EVT_LEFT_DOWN(wxFrameManager::OnLeftDown)
372 EVT_LEFT_UP(wxFrameManager::OnLeftUp)
373 EVT_MOTION(wxFrameManager::OnMotion)
374 EVT_LEAVE_WINDOW(wxFrameManager::OnLeaveWindow)
375 EVT_CHILD_FOCUS(wxFrameManager::OnChildFocus)
376 EVT_TIMER(101, wxFrameManager::OnHintFadeTimer)
377 END_EVENT_TABLE()
378
379
380 wxFrameManager::wxFrameManager(wxFrame* frame, unsigned int flags)
381 {
382 m_action = actionNone;
383 m_last_mouse_move = wxPoint();
384 m_hover_button = NULL;
385 m_art = new wxDefaultDockArt;
386 m_hint_wnd = NULL;
387 m_flags = flags;
388
389 if (frame)
390 {
391 SetFrame(frame);
392 }
393 }
394
395 wxFrameManager::~wxFrameManager()
396 {
397 delete m_art;
398 }
399
400 // GetPane() looks up a wxPaneInfo structure based
401 // on the supplied window pointer. Upon failure, GetPane()
402 // returns an empty wxPaneInfo, a condition which can be checked
403 // by calling wxPaneInfo::IsOk().
404 //
405 // The pane info's structure may then be modified. Once a pane's
406 // info is modified, wxFrameManager::Update() must be called to
407 // realize the changes in the UI.
408
409 wxPaneInfo& wxFrameManager::GetPane(wxWindow* window)
410 {
411 int i, pane_count;
412 for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i)
413 {
414 wxPaneInfo& p = m_panes.Item(i);
415 if (p.window == window)
416 return p;
417 }
418 return wxNullPaneInfo;
419 }
420
421 // this version of GetPane() looks up a pane based on a
422 // 'pane name', see above comment for more info
423 wxPaneInfo& wxFrameManager::GetPane(const wxString& name)
424 {
425 int i, pane_count;
426 for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i)
427 {
428 wxPaneInfo& p = m_panes.Item(i);
429 if (p.name == name)
430 return p;
431 }
432 return wxNullPaneInfo;
433 }
434
435 // GetAllPanes() returns a reference to all the pane info structures
436 wxPaneInfoArray& wxFrameManager::GetAllPanes()
437 {
438 return m_panes;
439 }
440
441 // HitTest() is an internal function which determines
442 // which UI item the specified coordinates are over
443 // (x,y) specify a position in client coordinates
444 wxDockUIPart* wxFrameManager::HitTest(int x, int y)
445 {
446 wxDockUIPart* result = NULL;
447
448 int i, part_count;
449 for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i)
450 {
451 wxDockUIPart* item = &m_uiparts.Item(i);
452
453 // we are not interested in typeDock, because this space
454 // isn't used to draw anything, just for measurements;
455 // besides, the entire dock area is covered with other
456 // rectangles, which we are interested in.
457 if (item->type == wxDockUIPart::typeDock)
458 continue;
459
460 // if we already have a hit on a more specific item, we are not
461 // interested in a pane hit. If, however, we don't already have
462 // a hit, returning a pane hit is necessary for some operations
463 if ((item->type == wxDockUIPart::typePane ||
464 item->type == wxDockUIPart::typePaneBorder) && result)
465 continue;
466
467 // if the point is inside the rectangle, we have a hit
468 if (item->rect.Inside(x,y))
469 result = item;
470 }
471
472 return result;
473 }
474
475
476 // SetFlags() and GetFlags() allow the owner to set various
477 // options which are global to wxFrameManager
478 void wxFrameManager::SetFlags(unsigned int flags)
479 {
480 m_flags = flags;
481 }
482
483 unsigned int wxFrameManager::GetFlags() const
484 {
485 return m_flags;
486 }
487
488
489 // SetFrame() is usually called once when the frame
490 // manager class is being initialized. "frame" specifies
491 // the frame which should be managed by the frame mananger
492 void wxFrameManager::SetFrame(wxFrame* frame)
493 {
494 wxASSERT_MSG(frame, wxT("specified frame must be non-NULL"));
495
496 m_frame = frame;
497 m_frame->PushEventHandler(this);
498
499 #if wxUSE_MDI
500 // if the owner is going to manage an MDI parent frame,
501 // we need to add the MDI client window as the default
502 // center pane
503
504 if (frame->IsKindOf(CLASSINFO(wxMDIParentFrame)))
505 {
506 wxMDIParentFrame* mdi_frame = (wxMDIParentFrame*)frame;
507 wxWindow* client_window = mdi_frame->GetClientWindow();
508
509 wxASSERT_MSG(client_window, wxT("Client window is NULL!"));
510
511 AddPane(client_window,
512 wxPaneInfo().Name(wxT("mdiclient")).
513 CenterPane().PaneBorder(false));
514 }
515 #endif
516 }
517
518
519 // UnInit() must be called, usually in the destructor
520 // of the frame class. If it is not called, usually this
521 // will result in a crash upon program exit
522 void wxFrameManager::UnInit()
523 {
524 m_frame->RemoveEventHandler(this);
525 }
526
527 // GetFrame() returns the frame pointer being managed by wxFrameManager
528 wxFrame* wxFrameManager::GetFrame() const
529 {
530 return m_frame;
531 }
532
533 wxDockArt* wxFrameManager::GetArtProvider() const
534 {
535 return m_art;
536 }
537
538 void wxFrameManager::ProcessMgrEvent(wxFrameManagerEvent& event)
539 {
540 // first, give the owner frame a chance to override
541 if (m_frame)
542 {
543 if (m_frame->ProcessEvent(event))
544 return;
545 }
546
547 ProcessEvent(event);
548 }
549
550 // SetArtProvider() instructs wxFrameManager to use the
551 // specified art provider for all drawing calls. This allows
552 // plugable look-and-feel features. The pointer that is
553 // passed to this method subsequently belongs to wxFrameManager,
554 // and is deleted in the frame manager destructor
555 void wxFrameManager::SetArtProvider(wxDockArt* art_provider)
556 {
557 // delete the last art provider, if any
558 delete m_art;
559
560 // assign the new art provider
561 m_art = art_provider;
562 }
563
564
565 bool wxFrameManager::AddPane(wxWindow* window, const wxPaneInfo& pane_info)
566 {
567 // check if the pane has a valid window
568 if (!window)
569 return false;
570
571 // check if the pane already exists
572 if (GetPane(pane_info.window).IsOk())
573 return false;
574
575 m_panes.Add(pane_info);
576
577 wxPaneInfo& pinfo = m_panes.Last();
578
579 // set the pane window
580 pinfo.window = window;
581
582 // if the pane's name identifier is blank, create a random string
583 if (pinfo.name.empty())
584 {
585 pinfo.name.Printf(wxT("%08lx%08x%08x%08lx"),
586 ((unsigned long)pinfo.window) & 0xffffffff,
587 (unsigned int)time(NULL),
588 #ifdef __WXWINCE__
589 (unsigned int)GetTickCount(),
590 #else
591 (unsigned int)clock(),
592 #endif
593 (unsigned long)m_panes.GetCount());
594 }
595
596 // set initial proportion (if not already set)
597 if (pinfo.dock_proportion == 0)
598 pinfo.dock_proportion = 100000;
599
600 if (pinfo.HasCloseButton() &&
601 pinfo.buttons.size() == 0)
602 {
603 wxPaneButton button;
604 button.button_id = wxPaneInfo::buttonClose;
605 pinfo.buttons.Add(button);
606 }
607
608 if (pinfo.best_size == wxDefaultSize &&
609 pinfo.window)
610 {
611 pinfo.best_size = pinfo.window->GetClientSize();
612
613 if (pinfo.window->IsKindOf(CLASSINFO(wxToolBar)))
614 {
615 // GetClientSize() doesn't get the best size for
616 // a toolbar under some newer versions of wxWidgets,
617 // so use GetBestSize()
618 pinfo.best_size = pinfo.window->GetBestSize();
619
620 // for some reason, wxToolBar::GetBestSize() is returning
621 // a size that is a pixel shy of the correct amount.
622 // I believe this to be the correct action, until
623 // wxToolBar::GetBestSize() is fixed. Is this assumption
624 // correct?
625 pinfo.best_size.y++;
626 }
627
628 if (pinfo.min_size != wxDefaultSize)
629 {
630 if (pinfo.best_size.x < pinfo.min_size.x)
631 pinfo.best_size.x = pinfo.min_size.x;
632 if (pinfo.best_size.y < pinfo.min_size.y)
633 pinfo.best_size.y = pinfo.min_size.y;
634 }
635 }
636
637 return true;
638 }
639
640 bool wxFrameManager::AddPane(wxWindow* window,
641 int direction,
642 const wxString& caption)
643 {
644 wxPaneInfo pinfo;
645 pinfo.Caption(caption);
646 switch (direction)
647 {
648 case wxTOP: pinfo.Top(); break;
649 case wxBOTTOM: pinfo.Bottom(); break;
650 case wxLEFT: pinfo.Left(); break;
651 case wxRIGHT: pinfo.Right(); break;
652 case wxCENTER: pinfo.CenterPane(); break;
653 }
654 return AddPane(window, pinfo);
655 }
656
657 bool wxFrameManager::InsertPane(wxWindow* window, const wxPaneInfo& pane_info,
658 int insert_level)
659 {
660 // shift the panes around, depending on the insert level
661 switch (insert_level)
662 {
663 case wxAUI_INSERT_PANE:
664 DoInsertPane(m_panes,
665 pane_info.dock_direction,
666 pane_info.dock_layer,
667 pane_info.dock_row,
668 pane_info.dock_pos);
669 break;
670 case wxAUI_INSERT_ROW:
671 DoInsertDockRow(m_panes,
672 pane_info.dock_direction,
673 pane_info.dock_layer,
674 pane_info.dock_row);
675 break;
676 case wxAUI_INSERT_DOCK:
677 DoInsertDockLayer(m_panes,
678 pane_info.dock_direction,
679 pane_info.dock_layer);
680 break;
681 }
682
683 // if the window already exists, we are basically just moving/inserting the
684 // existing window. If it doesn't exist, we need to add it and insert it
685 wxPaneInfo& existing_pane = GetPane(window);
686 if (!existing_pane.IsOk())
687 {
688 return AddPane(window, pane_info);
689 }
690 else
691 {
692 if (pane_info.IsFloating())
693 {
694 existing_pane.Float();
695 if (pane_info.floating_pos != wxDefaultPosition)
696 existing_pane.FloatingPosition(pane_info.floating_pos);
697 if (pane_info.floating_size != wxDefaultSize)
698 existing_pane.FloatingSize(pane_info.floating_size);
699 }
700 else
701 {
702 existing_pane.Direction(pane_info.dock_direction);
703 existing_pane.Layer(pane_info.dock_layer);
704 existing_pane.Row(pane_info.dock_row);
705 existing_pane.Position(pane_info.dock_pos);
706 }
707 }
708
709 return true;
710 }
711
712
713 // DetachPane() removes a pane from the frame manager. This
714 // method will not destroy the window that is removed.
715 bool wxFrameManager::DetachPane(wxWindow* window)
716 {
717 int i, count;
718 for (i = 0, count = m_panes.GetCount(); i < count; ++i)
719 {
720 wxPaneInfo& p = m_panes.Item(i);
721 if (p.window == window)
722 {
723 if (p.frame)
724 {
725 // we have a floating frame which is being detached. We need to
726 // reparent it to m_frame and destroy the floating frame
727
728 // reduce flicker
729 p.window->SetSize(1,1);
730 p.frame->Show(false);
731
732 // reparent to m_frame and destroy the pane
733 p.window->Reparent(m_frame);
734 p.frame->SetSizer(NULL);
735 p.frame->Destroy();
736 p.frame = NULL;
737 }
738 m_panes.RemoveAt(i);
739 return true;
740 }
741 }
742 return false;
743 }
744
745
746 // EscapeDelimiters() changes ";" into "\;" and "|" into "\|"
747 // in the input string. This is an internal functions which is
748 // used for saving perspectives
749 static wxString EscapeDelimiters(const wxString& s)
750 {
751 wxString result;
752 result.Alloc(s.length());
753 const wxChar* ch = s.c_str();
754 while (*ch)
755 {
756 if (*ch == wxT(';') || *ch == wxT('|'))
757 result += wxT('\\');
758 result += *ch;
759 ++ch;
760 }
761 return result;
762 }
763
764
765 // SavePerspective() saves all pane information as a single string.
766 // This string may later be fed into LoadPerspective() to restore
767 // all pane settings. This save and load mechanism allows an
768 // exact pane configuration to be saved and restored at a later time
769
770 wxString wxFrameManager::SavePerspective()
771 {
772 wxString result;
773 result.Alloc(500);
774 result = wxT("layout1|");
775
776 int pane_i, pane_count = m_panes.GetCount();
777 for (pane_i = 0; pane_i < pane_count; ++pane_i)
778 {
779 wxPaneInfo& pane = m_panes.Item(pane_i);
780
781 result += wxT("name=");
782 result += EscapeDelimiters(pane.name);
783 result += wxT(";");
784
785 result += wxT("caption=");
786 result += EscapeDelimiters(pane.caption);
787 result += wxT(";");
788
789 result += wxString::Format(wxT("state=%u;"), pane.state);
790 result += wxString::Format(wxT("dir=%d;"), pane.dock_direction);
791 result += wxString::Format(wxT("layer=%d;"), pane.dock_layer);
792 result += wxString::Format(wxT("row=%d;"), pane.dock_row);
793 result += wxString::Format(wxT("pos=%d;"), pane.dock_pos);
794 result += wxString::Format(wxT("prop=%d;"), pane.dock_proportion);
795 result += wxString::Format(wxT("bestw=%d;"), pane.best_size.x);
796 result += wxString::Format(wxT("besth=%d;"), pane.best_size.y);
797 result += wxString::Format(wxT("minw=%d;"), pane.min_size.x);
798 result += wxString::Format(wxT("minh=%d;"), pane.min_size.y);
799 result += wxString::Format(wxT("maxw=%d;"), pane.max_size.x);
800 result += wxString::Format(wxT("maxh=%d;"), pane.max_size.y);
801 result += wxString::Format(wxT("floatx=%d;"), pane.floating_pos.x);
802 result += wxString::Format(wxT("floaty=%d;"), pane.floating_pos.y);
803 result += wxString::Format(wxT("floatw=%d;"), pane.floating_size.x);
804 result += wxString::Format(wxT("floath=%d"), pane.floating_size.y);
805 result += wxT("|");
806 }
807
808 int dock_i, dock_count = m_docks.GetCount();
809 for (dock_i = 0; dock_i < dock_count; ++dock_i)
810 {
811 wxDockInfo& dock = m_docks.Item(dock_i);
812
813 result += wxString::Format(wxT("dock_size(%d,%d,%d)=%d|"),
814 dock.dock_direction, dock.dock_layer,
815 dock.dock_row, dock.size);
816 }
817
818 return result;
819 }
820
821 // LoadPerspective() loads a layout which was saved with SavePerspective()
822 // If the "update" flag parameter is true, the GUI will immediately be updated
823
824 bool wxFrameManager::LoadPerspective(const wxString& layout, bool update)
825 {
826 wxString input = layout;
827 wxString part;
828
829 // check layout string version
830 part = input.BeforeFirst(wxT('|'));
831 input = input.AfterFirst(wxT('|'));
832 part.Trim(true);
833 part.Trim(false);
834 if (part != wxT("layout1"))
835 return false;
836
837
838 // mark all panes currently managed as docked and hidden
839 int pane_i, pane_count = m_panes.GetCount();
840 for (pane_i = 0; pane_i < pane_count; ++pane_i)
841 m_panes.Item(pane_i).Dock().Hide();
842
843 // clear out the dock array; this will be reconstructed
844 m_docks.Clear();
845
846 // replace escaped characters so we can
847 // split up the string easily
848 input.Replace(wxT("\\|"), wxT("\a"));
849 input.Replace(wxT("\\;"), wxT("\b"));
850
851 while (1)
852 {
853 wxPaneInfo pane;
854
855 wxString pane_part = input.BeforeFirst(wxT('|'));
856 input = input.AfterFirst(wxT('|'));
857 pane_part.Trim(true);
858
859 // if the string is empty, we're done parsing
860 if (pane_part.empty())
861 break;
862
863
864 if (pane_part.Left(9) == wxT("dock_size"))
865 {
866 wxString val_name = pane_part.BeforeFirst(wxT('='));
867 wxString value = pane_part.AfterFirst(wxT('='));
868
869 long dir, layer, row, size;
870 wxString piece = val_name.AfterFirst(wxT('('));
871 piece = piece.BeforeLast(wxT(')'));
872 piece.BeforeFirst(wxT(',')).ToLong(&dir);
873 piece = piece.AfterFirst(wxT(','));
874 piece.BeforeFirst(wxT(',')).ToLong(&layer);
875 piece.AfterFirst(wxT(',')).ToLong(&row);
876 value.ToLong(&size);
877
878 wxDockInfo dock;
879 dock.dock_direction = dir;
880 dock.dock_layer = layer;
881 dock.dock_row = row;
882 dock.size = size;
883 m_docks.Add(dock);
884 continue;
885 }
886
887 while (1)
888 {
889 wxString val_part = pane_part.BeforeFirst(wxT(';'));
890 pane_part = pane_part.AfterFirst(wxT(';'));
891 wxString val_name = val_part.BeforeFirst(wxT('='));
892 wxString value = val_part.AfterFirst(wxT('='));
893 val_name.MakeLower();
894 val_name.Trim(true);
895 val_name.Trim(false);
896 value.Trim(true);
897 value.Trim(false);
898
899 if (val_name.empty())
900 break;
901
902 if (val_name == wxT("name"))
903 pane.name = value;
904 else if (val_name == wxT("caption"))
905 pane.caption = value;
906 else if (val_name == wxT("state"))
907 pane.state = (unsigned int)wxAtoi(value.c_str());
908 else if (val_name == wxT("dir"))
909 pane.dock_direction = wxAtoi(value.c_str());
910 else if (val_name == wxT("layer"))
911 pane.dock_layer = wxAtoi(value.c_str());
912 else if (val_name == wxT("row"))
913 pane.dock_row = wxAtoi(value.c_str());
914 else if (val_name == wxT("pos"))
915 pane.dock_pos = wxAtoi(value.c_str());
916 else if (val_name == wxT("prop"))
917 pane.dock_proportion = wxAtoi(value.c_str());
918 else if (val_name == wxT("bestw"))
919 pane.best_size.x = wxAtoi(value.c_str());
920 else if (val_name == wxT("besth"))
921 pane.best_size.y = wxAtoi(value.c_str());
922 else if (val_name == wxT("minw"))
923 pane.min_size.x = wxAtoi(value.c_str());
924 else if (val_name == wxT("minh"))
925 pane.min_size.y = wxAtoi(value.c_str());
926 else if (val_name == wxT("maxw"))
927 pane.max_size.x = wxAtoi(value.c_str());
928 else if (val_name == wxT("maxh"))
929 pane.max_size.y = wxAtoi(value.c_str());
930 else if (val_name == wxT("floatx"))
931 pane.floating_pos.x = wxAtoi(value.c_str());
932 else if (val_name == wxT("floaty"))
933 pane.floating_pos.y = wxAtoi(value.c_str());
934 else if (val_name == wxT("floatw"))
935 pane.floating_size.x = wxAtoi(value.c_str());
936 else if (val_name == wxT("floath"))
937 pane.floating_size.y = wxAtoi(value.c_str());
938 else {
939 wxFAIL_MSG(wxT("Bad Perspective String"));
940 }
941 }
942
943 // replace escaped characters so we can
944 // split up the string easily
945 pane.name.Replace(wxT("\a"), wxT("|"));
946 pane.name.Replace(wxT("\b"), wxT(";"));
947 pane.caption.Replace(wxT("\a"), wxT("|"));
948 pane.caption.Replace(wxT("\b"), wxT(";"));
949
950 wxPaneInfo& p = GetPane(pane.name);
951 if (!p.IsOk())
952 {
953 // the pane window couldn't be found
954 // in the existing layout
955 return false;
956 }
957
958 pane.window = p.window;
959 pane.frame = p.frame;
960 pane.buttons = p.buttons;
961 p = pane;
962 }
963
964 if (update)
965 Update();
966
967 return true;
968 }
969
970
971 void wxFrameManager::GetPanePositionsAndSizes(wxDockInfo& dock,
972 wxArrayInt& positions,
973 wxArrayInt& sizes)
974 {
975 int caption_size = m_art->GetMetric(wxAUI_ART_CAPTION_SIZE);
976 int pane_border_size = m_art->GetMetric(wxAUI_ART_PANE_BORDER_SIZE);
977 int gripper_size = m_art->GetMetric(wxAUI_ART_GRIPPER_SIZE);
978
979 positions.Empty();
980 sizes.Empty();
981
982 int offset, action_pane = -1;
983 int pane_i, pane_count = dock.panes.GetCount();
984
985 // find the pane marked as our action pane
986 for (pane_i = 0; pane_i < pane_count; ++pane_i)
987 {
988 wxPaneInfo& pane = *(dock.panes.Item(pane_i));
989
990 if (pane.state & wxPaneInfo::actionPane)
991 {
992 wxASSERT_MSG(action_pane==-1, wxT("Too many fixed action panes"));
993 action_pane = pane_i;
994 }
995 }
996
997 // set up each panes default position, and
998 // determine the size (width or height, depending
999 // on the dock's orientation) of each pane
1000 for (pane_i = 0; pane_i < pane_count; ++pane_i)
1001 {
1002 wxPaneInfo& pane = *(dock.panes.Item(pane_i));
1003 positions.Add(pane.dock_pos);
1004 int size = 0;
1005
1006 if (pane.HasBorder())
1007 size += (pane_border_size*2);
1008
1009 if (dock.IsHorizontal())
1010 {
1011 if (pane.HasGripper() && !pane.HasGripperTop())
1012 size += gripper_size;
1013 size += pane.best_size.x;
1014 }
1015 else
1016 {
1017 if (pane.HasGripper() && pane.HasGripperTop())
1018 size += gripper_size;
1019
1020 if (pane.HasCaption())
1021 size += caption_size;
1022 size += pane.best_size.y;
1023 }
1024
1025 sizes.Add(size);
1026 }
1027
1028 // if there is no action pane, just return the default
1029 // positions (as specified in pane.pane_pos)
1030 if (action_pane == -1)
1031 return;
1032
1033 offset = 0;
1034 for (pane_i = action_pane-1; pane_i >= 0; --pane_i)
1035 {
1036 int amount = positions[pane_i+1] - (positions[pane_i] + sizes[pane_i]);
1037
1038 if (amount >= 0)
1039 offset += amount;
1040 else
1041 positions[pane_i] -= -amount;
1042
1043 offset += sizes[pane_i];
1044 }
1045
1046 // if the dock mode is fixed, make sure none of the panes
1047 // overlap; we will bump panes that overlap
1048 offset = 0;
1049 for (pane_i = action_pane; pane_i < pane_count; ++pane_i)
1050 {
1051 int amount = positions[pane_i] - offset;
1052 if (amount >= 0)
1053 offset += amount;
1054 else
1055 positions[pane_i] += -amount;
1056
1057 offset += sizes[pane_i];
1058 }
1059 }
1060
1061
1062 void wxFrameManager::LayoutAddPane(wxSizer* cont,
1063 wxDockInfo& dock,
1064 wxPaneInfo& pane,
1065 wxDockUIPartArray& uiparts,
1066 bool spacer_only)
1067 {
1068 wxDockUIPart part;
1069 wxSizerItem* sizer_item;
1070
1071 int caption_size = m_art->GetMetric(wxAUI_ART_CAPTION_SIZE);
1072 int gripper_size = m_art->GetMetric(wxAUI_ART_GRIPPER_SIZE);
1073 int pane_border_size = m_art->GetMetric(wxAUI_ART_PANE_BORDER_SIZE);
1074 int pane_button_size = m_art->GetMetric(wxAUI_ART_PANE_BUTTON_SIZE);
1075
1076 // find out the orientation of the item (orientation for panes
1077 // is the same as the dock's orientation)
1078 int orientation;
1079 if (dock.IsHorizontal())
1080 orientation = wxHORIZONTAL;
1081 else
1082 orientation = wxVERTICAL;
1083
1084 // this variable will store the proportion
1085 // value that the pane will receive
1086 int pane_proportion = pane.dock_proportion;
1087
1088 wxBoxSizer* horz_pane_sizer = new wxBoxSizer(wxHORIZONTAL);
1089 wxBoxSizer* vert_pane_sizer = new wxBoxSizer(wxVERTICAL);
1090
1091 if (pane.HasGripper())
1092 {
1093 if (pane.HasGripperTop())
1094 sizer_item = vert_pane_sizer ->Add(1, gripper_size, 0, wxEXPAND);
1095 else
1096 sizer_item = horz_pane_sizer ->Add(gripper_size, 1, 0, wxEXPAND);
1097
1098 part.type = wxDockUIPart::typeGripper;
1099 part.dock = &dock;
1100 part.pane = &pane;
1101 part.button = NULL;
1102 part.orientation = orientation;
1103 part.cont_sizer = horz_pane_sizer;
1104 part.sizer_item = sizer_item;
1105 uiparts.Add(part);
1106 }
1107
1108 if (pane.HasCaption())
1109 {
1110 // create the caption sizer
1111 wxBoxSizer* caption_sizer = new wxBoxSizer(wxHORIZONTAL);
1112
1113 sizer_item = caption_sizer->Add(1, caption_size, 1, wxEXPAND);
1114
1115 part.type = wxDockUIPart::typeCaption;
1116 part.dock = &dock;
1117 part.pane = &pane;
1118 part.button = NULL;
1119 part.orientation = orientation;
1120 part.cont_sizer = vert_pane_sizer;
1121 part.sizer_item = sizer_item;
1122 int caption_part_idx = uiparts.GetCount();
1123 uiparts.Add(part);
1124
1125 // add pane buttons to the caption
1126 int i, button_count;
1127 for (i = 0, button_count = pane.buttons.GetCount();
1128 i < button_count; ++i)
1129 {
1130 wxPaneButton& button = pane.buttons.Item(i);
1131
1132 sizer_item = caption_sizer->Add(pane_button_size,
1133 caption_size,
1134 0, wxEXPAND);
1135
1136 part.type = wxDockUIPart::typePaneButton;
1137 part.dock = &dock;
1138 part.pane = &pane;
1139 part.button = &button;
1140 part.orientation = orientation;
1141 part.cont_sizer = caption_sizer;
1142 part.sizer_item = sizer_item;
1143 uiparts.Add(part);
1144 }
1145
1146 // add the caption sizer
1147 sizer_item = vert_pane_sizer->Add(caption_sizer, 0, wxEXPAND);
1148
1149 uiparts.Item(caption_part_idx).sizer_item = sizer_item;
1150 }
1151
1152 // add the pane window itself
1153 if (spacer_only)
1154 {
1155 sizer_item = vert_pane_sizer->Add(1, 1, 1, wxEXPAND);
1156 }
1157 else
1158 {
1159 sizer_item = vert_pane_sizer->Add(pane.window, 1, wxEXPAND);
1160 vert_pane_sizer->SetItemMinSize(pane.window, 1, 1);
1161 }
1162
1163 part.type = wxDockUIPart::typePane;
1164 part.dock = &dock;
1165 part.pane = &pane;
1166 part.button = NULL;
1167 part.orientation = orientation;
1168 part.cont_sizer = vert_pane_sizer;
1169 part.sizer_item = sizer_item;
1170 uiparts.Add(part);
1171
1172
1173 // determine if the pane should have a minimum size; if the pane is
1174 // non-resizable (fixed) then we must set a minimum size. Alternitavely,
1175 // if the pane.min_size is set, we must use that value as well
1176
1177 wxSize min_size = pane.min_size;
1178 if (pane.IsFixed())
1179 {
1180 if (min_size == wxDefaultSize)
1181 {
1182 min_size = pane.best_size;
1183 pane_proportion = 0;
1184 }
1185 }
1186
1187 if (min_size != wxDefaultSize)
1188 {
1189 vert_pane_sizer->SetItemMinSize(
1190 vert_pane_sizer->GetChildren().GetCount()-1,
1191 min_size.x, min_size.y);
1192 }
1193
1194
1195 // add the verticle sizer (caption, pane window) to the
1196 // horizontal sizer (gripper, verticle sizer)
1197 horz_pane_sizer->Add(vert_pane_sizer, 1, wxEXPAND);
1198
1199 // finally, add the pane sizer to the dock sizer
1200
1201 if (pane.HasBorder())
1202 {
1203 // allowing space for the pane's border
1204 sizer_item = cont->Add(horz_pane_sizer, pane_proportion,
1205 wxEXPAND | wxALL, pane_border_size);
1206
1207 part.type = wxDockUIPart::typePaneBorder;
1208 part.dock = &dock;
1209 part.pane = &pane;
1210 part.button = NULL;
1211 part.orientation = orientation;
1212 part.cont_sizer = cont;
1213 part.sizer_item = sizer_item;
1214 uiparts.Add(part);
1215 }
1216 else
1217 {
1218 sizer_item = cont->Add(horz_pane_sizer, pane_proportion, wxEXPAND);
1219 }
1220 }
1221
1222 void wxFrameManager::LayoutAddDock(wxSizer* cont,
1223 wxDockInfo& dock,
1224 wxDockUIPartArray& uiparts,
1225 bool spacer_only)
1226 {
1227 wxSizerItem* sizer_item;
1228 wxDockUIPart part;
1229
1230 int sash_size = m_art->GetMetric(wxAUI_ART_SASH_SIZE);
1231 int orientation = dock.IsHorizontal() ? wxHORIZONTAL : wxVERTICAL;
1232
1233 // resizable bottom and right docks have a sash before them
1234 if (!dock.fixed && (dock.dock_direction == wxAUI_DOCK_BOTTOM ||
1235 dock.dock_direction == wxAUI_DOCK_RIGHT))
1236 {
1237 sizer_item = cont->Add(sash_size, sash_size, 0, wxEXPAND);
1238
1239 part.type = wxDockUIPart::typeDockSizer;
1240 part.orientation = orientation;
1241 part.dock = &dock;
1242 part.pane = NULL;
1243 part.button = NULL;
1244 part.cont_sizer = cont;
1245 part.sizer_item = sizer_item;
1246 uiparts.Add(part);
1247 }
1248
1249 // create the sizer for the dock
1250 wxSizer* dock_sizer = new wxBoxSizer(orientation);
1251
1252 // add each pane to the dock
1253 int pane_i, pane_count = dock.panes.GetCount();
1254
1255 if (dock.fixed)
1256 {
1257 wxArrayInt pane_positions, pane_sizes;
1258
1259 // figure out the real pane positions we will
1260 // use, without modifying the each pane's pane_pos member
1261 GetPanePositionsAndSizes(dock, pane_positions, pane_sizes);
1262
1263 int offset = 0;
1264 for (pane_i = 0; pane_i < pane_count; ++pane_i)
1265 {
1266 wxPaneInfo& pane = *(dock.panes.Item(pane_i));
1267 int pane_pos = pane_positions.Item(pane_i);
1268
1269 int amount = pane_pos - offset;
1270 if (amount > 0)
1271 {
1272 if (dock.IsVertical())
1273 sizer_item = dock_sizer->Add(1, amount, 0, wxEXPAND);
1274 else
1275 sizer_item = dock_sizer->Add(amount, 1, 0, wxEXPAND);
1276
1277 part.type = wxDockUIPart::typeBackground;
1278 part.dock = &dock;
1279 part.pane = NULL;
1280 part.button = NULL;
1281 part.orientation = (orientation==wxHORIZONTAL) ? wxVERTICAL:wxHORIZONTAL;
1282 part.cont_sizer = dock_sizer;
1283 part.sizer_item = sizer_item;
1284 uiparts.Add(part);
1285
1286 offset += amount;
1287 }
1288
1289 LayoutAddPane(dock_sizer, dock, pane, uiparts, spacer_only);
1290
1291 offset += pane_sizes.Item(pane_i);
1292 }
1293
1294 // at the end add a very small stretchable background area
1295 sizer_item = dock_sizer->Add(1,1, 1, wxEXPAND);
1296
1297 part.type = wxDockUIPart::typeBackground;
1298 part.dock = &dock;
1299 part.pane = NULL;
1300 part.button = NULL;
1301 part.orientation = orientation;
1302 part.cont_sizer = dock_sizer;
1303 part.sizer_item = sizer_item;
1304 uiparts.Add(part);
1305 }
1306 else
1307 {
1308 for (pane_i = 0; pane_i < pane_count; ++pane_i)
1309 {
1310 wxPaneInfo& pane = *(dock.panes.Item(pane_i));
1311
1312 // if this is not the first pane being added,
1313 // we need to add a pane sizer
1314 if (pane_i > 0)
1315 {
1316 sizer_item = dock_sizer->Add(sash_size, sash_size, 0, wxEXPAND);
1317
1318 part.type = wxDockUIPart::typePaneSizer;
1319 part.dock = &dock;
1320 part.pane = dock.panes.Item(pane_i-1);
1321 part.button = NULL;
1322 part.orientation = (orientation==wxHORIZONTAL) ? wxVERTICAL:wxHORIZONTAL;
1323 part.cont_sizer = dock_sizer;
1324 part.sizer_item = sizer_item;
1325 uiparts.Add(part);
1326 }
1327
1328 LayoutAddPane(dock_sizer, dock, pane, uiparts, spacer_only);
1329 }
1330 }
1331
1332 if (dock.dock_direction == wxAUI_DOCK_CENTER)
1333 sizer_item = cont->Add(dock_sizer, 1, wxEXPAND);
1334 else
1335 sizer_item = cont->Add(dock_sizer, 0, wxEXPAND);
1336
1337 part.type = wxDockUIPart::typeDock;
1338 part.dock = &dock;
1339 part.pane = NULL;
1340 part.button = NULL;
1341 part.orientation = orientation;
1342 part.cont_sizer = cont;
1343 part.sizer_item = sizer_item;
1344 uiparts.Add(part);
1345
1346 if (dock.IsHorizontal())
1347 cont->SetItemMinSize(dock_sizer, 0, dock.size);
1348 else
1349 cont->SetItemMinSize(dock_sizer, dock.size, 0);
1350
1351 // top and left docks have a sash after them
1352 if (!dock.fixed && (dock.dock_direction == wxAUI_DOCK_TOP ||
1353 dock.dock_direction == wxAUI_DOCK_LEFT))
1354 {
1355 sizer_item = cont->Add(sash_size, sash_size, 0, wxEXPAND);
1356
1357 part.type = wxDockUIPart::typeDockSizer;
1358 part.dock = &dock;
1359 part.pane = NULL;
1360 part.button = NULL;
1361 part.orientation = orientation;
1362 part.cont_sizer = cont;
1363 part.sizer_item = sizer_item;
1364 uiparts.Add(part);
1365 }
1366 }
1367
1368 wxSizer* wxFrameManager::LayoutAll(wxPaneInfoArray& panes,
1369 wxDockInfoArray& docks,
1370 wxDockUIPartArray& uiparts,
1371 bool spacer_only)
1372 {
1373 wxBoxSizer* container = new wxBoxSizer(wxVERTICAL);
1374
1375 int pane_border_size = m_art->GetMetric(wxAUI_ART_PANE_BORDER_SIZE);
1376 int caption_size = m_art->GetMetric(wxAUI_ART_CAPTION_SIZE);
1377 wxSize cli_size = m_frame->GetClientSize();
1378 int i, dock_count, pane_count;
1379
1380
1381 // empty all docks out
1382 for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
1383 docks.Item(i).panes.Empty();
1384
1385 // iterate through all known panes, filing each
1386 // of them into the appropriate dock. If the
1387 // pane does not exist in the dock, add it
1388 for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
1389 {
1390 wxPaneInfo& p = panes.Item(i);
1391
1392 // find any docks in this layer
1393 wxDockInfo* dock;
1394 wxDockInfoPtrArray arr;
1395 FindDocks(docks, p.dock_direction, p.dock_layer, p.dock_row, arr);
1396
1397 if (arr.GetCount() > 0)
1398 {
1399 dock = arr.Item(0);
1400 }
1401 else
1402 {
1403 // dock was not found, so we need to create a new one
1404 wxDockInfo d;
1405 d.dock_direction = p.dock_direction;
1406 d.dock_layer = p.dock_layer;
1407 d.dock_row = p.dock_row;
1408 docks.Add(d);
1409 dock = &docks.Last();
1410 }
1411
1412
1413 if (p.IsDocked() && p.IsShown())
1414 {
1415 // remove the pane from any existing docks except this one
1416 RemovePaneFromDocks(docks, p, dock);
1417
1418 // pane needs to be added to the dock,
1419 // if it doesn't already exist
1420 if (!FindPaneInDock(*dock, p.window))
1421 dock->panes.Add(&p);
1422 }
1423 else
1424 {
1425 // remove the pane from any existing docks
1426 RemovePaneFromDocks(docks, p);
1427 }
1428
1429 }
1430
1431 // remove any empty docks
1432 for (i = docks.GetCount()-1; i >= 0; --i)
1433 {
1434 if (docks.Item(i).panes.GetCount() == 0)
1435 docks.RemoveAt(i);
1436 }
1437
1438 // configure the docks further
1439 for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
1440 {
1441 wxDockInfo& dock = docks.Item(i);
1442 int j, dock_pane_count = dock.panes.GetCount();
1443
1444 // sort the dock pane array by the pane's
1445 // dock position (dock_pos), in ascending order
1446 dock.panes.Sort(PaneSortFunc);
1447
1448 // for newly created docks, set up their initial size
1449 if (dock.size == 0)
1450 {
1451 int size = 0;
1452
1453 for (j = 0; j < dock_pane_count; ++j)
1454 {
1455 wxPaneInfo& pane = *dock.panes.Item(j);
1456 wxSize pane_size = pane.best_size;
1457 if (pane_size == wxDefaultSize)
1458 pane_size = pane.min_size;
1459 if (pane_size == wxDefaultSize)
1460 pane_size = pane.window->GetSize();
1461
1462 if (dock.IsHorizontal())
1463 size = wxMax(pane_size.y, size);
1464 else
1465 size = wxMax(pane_size.x, size);
1466 }
1467
1468 // add space for the border (two times), but only
1469 // if at least one pane inside the dock has a pane border
1470 for (j = 0; j < dock_pane_count; ++j)
1471 {
1472 if (dock.panes.Item(j)->HasBorder())
1473 {
1474 size += (pane_border_size*2);
1475 break;
1476 }
1477 }
1478
1479 // if pane is on the top or bottom, add the caption height,
1480 // but only if at least one pane inside the dock has a caption
1481 if (dock.IsHorizontal())
1482 {
1483 for (j = 0; j < dock_pane_count; ++j)
1484 {
1485 if (dock.panes.Item(j)->HasCaption())
1486 {
1487 size += caption_size;
1488 break;
1489 }
1490 }
1491 }
1492
1493 // new dock's size may not be more than 1/3 of the frame size
1494 if (dock.IsHorizontal())
1495 size = wxMin(size, cli_size.y/3);
1496 else
1497 size = wxMin(size, cli_size.x/3);
1498
1499 if (size < 10)
1500 size = 10;
1501 dock.size = size;
1502 }
1503
1504
1505 // determine the dock's minimum size
1506 bool plus_border = false;
1507 bool plus_caption = false;
1508 int dock_min_size = 0;
1509 for (j = 0; j < dock_pane_count; ++j)
1510 {
1511 wxPaneInfo& pane = *dock.panes.Item(j);
1512 if (pane.min_size != wxDefaultSize)
1513 {
1514 if (pane.HasBorder())
1515 plus_border = true;
1516 if (pane.HasCaption())
1517 plus_caption = true;
1518 if (dock.IsHorizontal())
1519 {
1520 if (pane.min_size.y > dock_min_size)
1521 dock_min_size = pane.min_size.y;
1522 }
1523 else
1524 {
1525 if (pane.min_size.x > dock_min_size)
1526 dock_min_size = pane.min_size.x;
1527 }
1528 }
1529 }
1530
1531 if (plus_border)
1532 dock_min_size += (pane_border_size*2);
1533 if (plus_caption && dock.IsHorizontal())
1534 dock_min_size += (caption_size);
1535
1536 dock.min_size = dock_min_size;
1537
1538
1539 // if the pane's current size is less than it's
1540 // minimum, increase the dock's size to it's minimum
1541 if (dock.size < dock.min_size)
1542 dock.size = dock.min_size;
1543
1544
1545 // determine the dock's mode (fixed or proportional);
1546 // determine whether the dock has only toolbars
1547 bool action_pane_marked = false;
1548 dock.fixed = true;
1549 dock.toolbar = true;
1550 for (j = 0; j < dock_pane_count; ++j)
1551 {
1552 wxPaneInfo& pane = *dock.panes.Item(j);
1553 if (!pane.IsFixed())
1554 dock.fixed = false;
1555 if (!pane.IsToolbar())
1556 dock.toolbar = false;
1557 if (pane.state & wxPaneInfo::actionPane)
1558 action_pane_marked = true;
1559 }
1560
1561
1562 // if the dock mode is proportional and not fixed-pixel,
1563 // reassign the dock_pos to the sequential 0, 1, 2, 3;
1564 // e.g. remove gaps like 1, 2, 30, 500
1565 if (!dock.fixed)
1566 {
1567 for (j = 0; j < dock_pane_count; ++j)
1568 {
1569 wxPaneInfo& pane = *dock.panes.Item(j);
1570 pane.dock_pos = j;
1571 }
1572 }
1573
1574 // if the dock mode is fixed, and none of the panes
1575 // are being moved right now, make sure the panes
1576 // do not overlap each other. If they do, we will
1577 // adjust the panes' positions
1578 if (dock.fixed && !action_pane_marked)
1579 {
1580 wxArrayInt pane_positions, pane_sizes;
1581 GetPanePositionsAndSizes(dock, pane_positions, pane_sizes);
1582
1583 int offset = 0;
1584 for (j = 0; j < dock_pane_count; ++j)
1585 {
1586 wxPaneInfo& pane = *(dock.panes.Item(j));
1587 pane.dock_pos = pane_positions[j];
1588
1589 int amount = pane.dock_pos - offset;
1590 if (amount >= 0)
1591 offset += amount;
1592 else
1593 pane.dock_pos += -amount;
1594
1595 offset += pane_sizes[j];
1596 }
1597 }
1598 }
1599
1600 // discover the maximum dock layer
1601 int max_layer = 0;
1602 for (i = 0; i < dock_count; ++i)
1603 max_layer = wxMax(max_layer, docks.Item(i).dock_layer);
1604
1605
1606 // clear out uiparts
1607 uiparts.Empty();
1608
1609 // create a bunch of box sizers,
1610 // from the innermost level outwards.
1611 wxSizer* cont = NULL;
1612 wxSizer* middle = NULL;
1613 int layer = 0;
1614 int row, row_count;
1615
1616 for (layer = 0; layer <= max_layer; ++layer)
1617 {
1618 wxDockInfoPtrArray arr;
1619
1620 // find any docks in this layer
1621 FindDocks(docks, -1, layer, -1, arr);
1622
1623 // if there aren't any, skip to the next layer
1624 if (arr.IsEmpty())
1625 continue;
1626
1627 wxSizer* old_cont = cont;
1628
1629 // create a container which will hold this layer's
1630 // docks (top, bottom, left, right)
1631 cont = new wxBoxSizer(wxVERTICAL);
1632
1633
1634 // find any top docks in this layer
1635 FindDocks(docks, wxAUI_DOCK_TOP, layer, -1, arr);
1636 RenumberDockRows(arr);
1637 if (!arr.IsEmpty())
1638 {
1639 for (row = 0, row_count = arr.GetCount(); row < row_count; ++row)
1640 LayoutAddDock(cont, *arr.Item(row), uiparts, spacer_only);
1641 }
1642
1643
1644 // fill out the middle layer (which consists
1645 // of left docks, content area and right docks)
1646
1647 middle = new wxBoxSizer(wxHORIZONTAL);
1648
1649 // find any left docks in this layer
1650 FindDocks(docks, wxAUI_DOCK_LEFT, layer, -1, arr);
1651 RenumberDockRows(arr);
1652 if (!arr.IsEmpty())
1653 {
1654 for (row = 0, row_count = arr.GetCount(); row < row_count; ++row)
1655 LayoutAddDock(middle, *arr.Item(row), uiparts, spacer_only);
1656 }
1657
1658 // add content dock (or previous layer's sizer
1659 // to the middle
1660 if (!old_cont)
1661 {
1662 // find any center docks
1663 FindDocks(docks, wxAUI_DOCK_CENTER, -1, -1, arr);
1664 if (!arr.IsEmpty())
1665 {
1666 for (row = 0,row_count = arr.GetCount(); row<row_count; ++row)
1667 LayoutAddDock(middle, *arr.Item(row), uiparts, spacer_only);
1668 }
1669 else
1670 {
1671 // there are no center docks, add a background area
1672 wxSizerItem* sizer_item = middle->Add(1,1, 1, wxEXPAND);
1673 wxDockUIPart part;
1674 part.type = wxDockUIPart::typeBackground;
1675 part.pane = NULL;
1676 part.dock = NULL;
1677 part.button = NULL;
1678 part.cont_sizer = middle;
1679 part.sizer_item = sizer_item;
1680 uiparts.Add(part);
1681 }
1682 }
1683 else
1684 {
1685 middle->Add(old_cont, 1, wxEXPAND);
1686 }
1687
1688 // find any right docks in this layer
1689 FindDocks(docks, wxAUI_DOCK_RIGHT, layer, -1, arr);
1690 RenumberDockRows(arr);
1691 if (!arr.IsEmpty())
1692 {
1693 for (row = arr.GetCount()-1; row >= 0; --row)
1694 LayoutAddDock(middle, *arr.Item(row), uiparts, spacer_only);
1695 }
1696
1697 cont->Add(middle, 1, wxEXPAND);
1698
1699
1700
1701 // find any bottom docks in this layer
1702 FindDocks(docks, wxAUI_DOCK_BOTTOM, layer, -1, arr);
1703 RenumberDockRows(arr);
1704 if (!arr.IsEmpty())
1705 {
1706 for (row = arr.GetCount()-1; row >= 0; --row)
1707 LayoutAddDock(cont, *arr.Item(row), uiparts, spacer_only);
1708 }
1709
1710 }
1711
1712 if (!cont)
1713 {
1714 // no sizer available, because there are no docks,
1715 // therefore we will create a simple background area
1716 cont = new wxBoxSizer(wxVERTICAL);
1717 wxSizerItem* sizer_item = cont->Add(1,1, 1, wxEXPAND);
1718 wxDockUIPart part;
1719 part.type = wxDockUIPart::typeBackground;
1720 part.pane = NULL;
1721 part.dock = NULL;
1722 part.button = NULL;
1723 part.cont_sizer = middle;
1724 part.sizer_item = sizer_item;
1725 uiparts.Add(part);
1726 }
1727
1728 container->Add(cont, 1, wxEXPAND);
1729 return container;
1730 }
1731
1732
1733 // Update() updates the layout. Whenever changes are made to
1734 // one or more panes, this function should be called. It is the
1735 // external entry point for running the layout engine.
1736
1737 void wxFrameManager::Update()
1738 {
1739 wxSizer* sizer;
1740 int i, pane_count = m_panes.GetCount();
1741
1742 // delete old sizer first
1743 m_frame->SetSizer(NULL);
1744
1745 // destroy floating panes which have been
1746 // redocked or are becoming non-floating
1747 for (i = 0; i < pane_count; ++i)
1748 {
1749 wxPaneInfo& p = m_panes.Item(i);
1750
1751 if (!p.IsFloating() && p.frame)
1752 {
1753 // because the pane is no longer in a floating, we need to
1754 // reparent it to m_frame and destroy the floating frame
1755
1756 // reduce flicker
1757 p.window->SetSize(1,1);
1758 p.frame->Show(false);
1759
1760 // reparent to m_frame and destroy the pane
1761 p.window->Reparent(m_frame);
1762 p.frame->SetSizer(NULL);
1763 p.frame->Destroy();
1764 p.frame = NULL;
1765 }
1766 }
1767
1768
1769 // create a layout for all of the panes
1770 sizer = LayoutAll(m_panes, m_docks, m_uiparts, false);
1771
1772 // hide or show panes as necessary,
1773 // and float panes as necessary
1774 for (i = 0; i < pane_count; ++i)
1775 {
1776 wxPaneInfo& p = m_panes.Item(i);
1777
1778 if (p.IsFloating())
1779 {
1780 if (p.frame == NULL)
1781 {
1782 // we need to create a frame for this
1783 // pane, which has recently been floated
1784 wxFloatingPane* frame = new wxFloatingPane(m_frame,
1785 this, -1,
1786 p.floating_pos,
1787 p.floating_size);
1788
1789 // on MSW, if the owner desires transparent dragging, and
1790 // the dragging is happening right now, then the floating
1791 // window should have this style by default
1792 #ifdef __WXMSW__
1793 if (m_action == actionDragFloatingPane &&
1794 (m_flags & wxAUI_MGR_TRANSPARENT_DRAG))
1795 MakeWindowTransparent(frame, 150);
1796 #endif
1797
1798 frame->SetPaneWindow(p);
1799 p.frame = frame;
1800
1801 if (p.IsShown())
1802 {
1803 frame->Show();
1804 }
1805 }
1806 else
1807 {
1808 // frame already exists, make sure it's position
1809 // and size reflect the information in wxPaneInfo
1810 if (p.frame->GetPosition() != p.floating_pos)
1811 {
1812 p.frame->SetSize(p.floating_pos.x, p.floating_pos.y,
1813 -1, -1, wxSIZE_USE_EXISTING);
1814 //p.frame->Move(p.floating_pos.x, p.floating_pos.y);
1815 }
1816
1817 p.frame->Show(p.IsShown());
1818 }
1819 }
1820 else
1821 {
1822 p.window->Show(p.IsShown());
1823 }
1824
1825 // if "active panes" are no longer allowed, clear
1826 // any optionActive values from the pane states
1827 if ((m_flags & wxAUI_MGR_ALLOW_ACTIVE_PANE) == 0)
1828 {
1829 p.state &= ~wxPaneInfo::optionActive;
1830 }
1831 }
1832
1833
1834 // keep track of the old window rectangles so we can
1835 // refresh those windows whose rect has changed
1836 wxAuiRectArray old_pane_rects;
1837 for (i = 0; i < pane_count; ++i)
1838 {
1839 wxRect r;
1840 wxPaneInfo& p = m_panes.Item(i);
1841
1842 if (p.window && p.IsShown() && p.IsDocked())
1843 r = p.rect;
1844
1845 old_pane_rects.Add(r);
1846 }
1847
1848
1849
1850
1851 // apply the new sizer
1852 m_frame->SetSizer(sizer);
1853 m_frame->SetAutoLayout(false);
1854 DoFrameLayout();
1855
1856
1857
1858 // now that the frame layout is done, we need to check
1859 // the new pane rectangles against the old rectangles that
1860 // we saved a few lines above here. If the rectangles have
1861 // changed, the corresponding panes must also be updated
1862 for (i = 0; i < pane_count; ++i)
1863 {
1864 wxPaneInfo& p = m_panes.Item(i);
1865 if (p.window && p.window->IsShown() && p.IsDocked())
1866 {
1867 if (p.rect != old_pane_rects[i])
1868 {
1869 p.window->Refresh();
1870 p.window->Update();
1871 }
1872 }
1873 }
1874
1875
1876 Repaint();
1877
1878 // set frame's minimum size
1879
1880 /*
1881 // N.B. More work needs to be done on frame minimum sizes;
1882 // this is some intresting code that imposes the minimum size,
1883 // but we may want to include a more flexible mechanism or
1884 // options for multiple minimum-size modes, e.g. strict or lax
1885 wxSize min_size = sizer->GetMinSize();
1886 wxSize frame_size = m_frame->GetSize();
1887 wxSize client_size = m_frame->GetClientSize();
1888
1889 wxSize minframe_size(min_size.x+frame_size.x-client_size.x,
1890 min_size.y+frame_size.y-client_size.y );
1891
1892 m_frame->SetMinSize(minframe_size);
1893
1894 if (frame_size.x < minframe_size.x ||
1895 frame_size.y < minframe_size.y)
1896 sizer->Fit(m_frame);
1897 */
1898 }
1899
1900
1901 // DoFrameLayout() is an internal function which invokes wxSizer::Layout
1902 // on the frame's main sizer, then measures all the various UI items
1903 // and updates their internal rectangles. This should always be called
1904 // instead of calling m_frame->Layout() directly
1905
1906 void wxFrameManager::DoFrameLayout()
1907 {
1908 m_frame->Layout();
1909
1910 int i, part_count;
1911 for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i)
1912 {
1913 wxDockUIPart& part = m_uiparts.Item(i);
1914
1915 // get the rectangle of the UI part
1916 // originally, this code looked like this:
1917 // part.rect = wxRect(part.sizer_item->GetPosition(),
1918 // part.sizer_item->GetSize());
1919 // this worked quite well, with one exception: the mdi
1920 // client window had a "deferred" size variable
1921 // that returned the wrong size. It looks like
1922 // a bug in wx, because the former size of the window
1923 // was being returned. So, we will retrieve the part's
1924 // rectangle via other means
1925
1926
1927 part.rect = part.sizer_item->GetRect();
1928 int flag = part.sizer_item->GetFlag();
1929 int border = part.sizer_item->GetBorder();
1930 if (flag & wxTOP)
1931 {
1932 part.rect.y -= border;
1933 part.rect.height += border;
1934 }
1935 if (flag & wxLEFT)
1936 {
1937 part.rect.x -= border;
1938 part.rect.width += border;
1939 }
1940 if (flag & wxBOTTOM)
1941 part.rect.height += border;
1942 if (flag & wxRIGHT)
1943 part.rect.width += border;
1944
1945
1946 if (part.type == wxDockUIPart::typeDock)
1947 part.dock->rect = part.rect;
1948 if (part.type == wxDockUIPart::typePane)
1949 part.pane->rect = part.rect;
1950 }
1951 }
1952
1953 // GetPanePart() looks up the pane the pane border UI part (or the regular
1954 // pane part if there is no border). This allows the caller to get the exact
1955 // rectangle of the pane in question, including decorations like
1956 // caption and border (if any).
1957
1958 wxDockUIPart* wxFrameManager::GetPanePart(wxWindow* wnd)
1959 {
1960 int i, part_count;
1961 for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i)
1962 {
1963 wxDockUIPart& part = m_uiparts.Item(i);
1964 if (part.type == wxDockUIPart::typePaneBorder &&
1965 part.pane && part.pane->window == wnd)
1966 return &part;
1967 }
1968 for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i)
1969 {
1970 wxDockUIPart& part = m_uiparts.Item(i);
1971 if (part.type == wxDockUIPart::typePane &&
1972 part.pane && part.pane->window == wnd)
1973 return &part;
1974 }
1975 return NULL;
1976 }
1977
1978
1979
1980 // GetDockPixelOffset() is an internal function which returns
1981 // a dock's offset in pixels from the left side of the window
1982 // (for horizontal docks) or from the top of the window (for
1983 // vertical docks). This value is necessary for calculating
1984 // fixel-pane/toolbar offsets when they are dragged.
1985
1986 int wxFrameManager::GetDockPixelOffset(wxPaneInfo& test)
1987 {
1988 // the only way to accurately calculate the dock's
1989 // offset is to actually run a theoretical layout
1990
1991 int i, part_count, dock_count;
1992 wxDockInfoArray docks;
1993 wxPaneInfoArray panes;
1994 wxDockUIPartArray uiparts;
1995 CopyDocksAndPanes(docks, panes, m_docks, m_panes);
1996 panes.Add(test);
1997
1998 wxSizer* sizer = LayoutAll(panes, docks, uiparts, true);
1999 wxSize client_size = m_frame->GetClientSize();
2000 sizer->SetDimension(0, 0, client_size.x, client_size.y);
2001 sizer->Layout();
2002
2003 for (i = 0, part_count = uiparts.GetCount(); i < part_count; ++i)
2004 {
2005 wxDockUIPart& part = uiparts.Item(i);
2006 part.rect = wxRect(part.sizer_item->GetPosition(),
2007 part.sizer_item->GetSize());
2008 if (part.type == wxDockUIPart::typeDock)
2009 part.dock->rect = part.rect;
2010 }
2011
2012 delete sizer;
2013
2014 for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
2015 {
2016 wxDockInfo& dock = docks.Item(i);
2017 if (test.dock_direction == dock.dock_direction &&
2018 test.dock_layer==dock.dock_layer && test.dock_row==dock.dock_row)
2019 {
2020 if (dock.IsVertical())
2021 return dock.rect.y;
2022 else
2023 return dock.rect.x;
2024 }
2025 }
2026
2027 return 0;
2028 }
2029
2030
2031
2032 // ProcessDockResult() is a utility function used by DoDrop() - it checks
2033 // if a dock operation is allowed, the new dock position is copied into
2034 // the target info. If the operation was allowed, the function returns true.
2035
2036 static bool ProcessDockResult(wxPaneInfo& target,
2037 const wxPaneInfo& new_pos)
2038 {
2039 bool allowed = false;
2040 switch (new_pos.dock_direction)
2041 {
2042 case wxAUI_DOCK_TOP: allowed = target.IsTopDockable(); break;
2043 case wxAUI_DOCK_BOTTOM: allowed = target.IsBottomDockable(); break;
2044 case wxAUI_DOCK_LEFT: allowed = target.IsLeftDockable(); break;
2045 case wxAUI_DOCK_RIGHT: allowed = target.IsRightDockable(); break;
2046 }
2047
2048 if (allowed)
2049 target = new_pos;
2050
2051 return allowed;
2052 }
2053
2054
2055 // DoDrop() is an important function. It basically takes a mouse position,
2056 // and determines where the pane's new position would be. If the pane is to be
2057 // dropped, it performs the drop operation using the specified dock and pane
2058 // arrays. By specifying copied dock and pane arrays when calling, a "what-if"
2059 // scenario can be performed, giving precise coordinates for drop hints.
2060 // If, however, wxFrameManager:m_docks and wxFrameManager::m_panes are specified
2061 // as parameters, the changes will be made to the main state arrays
2062
2063 const int auiInsertRowPixels = 10;
2064 const int auiNewRowPixels = 40;
2065 const int auiLayerInsertPixels = 40;
2066 const int auiLayerInsertOffset = 5;
2067
2068 bool wxFrameManager::DoDrop(wxDockInfoArray& docks,
2069 wxPaneInfoArray& panes,
2070 wxPaneInfo& target,
2071 const wxPoint& pt,
2072 const wxPoint& offset)
2073 {
2074 wxSize cli_size = m_frame->GetClientSize();
2075
2076 wxPaneInfo drop = target;
2077
2078
2079 // The result should always be shown
2080 drop.Show();
2081
2082
2083 // Check to see if the pane has been dragged outside of the window
2084 // (or near to the outside of the window), if so, dock it along the edge
2085
2086
2087 int layer_insert_offset = auiLayerInsertOffset;
2088 if (target.IsToolbar())
2089 layer_insert_offset = 0;
2090
2091 if (pt.x < layer_insert_offset &&
2092 pt.x > layer_insert_offset-auiLayerInsertPixels)
2093 {
2094 int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_LEFT),
2095 GetMaxLayer(docks, wxAUI_DOCK_BOTTOM)),
2096 GetMaxLayer(docks, wxAUI_DOCK_TOP)) + 1;
2097 drop.Dock().Left().
2098 Layer(new_layer).
2099 Row(0).
2100 Position(pt.y - GetDockPixelOffset(drop) - offset.y);
2101 return ProcessDockResult(target, drop);
2102 }
2103 else if (pt.y < layer_insert_offset &&
2104 pt.y > layer_insert_offset-auiLayerInsertPixels)
2105 {
2106 int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_TOP),
2107 GetMaxLayer(docks, wxAUI_DOCK_LEFT)),
2108 GetMaxLayer(docks, wxAUI_DOCK_RIGHT)) + 1;
2109 drop.Dock().Top().
2110 Layer(new_layer).
2111 Row(0).
2112 Position(pt.x - GetDockPixelOffset(drop) - offset.x);
2113 return ProcessDockResult(target, drop);
2114 }
2115 else if (pt.x >= cli_size.x - layer_insert_offset &&
2116 pt.x < cli_size.x - layer_insert_offset + auiLayerInsertPixels)
2117 {
2118 int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_RIGHT),
2119 GetMaxLayer(docks, wxAUI_DOCK_TOP)),
2120 GetMaxLayer(docks, wxAUI_DOCK_BOTTOM)) + 1;
2121 drop.Dock().Right().
2122 Layer(new_layer).
2123 Row(0).
2124 Position(pt.y - GetDockPixelOffset(drop) - offset.y);
2125 return ProcessDockResult(target, drop);
2126 }
2127 else if (pt.y >= cli_size.y - layer_insert_offset &&
2128 pt.y < cli_size.y - layer_insert_offset + auiLayerInsertPixels)
2129 {
2130 int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_BOTTOM),
2131 GetMaxLayer(docks, wxAUI_DOCK_LEFT)),
2132 GetMaxLayer(docks, wxAUI_DOCK_RIGHT)) + 1;
2133 drop.Dock().Bottom().
2134 Layer(new_layer).
2135 Row(0).
2136 Position(pt.x - GetDockPixelOffset(drop) - offset.x);
2137 return ProcessDockResult(target, drop);
2138 }
2139
2140
2141 wxDockUIPart* part = HitTest(pt.x, pt.y);
2142
2143
2144 if (drop.IsToolbar())
2145 {
2146 if (!part || !part->dock)
2147 return false;
2148
2149
2150 // calculate the offset from where the dock begins
2151 // to the point where the user dropped the pane
2152 int dock_drop_offset = 0;
2153 if (part->dock->IsHorizontal())
2154 dock_drop_offset = pt.x - part->dock->rect.x - offset.x;
2155 else
2156 dock_drop_offset = pt.y - part->dock->rect.y - offset.y;
2157
2158
2159 // toolbars may only be moved in and to fixed-pane docks,
2160 // otherwise we will try to float the pane. Also, the pane
2161 // should float if being dragged over center pane windows
2162 if (!part->dock->fixed || part->dock->dock_direction == wxAUI_DOCK_CENTER)
2163 {
2164 if ((m_flags & wxAUI_MGR_ALLOW_FLOATING) &&
2165 (drop.IsFloatable() ||
2166 (part->dock->dock_direction != wxAUI_DOCK_CENTER &&
2167 part->dock->dock_direction != wxAUI_DOCK_NONE)))
2168 {
2169 drop.Float();
2170 }
2171
2172 return ProcessDockResult(target, drop);
2173 }
2174
2175 drop.Dock().
2176 Direction(part->dock->dock_direction).
2177 Layer(part->dock->dock_layer).
2178 Row(part->dock->dock_row).
2179 Position(dock_drop_offset);
2180
2181 if ((
2182 ((pt.y < part->dock->rect.y + 2) && part->dock->IsHorizontal()) ||
2183 ((pt.x < part->dock->rect.x + 2) && part->dock->IsVertical())
2184 ) && part->dock->panes.GetCount() > 1)
2185 {
2186 int row = drop.dock_row;
2187 DoInsertDockRow(panes, part->dock->dock_direction,
2188 part->dock->dock_layer,
2189 part->dock->dock_row);
2190 drop.dock_row = row;
2191 }
2192
2193 if ((
2194 ((pt.y > part->dock->rect.y + part->dock->rect.height - 2 ) && part->dock->IsHorizontal()) ||
2195 ((pt.x > part->dock->rect.x + part->dock->rect.width - 2 ) && part->dock->IsVertical())
2196 ) && part->dock->panes.GetCount() > 1)
2197 {
2198 DoInsertDockRow(panes, part->dock->dock_direction,
2199 part->dock->dock_layer,
2200 part->dock->dock_row+1);
2201 drop.dock_row = part->dock->dock_row+1;
2202 }
2203
2204 return ProcessDockResult(target, drop);
2205 }
2206
2207
2208
2209
2210 if (!part)
2211 return false;
2212
2213 if (part->type == wxDockUIPart::typePaneBorder ||
2214 part->type == wxDockUIPart::typeCaption ||
2215 part->type == wxDockUIPart::typeGripper ||
2216 part->type == wxDockUIPart::typePaneButton ||
2217 part->type == wxDockUIPart::typePane ||
2218 part->type == wxDockUIPart::typePaneSizer ||
2219 part->type == wxDockUIPart::typeDockSizer ||
2220 part->type == wxDockUIPart::typeBackground)
2221 {
2222 if (part->type == wxDockUIPart::typeDockSizer)
2223 {
2224 if (part->dock->panes.GetCount() != 1)
2225 return false;
2226 part = GetPanePart(part->dock->panes.Item(0)->window);
2227 if (!part)
2228 return false;
2229 }
2230
2231
2232
2233 // If a normal frame is being dragged over a toolbar, insert it
2234 // along the edge under the toolbar, but over all other panes.
2235 // (this could be done much better, but somehow factoring this
2236 // calculation with the one at the beginning of this function)
2237 if (part->dock && part->dock->toolbar)
2238 {
2239 int layer = 0;
2240
2241 switch (part->dock->dock_direction)
2242 {
2243 case wxAUI_DOCK_LEFT:
2244 layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_LEFT),
2245 GetMaxLayer(docks, wxAUI_DOCK_BOTTOM)),
2246 GetMaxLayer(docks, wxAUI_DOCK_TOP));
2247 break;
2248 case wxAUI_DOCK_TOP:
2249 layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_TOP),
2250 GetMaxLayer(docks, wxAUI_DOCK_LEFT)),
2251 GetMaxLayer(docks, wxAUI_DOCK_RIGHT));
2252 break;
2253 case wxAUI_DOCK_RIGHT:
2254 layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_RIGHT),
2255 GetMaxLayer(docks, wxAUI_DOCK_TOP)),
2256 GetMaxLayer(docks, wxAUI_DOCK_BOTTOM));
2257 break;
2258 case wxAUI_DOCK_BOTTOM:
2259 layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_BOTTOM),
2260 GetMaxLayer(docks, wxAUI_DOCK_LEFT)),
2261 GetMaxLayer(docks, wxAUI_DOCK_RIGHT));
2262 break;
2263 }
2264
2265 DoInsertDockRow(panes, part->dock->dock_direction,
2266 layer, 0);
2267 drop.Dock().
2268 Direction(part->dock->dock_direction).
2269 Layer(layer).Row(0).Position(0);
2270 return ProcessDockResult(target, drop);
2271 }
2272
2273
2274 if (!part->pane)
2275 return false;
2276
2277 part = GetPanePart(part->pane->window);
2278 if (!part)
2279 return false;
2280
2281 bool insert_dock_row = false;
2282 int insert_row = part->pane->dock_row;
2283 int insert_dir = part->pane->dock_direction;
2284 int insert_layer = part->pane->dock_layer;
2285
2286 switch (part->pane->dock_direction)
2287 {
2288 case wxAUI_DOCK_TOP:
2289 if (pt.y >= part->rect.y &&
2290 pt.y < part->rect.y+auiInsertRowPixels)
2291 insert_dock_row = true;
2292 break;
2293 case wxAUI_DOCK_BOTTOM:
2294 if (pt.y > part->rect.y+part->rect.height-auiInsertRowPixels &&
2295 pt.y <= part->rect.y + part->rect.height)
2296 insert_dock_row = true;
2297 break;
2298 case wxAUI_DOCK_LEFT:
2299 if (pt.x >= part->rect.x &&
2300 pt.x < part->rect.x+auiInsertRowPixels)
2301 insert_dock_row = true;
2302 break;
2303 case wxAUI_DOCK_RIGHT:
2304 if (pt.x > part->rect.x+part->rect.width-auiInsertRowPixels &&
2305 pt.x <= part->rect.x+part->rect.width)
2306 insert_dock_row = true;
2307 break;
2308 case wxAUI_DOCK_CENTER:
2309 {
2310 // "new row pixels" will be set to the default, but
2311 // must never exceed 20% of the window size
2312 int new_row_pixels_x = auiNewRowPixels;
2313 int new_row_pixels_y = auiNewRowPixels;
2314
2315 if (new_row_pixels_x > (part->rect.width*20)/100)
2316 new_row_pixels_x = (part->rect.width*20)/100;
2317
2318 if (new_row_pixels_y > (part->rect.height*20)/100)
2319 new_row_pixels_y = (part->rect.height*20)/100;
2320
2321
2322 // determine if the mouse pointer is in a location that
2323 // will cause a new row to be inserted. The hot spot positions
2324 // are along the borders of the center pane
2325
2326 insert_layer = 0;
2327 insert_dock_row = true;
2328 if (pt.x >= part->rect.x &&
2329 pt.x < part->rect.x+new_row_pixels_x)
2330 insert_dir = wxAUI_DOCK_LEFT;
2331 else
2332 if (pt.y >= part->rect.y &&
2333 pt.y < part->rect.y+new_row_pixels_y)
2334 insert_dir = wxAUI_DOCK_TOP;
2335 else
2336 if (pt.x >= part->rect.x + part->rect.width-new_row_pixels_x &&
2337 pt.x < part->rect.x + part->rect.width)
2338 insert_dir = wxAUI_DOCK_RIGHT;
2339 else
2340 if (pt.y >= part->rect.y+ part->rect.height-new_row_pixels_y &&
2341 pt.y < part->rect.y + part->rect.height)
2342 insert_dir = wxAUI_DOCK_BOTTOM;
2343 else
2344 return false;
2345
2346 insert_row = GetMaxRow(panes, insert_dir, insert_layer) + 1;
2347 }
2348 }
2349
2350 if (insert_dock_row)
2351 {
2352 DoInsertDockRow(panes, insert_dir, insert_layer, insert_row);
2353 drop.Dock().Direction(insert_dir).
2354 Layer(insert_layer).
2355 Row(insert_row).
2356 Position(0);
2357 return ProcessDockResult(target, drop);
2358 }
2359
2360 // determine the mouse offset and the pane size, both in the
2361 // direction of the dock itself, and perpendicular to the dock
2362
2363 int offset, size;
2364
2365 if (part->orientation == wxVERTICAL)
2366 {
2367 offset = pt.y - part->rect.y;
2368 size = part->rect.GetHeight();
2369 }
2370 else
2371 {
2372 offset = pt.x - part->rect.x;
2373 size = part->rect.GetWidth();
2374 }
2375
2376 int drop_position = part->pane->dock_pos;
2377
2378 // if we are in the top/left part of the pane,
2379 // insert the pane before the pane being hovered over
2380 if (offset <= size/2)
2381 {
2382 drop_position = part->pane->dock_pos;
2383 DoInsertPane(panes,
2384 part->pane->dock_direction,
2385 part->pane->dock_layer,
2386 part->pane->dock_row,
2387 part->pane->dock_pos);
2388 }
2389
2390 // if we are in the bottom/right part of the pane,
2391 // insert the pane before the pane being hovered over
2392 if (offset > size/2)
2393 {
2394 drop_position = part->pane->dock_pos+1;
2395 DoInsertPane(panes,
2396 part->pane->dock_direction,
2397 part->pane->dock_layer,
2398 part->pane->dock_row,
2399 part->pane->dock_pos+1);
2400 }
2401
2402 drop.Dock().
2403 Direction(part->dock->dock_direction).
2404 Layer(part->dock->dock_layer).
2405 Row(part->dock->dock_row).
2406 Position(drop_position);
2407 return ProcessDockResult(target, drop);
2408 }
2409
2410 return false;
2411 }
2412
2413
2414 void wxFrameManager::OnHintFadeTimer(wxTimerEvent& WXUNUSED(event))
2415 {
2416 #ifdef __WXMSW__
2417 if (!m_hint_wnd || m_hint_fadeamt >= 50)
2418 {
2419 m_hint_fadetimer.Stop();
2420 return;
2421 }
2422
2423 m_hint_fadeamt += 5;
2424 MakeWindowTransparent(m_hint_wnd, m_hint_fadeamt);
2425 #endif
2426 }
2427
2428 void wxFrameManager::ShowHint(const wxRect& rect)
2429 {
2430 #ifdef __WXMSW__
2431
2432 // First, determine if the operating system can handle transparency.
2433 // Transparency is available on Win2000 and above
2434
2435 static int os_type = -1;
2436 static int ver_major = -1;
2437
2438 if (os_type == -1)
2439 os_type = ::wxGetOsVersion(&ver_major);
2440
2441 // If the transparent flag is set, and the OS supports it,
2442 // go ahead and use a transparent hint
2443
2444 if ((m_flags & wxAUI_MGR_TRANSPARENT_HINT) != 0 &&
2445 os_type == wxWINDOWS_NT && ver_major >= 5)
2446 {
2447 if (m_last_hint == rect)
2448 return;
2449 m_last_hint = rect;
2450
2451 int initial_fade = 50;
2452 if (m_flags & wxAUI_MGR_TRANSPARENT_HINT_FADE)
2453 initial_fade = 0;
2454
2455 if (m_hint_wnd == NULL)
2456 {
2457 wxPoint pt = rect.GetPosition();
2458 wxSize size = rect.GetSize();
2459 m_hint_wnd = new wxFrame(m_frame, -1, wxEmptyString, pt, size,
2460 wxFRAME_TOOL_WINDOW |
2461 wxFRAME_FLOAT_ON_PARENT |
2462 wxFRAME_NO_TASKBAR |
2463 wxNO_BORDER);
2464
2465 MakeWindowTransparent(m_hint_wnd, initial_fade);
2466 m_hint_wnd->SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_ACTIVECAPTION));
2467 m_hint_wnd->Show();
2468
2469 // if we are dragging a floating pane, set the focus
2470 // back to that floating pane (otherwise it becomes unfocused)
2471 if (m_action == actionDragFloatingPane && m_action_window)
2472 m_action_window->SetFocus();
2473
2474 }
2475 else
2476 {
2477 MakeWindowTransparent(m_hint_wnd, initial_fade);
2478 m_hint_wnd->SetSize(rect);
2479 }
2480
2481 if (m_flags & wxAUI_MGR_TRANSPARENT_HINT_FADE)
2482 {
2483 // start fade in timer
2484 m_hint_fadeamt = 0;
2485 m_hint_fadetimer.SetOwner(this, 101);
2486 m_hint_fadetimer.Start(5);
2487 }
2488
2489 return;
2490 }
2491 #endif
2492
2493 if (m_last_hint != rect)
2494 {
2495 // remove the last hint rectangle
2496 m_last_hint = rect;
2497 m_frame->Refresh();
2498 m_frame->Update();
2499 }
2500
2501 wxScreenDC screendc;
2502 wxRegion clip(1, 1, 10000, 10000);
2503
2504 // clip all floating windows, so we don't draw over them
2505 int i, pane_count;
2506 for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i)
2507 {
2508 wxPaneInfo& pane = m_panes.Item(i);
2509
2510 if (pane.IsFloating() &&
2511 pane.frame->IsShown())
2512 {
2513 wxRect rect = pane.frame->GetRect();
2514 #ifdef __WXGTK__
2515 // wxGTK returns the client size, not the whole frame size
2516 rect.width += 15;
2517 rect.height += 35;
2518 rect.Inflate(5);
2519 #endif
2520
2521 clip.Subtract(rect);
2522 }
2523 }
2524
2525 screendc.SetClippingRegion(clip);
2526
2527 wxBitmap stipple = wxPaneCreateStippleBitmap();
2528 wxBrush brush(stipple);
2529 screendc.SetBrush(brush);
2530 screendc.SetPen(*wxTRANSPARENT_PEN);
2531
2532 screendc.DrawRectangle(rect.x, rect.y, 5, rect.height);
2533 screendc.DrawRectangle(rect.x+5, rect.y, rect.width-10, 5);
2534 screendc.DrawRectangle(rect.x+rect.width-5, rect.y, 5, rect.height);
2535 screendc.DrawRectangle(rect.x+5, rect.y+rect.height-5, rect.width-10, 5);
2536 }
2537
2538 void wxFrameManager::HideHint()
2539 {
2540 // hides a transparent window hint (currently wxMSW only)
2541 #ifdef __WXMSW__
2542 if (m_hint_wnd)
2543 {
2544 MakeWindowTransparent(m_hint_wnd, 0);
2545 m_hint_fadetimer.Stop();
2546 m_last_hint = wxRect();
2547 return;
2548 }
2549 #endif
2550
2551 // hides a painted hint by redrawing the frame window
2552 if (!m_last_hint.IsEmpty())
2553 {
2554 m_frame->Refresh();
2555 m_frame->Update();
2556 m_last_hint = wxRect();
2557 }
2558 }
2559
2560
2561
2562 // DrawHintRect() draws a drop hint rectangle. First calls DoDrop() to
2563 // determine the exact position the pane would be at were if dropped. If
2564 // the pame would indeed become docked at the specified drop point,
2565 // DrawHintRect() then calls ShowHint() to indicate this drop rectangle.
2566 // "pane_window" is the window pointer of the pane being dragged, pt is
2567 // the mouse position, in client coordinates
2568 void wxFrameManager::DrawHintRect(wxWindow* pane_window,
2569 const wxPoint& pt,
2570 const wxPoint& offset)
2571 {
2572 wxRect rect;
2573
2574 // we need to paint a hint rectangle; to find out the exact hint rectangle,
2575 // we will create a new temporary layout and then measure the resulting
2576 // rectangle; we will create a copy of the docking structures (m_dock)
2577 // so that we don't modify the real thing on screen
2578
2579 int i, pane_count, part_count;
2580 wxDockInfoArray docks;
2581 wxPaneInfoArray panes;
2582 wxDockUIPartArray uiparts;
2583 wxPaneInfo hint = GetPane(pane_window);
2584 hint.name = wxT("__HINT__");
2585
2586 if (!hint.IsOk())
2587 return;
2588
2589 CopyDocksAndPanes(docks, panes, m_docks, m_panes);
2590
2591 // remove any pane already there which bears the same window;
2592 // this happens when you are moving a pane around in a dock
2593 for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
2594 {
2595 if (panes.Item(i).window == pane_window)
2596 {
2597 RemovePaneFromDocks(docks, panes.Item(i));
2598 panes.RemoveAt(i);
2599 break;
2600 }
2601 }
2602
2603 // find out where the new pane would be
2604 if (!DoDrop(docks, panes, hint, pt, offset))
2605 {
2606 HideHint();
2607 return;
2608 }
2609
2610 panes.Add(hint);
2611
2612 wxSizer* sizer = LayoutAll(panes, docks, uiparts, true);
2613 wxSize client_size = m_frame->GetClientSize();
2614 sizer->SetDimension(0, 0, client_size.x, client_size.y);
2615 sizer->Layout();
2616
2617 for (i = 0, part_count = uiparts.GetCount();
2618 i < part_count; ++i)
2619 {
2620 wxDockUIPart& part = uiparts.Item(i);
2621
2622 if (part.type == wxDockUIPart::typePaneBorder &&
2623 part.pane && part.pane->name == wxT("__HINT__"))
2624 {
2625 rect = wxRect(part.sizer_item->GetPosition(),
2626 part.sizer_item->GetSize());
2627 break;
2628 }
2629 }
2630
2631 delete sizer;
2632
2633 if (rect.IsEmpty())
2634 {
2635 HideHint();
2636 return;
2637 }
2638
2639 // actually show the hint rectangle on the screen
2640 m_frame->ClientToScreen(&rect.x, &rect.y);
2641 ShowHint(rect);
2642 }
2643
2644 void wxFrameManager::OnFloatingPaneMoveStart(wxWindow* wnd)
2645 {
2646 // try to find the pane
2647 wxPaneInfo& pane = GetPane(wnd);
2648 wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
2649
2650 #ifdef __WXMSW__
2651 if (m_flags & wxAUI_MGR_TRANSPARENT_DRAG)
2652 MakeWindowTransparent(pane.frame, 150);
2653 #endif
2654 }
2655
2656 void wxFrameManager::OnFloatingPaneMoving(wxWindow* wnd)
2657 {
2658 // try to find the pane
2659 wxPaneInfo& pane = GetPane(wnd);
2660 wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
2661
2662 wxPoint pt = ::wxGetMousePosition();
2663 wxPoint client_pt = m_frame->ScreenToClient(pt);
2664
2665 // calculate the offset from the upper left-hand corner
2666 // of the frame to the mouse pointer
2667 wxPoint frame_pos = pane.frame->GetPosition();
2668 wxPoint action_offset(pt.x-frame_pos.x, pt.y-frame_pos.y);
2669
2670 // no hint for toolbar floating windows
2671 if (pane.IsToolbar() && m_action == actionDragFloatingPane)
2672 {
2673 if (m_action == actionDragFloatingPane)
2674 {
2675 wxDockInfoArray docks;
2676 wxPaneInfoArray panes;
2677 wxDockUIPartArray uiparts;
2678 wxPaneInfo hint = pane;
2679
2680 CopyDocksAndPanes(docks, panes, m_docks, m_panes);
2681
2682 // find out where the new pane would be
2683 if (!DoDrop(docks, panes, hint, client_pt))
2684 return;
2685 if (hint.IsFloating())
2686 return;
2687
2688 pane = hint;
2689 m_action = actionDragToolbarPane;
2690 m_action_window = pane.window;
2691
2692 Update();
2693 }
2694
2695 return;
2696 }
2697
2698
2699 // if a key modifier is pressed while dragging the frame,
2700 // don't dock the window
2701 if (wxGetKeyState(WXK_CONTROL) || wxGetKeyState(WXK_ALT))
2702 {
2703 HideHint();
2704 return;
2705 }
2706
2707
2708 DrawHintRect(wnd, client_pt, action_offset);
2709
2710 #ifdef __WXGTK__
2711 // this cleans up some screen artifacts that are caused on GTK because
2712 // we aren't getting the exact size of the window (see comment
2713 // in DrawHintRect)
2714 //Refresh();
2715 #endif
2716
2717
2718 // reduces flicker
2719 m_frame->Update();
2720 }
2721
2722 void wxFrameManager::OnFloatingPaneMoved(wxWindow* wnd)
2723 {
2724 // try to find the pane
2725 wxPaneInfo& pane = GetPane(wnd);
2726 wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
2727
2728 wxPoint pt = ::wxGetMousePosition();
2729 wxPoint client_pt = m_frame->ScreenToClient(pt);
2730
2731 // calculate the offset from the upper left-hand corner
2732 // of the frame to the mouse pointer
2733 wxPoint frame_pos = pane.frame->GetPosition();
2734 wxPoint action_offset(pt.x-frame_pos.x, pt.y-frame_pos.y);
2735
2736
2737 // if a key modifier is pressed while dragging the frame,
2738 // don't dock the window
2739 if (wxGetKeyState(WXK_CONTROL) || wxGetKeyState(WXK_ALT))
2740 {
2741 HideHint();
2742 return;
2743 }
2744
2745
2746 // do the drop calculation
2747 DoDrop(m_docks, m_panes, pane, client_pt, action_offset);
2748
2749 // if the pane is still floating, update it's floating
2750 // position (that we store)
2751 if (pane.IsFloating())
2752 {
2753 pane.floating_pos = pane.frame->GetPosition();
2754
2755 #ifdef __WXMSW__
2756 if (m_flags & wxAUI_MGR_TRANSPARENT_DRAG)
2757 MakeWindowTransparent(pane.frame, 255);
2758 #endif
2759 }
2760
2761 Update();
2762
2763 HideHint();
2764 }
2765
2766 void wxFrameManager::OnFloatingPaneResized(wxWindow* wnd, const wxSize& size)
2767 {
2768 // try to find the pane
2769 wxPaneInfo& pane = GetPane(wnd);
2770 wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
2771
2772 pane.floating_size = size;
2773 }
2774
2775 void wxFrameManager::OnFloatingPaneClosed(wxWindow* wnd)
2776 {
2777 // try to find the pane
2778 wxPaneInfo& pane = GetPane(wnd);
2779 wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
2780
2781 // reparent the pane window back to us and
2782 // prepare the frame window for destruction
2783 pane.window->Show(false);
2784 pane.window->Reparent(m_frame);
2785 pane.frame = NULL;
2786 pane.Hide();
2787 }
2788
2789 void wxFrameManager::OnFloatingPaneActivated(wxWindow* wnd)
2790 {
2791 if (GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE)
2792 {
2793 // try to find the pane
2794 wxPaneInfo& pane = GetPane(wnd);
2795 wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
2796
2797 SetActivePane(m_panes, wnd);
2798 Repaint();
2799 }
2800 }
2801
2802 // Render() draws all of the pane captions, sashes,
2803 // backgrounds, captions, grippers, pane borders and buttons.
2804 // It renders the entire user interface.
2805
2806 void wxFrameManager::Render(wxDC* dc)
2807 {
2808 #ifdef __WXMAC__
2809 dc->Clear() ;
2810 #endif
2811 int i, part_count;
2812 for (i = 0, part_count = m_uiparts.GetCount();
2813 i < part_count; ++i)
2814 {
2815 wxDockUIPart& part = m_uiparts.Item(i);
2816
2817 // don't draw hidden pane items
2818 if (part.sizer_item && !part.sizer_item->IsShown())
2819 continue;
2820
2821 switch (part.type)
2822 {
2823 case wxDockUIPart::typeDockSizer:
2824 case wxDockUIPart::typePaneSizer:
2825 m_art->DrawSash(*dc, part.orientation, part.rect);
2826 break;
2827 case wxDockUIPart::typeBackground:
2828 m_art->DrawBackground(*dc, part.orientation, part.rect);
2829 break;
2830 case wxDockUIPart::typeCaption:
2831 m_art->DrawCaption(*dc, part.pane->caption, part.rect, *part.pane);
2832 break;
2833 case wxDockUIPart::typeGripper:
2834 m_art->DrawGripper(*dc, part.rect, *part.pane);
2835 break;
2836 case wxDockUIPart::typePaneBorder:
2837 m_art->DrawBorder(*dc, part.rect, *part.pane);
2838 break;
2839 case wxDockUIPart::typePaneButton:
2840 m_art->DrawPaneButton(*dc, part.button->button_id,
2841 wxAUI_BUTTON_STATE_NORMAL, part.rect, *part.pane);
2842 break;
2843 }
2844 }
2845 }
2846
2847 void wxFrameManager::Repaint(wxDC* dc)
2848 {
2849 #ifdef __WXMAC__
2850 if ( dc == NULL )
2851 {
2852 m_frame->Refresh() ;
2853 m_frame->Update() ;
2854 return ;
2855 }
2856 #endif
2857 int w, h;
2858 m_frame->GetClientSize(&w, &h);
2859
2860 // figure out which dc to use; if one
2861 // has been specified, use it, otherwise
2862 // make a client dc
2863 wxClientDC* client_dc = NULL;
2864 if (!dc)
2865 {
2866 client_dc = new wxClientDC(m_frame);
2867 dc = client_dc;
2868 }
2869
2870 // if the frame has a toolbar, the client area
2871 // origin will not be (0,0).
2872 wxPoint pt = m_frame->GetClientAreaOrigin();
2873 if (pt.x != 0 || pt.y != 0)
2874 dc->SetDeviceOrigin(pt.x, pt.y);
2875
2876 // render all the items
2877 Render(dc);
2878
2879 // if we created a client_dc, delete it
2880 if (client_dc)
2881 delete client_dc;
2882 }
2883
2884 void wxFrameManager::OnPaint(wxPaintEvent& WXUNUSED(event))
2885 {
2886 wxPaintDC dc(m_frame);
2887 Repaint(&dc);
2888 }
2889
2890 void wxFrameManager::OnEraseBackground(wxEraseEvent& event)
2891 {
2892 #ifdef __WXMAC__
2893 event.Skip() ;
2894 #else
2895 wxUnusedVar(event);
2896 #endif
2897 }
2898
2899 void wxFrameManager::OnSize(wxSizeEvent& WXUNUSED(event))
2900 {
2901 if (m_frame)
2902 {
2903 DoFrameLayout();
2904 Repaint();
2905 }
2906 }
2907
2908
2909 void wxFrameManager::OnSetCursor(wxSetCursorEvent& event)
2910 {
2911 // determine cursor
2912 wxDockUIPart* part = HitTest(event.GetX(), event.GetY());
2913 wxCursor cursor = wxNullCursor;
2914
2915 if (part)
2916 {
2917 if (part->type == wxDockUIPart::typeDockSizer ||
2918 part->type == wxDockUIPart::typePaneSizer)
2919 {
2920 // a dock may not be resized if it has a single
2921 // pane which is not resizable
2922 if (part->type == wxDockUIPart::typeDockSizer && part->dock &&
2923 part->dock->panes.GetCount() == 1 &&
2924 part->dock->panes.Item(0)->IsFixed())
2925 return;
2926
2927 // panes that may not be resized do not get a sizing cursor
2928 if (part->pane && part->pane->IsFixed())
2929 return;
2930
2931 if (part->orientation == wxVERTICAL)
2932 cursor = wxCursor(wxCURSOR_SIZEWE);
2933 else
2934 cursor = wxCursor(wxCURSOR_SIZENS);
2935 }
2936 else if (part->type == wxDockUIPart::typeGripper)
2937 {
2938 cursor = wxCursor(wxCURSOR_SIZING);
2939 }
2940 }
2941
2942 event.SetCursor(cursor);
2943 }
2944
2945
2946
2947 void wxFrameManager::UpdateButtonOnScreen(wxDockUIPart* button_ui_part,
2948 const wxMouseEvent& event)
2949 {
2950 wxDockUIPart* hit_test = HitTest(event.GetX(), event.GetY());
2951
2952 int state = wxAUI_BUTTON_STATE_NORMAL;
2953
2954 if (hit_test == button_ui_part)
2955 {
2956 if (event.LeftDown())
2957 state = wxAUI_BUTTON_STATE_PRESSED;
2958 else
2959 state = wxAUI_BUTTON_STATE_HOVER;
2960 }
2961 else
2962 {
2963 if (event.LeftDown())
2964 state = wxAUI_BUTTON_STATE_HOVER;
2965 }
2966
2967 // now repaint the button with hover state
2968 wxClientDC cdc(m_frame);
2969
2970 // if the frame has a toolbar, the client area
2971 // origin will not be (0,0).
2972 wxPoint pt = m_frame->GetClientAreaOrigin();
2973 if (pt.x != 0 || pt.y != 0)
2974 cdc.SetDeviceOrigin(pt.x, pt.y);
2975
2976 m_art->DrawPaneButton(cdc,
2977 button_ui_part->button->button_id,
2978 state,
2979 button_ui_part->rect,
2980 *hit_test->pane);
2981 }
2982
2983 void wxFrameManager::OnLeftDown(wxMouseEvent& event)
2984 {
2985 wxDockUIPart* part = HitTest(event.GetX(), event.GetY());
2986 if (part)
2987 {
2988 if (part->dock && part->dock->dock_direction == wxAUI_DOCK_CENTER)
2989 return;
2990
2991 if (part->type == wxDockUIPart::typeDockSizer ||
2992 part->type == wxDockUIPart::typePaneSizer)
2993 {
2994 // a dock may not be resized if it has a single
2995 // pane which is not resizable
2996 if (part->type == wxDockUIPart::typeDockSizer && part->dock &&
2997 part->dock->panes.GetCount() == 1 &&
2998 part->dock->panes.Item(0)->IsFixed())
2999 return;
3000
3001 // panes that may not be resized should be ignored here
3002 if (part->pane && part->pane->IsFixed())
3003 return;
3004
3005 m_action = actionResize;
3006 m_action_part = part;
3007 m_action_hintrect = wxRect();
3008 m_action_start = wxPoint(event.m_x, event.m_y);
3009 m_action_offset = wxPoint(event.m_x - part->rect.x,
3010 event.m_y - part->rect.y);
3011 m_frame->CaptureMouse();
3012 }
3013 else if (part->type == wxDockUIPart::typePaneButton)
3014 {
3015 m_action = actionClickButton;
3016 m_action_part = part;
3017 m_action_start = wxPoint(event.m_x, event.m_y);
3018 m_frame->CaptureMouse();
3019
3020 UpdateButtonOnScreen(part, event);
3021 }
3022 else if (part->type == wxDockUIPart::typeCaption ||
3023 part->type == wxDockUIPart::typeGripper)
3024 {
3025 if (GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE)
3026 {
3027 // set the caption as active
3028 SetActivePane(m_panes, part->pane->window);
3029 Repaint();
3030 }
3031
3032 m_action = actionClickCaption;
3033 m_action_part = part;
3034 m_action_start = wxPoint(event.m_x, event.m_y);
3035 m_action_offset = wxPoint(event.m_x - part->rect.x,
3036 event.m_y - part->rect.y);
3037 m_frame->CaptureMouse();
3038 }
3039 #ifdef __WXMAC__
3040 else
3041 {
3042 event.Skip();
3043 }
3044 #endif
3045 }
3046 #ifdef __WXMAC__
3047 else
3048 {
3049 event.Skip();
3050 }
3051 #else
3052 event.Skip();
3053 #endif
3054 }
3055
3056
3057 void wxFrameManager::OnLeftUp(wxMouseEvent& event)
3058 {
3059 if (m_action == actionResize)
3060 {
3061 m_frame->ReleaseMouse();
3062
3063 // get rid of the hint rectangle
3064 wxScreenDC dc;
3065 DrawResizeHint(dc, m_action_hintrect);
3066
3067 // resize the dock or the pane
3068 if (m_action_part && m_action_part->type==wxDockUIPart::typeDockSizer)
3069 {
3070 wxRect& rect = m_action_part->dock->rect;
3071
3072 wxPoint new_pos(event.m_x - m_action_offset.x,
3073 event.m_y - m_action_offset.y);
3074
3075 switch (m_action_part->dock->dock_direction)
3076 {
3077 case wxAUI_DOCK_LEFT:
3078 m_action_part->dock->size = new_pos.x - rect.x;
3079 break;
3080 case wxAUI_DOCK_TOP:
3081 m_action_part->dock->size = new_pos.y - rect.y;
3082 break;
3083 case wxAUI_DOCK_RIGHT:
3084 m_action_part->dock->size = rect.x + rect.width -
3085 new_pos.x - m_action_part->rect.GetWidth();
3086 break;
3087 case wxAUI_DOCK_BOTTOM:
3088 m_action_part->dock->size = rect.y + rect.height -
3089 new_pos.y - m_action_part->rect.GetHeight();
3090 break;
3091 }
3092
3093 Update();
3094 Repaint(NULL);
3095 }
3096 else if (m_action_part &&
3097 m_action_part->type == wxDockUIPart::typePaneSizer)
3098 {
3099 wxDockInfo& dock = *m_action_part->dock;
3100 wxPaneInfo& pane = *m_action_part->pane;
3101
3102 int total_proportion = 0;
3103 int dock_pixels = 0;
3104 int new_pixsize = 0;
3105
3106 int caption_size = m_art->GetMetric(wxAUI_ART_CAPTION_SIZE);
3107 int pane_border_size = m_art->GetMetric(wxAUI_ART_PANE_BORDER_SIZE);
3108 int sash_size = m_art->GetMetric(wxAUI_ART_SASH_SIZE);
3109
3110 wxPoint new_pos(event.m_x - m_action_offset.x,
3111 event.m_y - m_action_offset.y);
3112
3113 // determine the pane rectangle by getting the pane part
3114 wxDockUIPart* pane_part = GetPanePart(pane.window);
3115 wxASSERT_MSG(pane_part,
3116 wxT("Pane border part not found -- shouldn't happen"));
3117
3118 // determine the new pixel size that the user wants;
3119 // this will help us recalculate the pane's proportion
3120 if (dock.IsHorizontal())
3121 new_pixsize = new_pos.x - pane_part->rect.x;
3122 else
3123 new_pixsize = new_pos.y - pane_part->rect.y;
3124
3125 // determine the size of the dock, based on orientation
3126 if (dock.IsHorizontal())
3127 dock_pixels = dock.rect.GetWidth();
3128 else
3129 dock_pixels = dock.rect.GetHeight();
3130
3131 // determine the total proportion of all resizable panes,
3132 // and the total size of the dock minus the size of all
3133 // the fixed panes
3134 int i, dock_pane_count = dock.panes.GetCount();
3135 int pane_position = -1;
3136 for (i = 0; i < dock_pane_count; ++i)
3137 {
3138 wxPaneInfo& p = *dock.panes.Item(i);
3139 if (p.window == pane.window)
3140 pane_position = i;
3141
3142 // while we're at it, subtract the pane sash
3143 // width from the dock width, because this would
3144 // skew our proportion calculations
3145 if (i > 0)
3146 dock_pixels -= sash_size;
3147
3148 // also, the whole size (including decorations) of
3149 // all fixed panes must also be subtracted, because they
3150 // are not part of the proportion calculation
3151 if (p.IsFixed())
3152 {
3153 if (dock.IsHorizontal())
3154 dock_pixels -= p.best_size.x;
3155 else
3156 dock_pixels -= p.best_size.y;
3157 }
3158 else
3159 {
3160 total_proportion += p.dock_proportion;
3161 }
3162 }
3163
3164 // find a pane in our dock to 'steal' space from or to 'give'
3165 // space to -- this is essentially what is done when a pane is
3166 // resized; the pane should usually be the first non-fixed pane
3167 // to the right of the action pane
3168 int borrow_pane = -1;
3169 for (i = pane_position+1; i < dock_pane_count; ++i)
3170 {
3171 wxPaneInfo& p = *dock.panes.Item(i);
3172 if (!p.IsFixed())
3173 {
3174 borrow_pane = i;
3175 break;
3176 }
3177 }
3178
3179
3180 // demand that the pane being resized is found in this dock
3181 // (this assert really never should be raised)
3182 wxASSERT_MSG(pane_position != -1, wxT("Pane not found in dock"));
3183
3184 // prevent division by zero
3185 if (dock_pixels == 0 || total_proportion == 0 || borrow_pane == -1)
3186 {
3187 m_action = actionNone;
3188 return;
3189 }
3190
3191 // calculate the new proportion of the pane
3192 int new_proportion = (new_pixsize*total_proportion)/dock_pixels;
3193
3194 // default minimum size
3195 int min_size = 0;
3196
3197 // check against the pane's minimum size, if specified. please note
3198 // that this is not enough to ensure that the minimum size will
3199 // not be violated, because the whole frame might later be shrunk,
3200 // causing the size of the pane to violate it's minimum size
3201 if (pane.min_size.IsFullySpecified())
3202 {
3203 min_size = 0;
3204
3205 if (pane.HasBorder())
3206 min_size += (pane_border_size*2);
3207
3208 // calculate minimum size with decorations (border,caption)
3209 if (pane_part->orientation == wxVERTICAL)
3210 {
3211 min_size += pane.min_size.y;
3212 if (pane.HasCaption())
3213 min_size += caption_size;
3214 }
3215 else
3216 {
3217 min_size += pane.min_size.x;
3218 }
3219 }
3220
3221
3222 // for some reason, an arithmatic error somewhere is causing
3223 // the proportion calculations to always be off by 1 pixel;
3224 // for now we will add the 1 pixel on, but we really should
3225 // determine what's causing this.
3226 min_size++;
3227
3228 int min_proportion = (min_size*total_proportion)/dock_pixels;
3229
3230 if (new_proportion < min_proportion)
3231 new_proportion = min_proportion;
3232
3233
3234
3235 int prop_diff = new_proportion - pane.dock_proportion;
3236
3237 // borrow the space from our neighbor pane to the
3238 // right or bottom (depending on orientation)
3239 dock.panes.Item(borrow_pane)->dock_proportion -= prop_diff;
3240 pane.dock_proportion = new_proportion;
3241
3242 // repaint
3243 Update();
3244 Repaint(NULL);
3245 }
3246 }
3247 else if (m_action == actionClickButton)
3248 {
3249 m_hover_button = NULL;
3250 m_frame->ReleaseMouse();
3251 UpdateButtonOnScreen(m_action_part, event);
3252
3253 // make sure we're still over the item that was originally clicked
3254 if (m_action_part == HitTest(event.GetX(), event.GetY()))
3255 {
3256 // fire button-click event
3257 wxFrameManagerEvent e(wxEVT_AUI_PANEBUTTON);
3258 e.SetPane(m_action_part->pane);
3259 e.SetButton(m_action_part->button->button_id);
3260 ProcessMgrEvent(e);
3261 }
3262 }
3263 else if (m_action == actionClickCaption)
3264 {
3265 m_frame->ReleaseMouse();
3266 }
3267 else if (m_action == actionDragFloatingPane)
3268 {
3269 m_frame->ReleaseMouse();
3270 }
3271 else if (m_action == actionDragToolbarPane)
3272 {
3273 m_frame->ReleaseMouse();
3274
3275 wxPaneInfo& pane = GetPane(m_action_window);
3276 wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
3277
3278 // save the new positions
3279 wxDockInfoPtrArray docks;
3280 FindDocks(m_docks, pane.dock_direction,
3281 pane.dock_layer, pane.dock_row, docks);
3282 if (docks.GetCount() == 1)
3283 {
3284 wxDockInfo& dock = *docks.Item(0);
3285
3286 wxArrayInt pane_positions, pane_sizes;
3287 GetPanePositionsAndSizes(dock, pane_positions, pane_sizes);
3288
3289 int i, dock_pane_count = dock.panes.GetCount();
3290 for (i = 0; i < dock_pane_count; ++i)
3291 dock.panes.Item(i)->dock_pos = pane_positions[i];
3292 }
3293
3294 pane.state &= ~wxPaneInfo::actionPane;
3295 Update();
3296 }
3297 else
3298 {
3299 event.Skip();
3300 }
3301
3302 m_action = actionNone;
3303 m_last_mouse_move = wxPoint(); // see comment in OnMotion()
3304 }
3305
3306
3307 void wxFrameManager::OnMotion(wxMouseEvent& event)
3308 {
3309 // sometimes when Update() is called from inside this method,
3310 // a spurious mouse move event is generated; this check will make
3311 // sure that only real mouse moves will get anywhere in this method;
3312 // this appears to be a bug somewhere, and I don't know where the
3313 // mouse move event is being generated. only verified on MSW
3314
3315 wxPoint mouse_pos = event.GetPosition();
3316 if (m_last_mouse_move == mouse_pos)
3317 return;
3318 m_last_mouse_move = mouse_pos;
3319
3320
3321 if (m_action == actionResize)
3322 {
3323 wxPoint pos = m_action_part->rect.GetPosition();
3324 if (m_action_part->orientation == wxHORIZONTAL)
3325 pos.y = wxMax(0, event.m_y - m_action_offset.y);
3326 else
3327 pos.x = wxMax(0, event.m_x - m_action_offset.x);
3328
3329 wxRect rect(m_frame->ClientToScreen(pos),
3330 m_action_part->rect.GetSize());
3331
3332 wxScreenDC dc;
3333 if (!m_action_hintrect.IsEmpty())
3334 DrawResizeHint(dc, m_action_hintrect);
3335 DrawResizeHint(dc, rect);
3336 m_action_hintrect = rect;
3337 }
3338 else if (m_action == actionClickCaption)
3339 {
3340 int drag_x_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_X);
3341 int drag_y_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_Y);
3342
3343 // caption has been clicked. we need to check if the mouse
3344 // is now being dragged. if it is, we need to change the
3345 // mouse action to 'drag'
3346 if (abs(event.m_x - m_action_start.x) > drag_x_threshold ||
3347 abs(event.m_y - m_action_start.y) > drag_y_threshold)
3348 {
3349 wxPaneInfo* pane_info = m_action_part->pane;
3350
3351 if (!pane_info->IsToolbar())
3352 {
3353 if ((m_flags & wxAUI_MGR_ALLOW_FLOATING) &&
3354 pane_info->IsFloatable())
3355 {
3356 m_action = actionDragFloatingPane;
3357
3358 // set initial float position
3359 wxPoint pt = m_frame->ClientToScreen(event.GetPosition());
3360 pane_info->floating_pos = wxPoint(pt.x - m_action_offset.x,
3361 pt.y - m_action_offset.y);
3362 // float the window
3363 pane_info->Float();
3364 Update();
3365
3366 m_action_window = pane_info->frame;
3367
3368 // action offset is used here to make it feel "natural" to the user
3369 // to drag a docked pane and suddenly have it become a floating frame.
3370 // Sometimes, however, the offset where the user clicked on the docked
3371 // caption is bigger than the width of the floating frame itself, so
3372 // in that case we need to set the action offset to a sensible value
3373 wxSize frame_size = m_action_window->GetSize();
3374 if (frame_size.x <= m_action_offset.x)
3375 m_action_offset.x = 30;
3376 }
3377 }
3378 else
3379 {
3380 m_action = actionDragToolbarPane;
3381 m_action_window = pane_info->window;
3382 }
3383 }
3384 }
3385 else if (m_action == actionDragFloatingPane)
3386 {
3387 wxPoint pt = m_frame->ClientToScreen(event.GetPosition());
3388 m_action_window->Move(pt.x - m_action_offset.x,
3389 pt.y - m_action_offset.y);
3390 }
3391 else if (m_action == actionDragToolbarPane)
3392 {
3393 wxPaneInfo& pane = GetPane(m_action_window);
3394 wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
3395
3396 pane.state |= wxPaneInfo::actionPane;
3397
3398 wxPoint pt = event.GetPosition();
3399 DoDrop(m_docks, m_panes, pane, pt, m_action_offset);
3400
3401 // if DoDrop() decided to float the pane, set up
3402 // the floating pane's initial position
3403 if (pane.IsFloating())
3404 {
3405 wxPoint pt = m_frame->ClientToScreen(event.GetPosition());
3406 pane.floating_pos = wxPoint(pt.x - m_action_offset.x,
3407 pt.y - m_action_offset.y);
3408 }
3409
3410 // this will do the actiual move operation;
3411 // in the case that the pane has been floated,
3412 // this call will create the floating pane
3413 // and do the reparenting
3414 Update();
3415
3416 // if the pane has been floated, change the mouse
3417 // action actionDragFloatingPane so that subsequent
3418 // EVT_MOTION() events will move the floating pane
3419 if (pane.IsFloating())
3420 {
3421 pane.state &= ~wxPaneInfo::actionPane;
3422 m_action = actionDragFloatingPane;
3423 m_action_window = pane.frame;
3424 }
3425 }
3426 else
3427 {
3428 wxDockUIPart* part = HitTest(event.GetX(), event.GetY());
3429 if (part && part->type == wxDockUIPart::typePaneButton)
3430 {
3431 if (part != m_hover_button)
3432 {
3433 // make the old button normal
3434 if (m_hover_button)
3435 UpdateButtonOnScreen(m_hover_button, event);
3436
3437 // mouse is over a button, so repaint the
3438 // button in hover mode
3439 UpdateButtonOnScreen(part, event);
3440 m_hover_button = part;
3441 }
3442 }
3443 else
3444 {
3445 if (m_hover_button)
3446 {
3447 m_hover_button = NULL;
3448 Repaint();
3449 }
3450 else
3451 {
3452 event.Skip();
3453 }
3454 }
3455 }
3456 }
3457
3458 void wxFrameManager::OnLeaveWindow(wxMouseEvent& WXUNUSED(event))
3459 {
3460 if (m_hover_button)
3461 {
3462 m_hover_button = NULL;
3463 Repaint();
3464 }
3465 }
3466
3467 void wxFrameManager::OnChildFocus(wxChildFocusEvent& event)
3468 {
3469 // when a child pane has it's focus set, we should change the
3470 // pane's active state to reflect this. (this is only true if
3471 // active panes are allowed by the owner)
3472 if (GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE)
3473 {
3474 if (GetPane(event.GetWindow()).IsOk())
3475 {
3476 SetActivePane(m_panes, event.GetWindow());
3477 m_frame->Refresh();
3478 }
3479 }
3480 }
3481
3482
3483 // OnPaneButton() is an event handler that is called
3484 // when a pane button has been pressed.
3485 void wxFrameManager::OnPaneButton(wxFrameManagerEvent& event)
3486 {
3487 wxPaneInfo& pane = *(event.pane);
3488
3489 if (event.button == wxPaneInfo::buttonClose)
3490 {
3491 pane.Hide();
3492 Update();
3493 }
3494 else if (event.button == wxPaneInfo::buttonPin)
3495 {
3496 if ((m_flags & wxAUI_MGR_ALLOW_FLOATING) &&
3497 pane.IsFloatable())
3498 pane.Float();
3499 Update();
3500 }
3501 }
3502
3503 #endif // wxUSE_AUI