1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/aui/framemanager.cpp
3 // Purpose: wxaui: wx advanced user interface - docking window manager
4 // Author: Benjamin I. Williams
8 // Copyright: (C) Copyright 2005-2006, Kirix Corporation, All Rights Reserved
9 // Licence: wxWindows Library Licence, Version 3.1
10 ///////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
20 #include "wx/wxprec.h"
28 #include "wx/aui/framemanager.h"
29 #include "wx/aui/dockart.h"
30 #include "wx/aui/floatpane.h"
33 #include "wx/settings.h"
35 #include "wx/dcclient.h"
36 #include "wx/dcscreen.h"
37 #include "wx/toolbar.h"
42 WX_CHECK_BUILD_OPTIONS("wxAUI")
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
)
52 wxPaneInfo wxNullPaneInfo
;
53 wxDockInfo wxNullDockInfo
;
54 DEFINE_EVENT_TYPE(wxEVT_AUI_PANEBUTTON
)
55 DEFINE_EVENT_TYPE(wxEVT_AUI_PANECLOSE
)
56 DEFINE_EVENT_TYPE(wxEVT_AUI_RENDER
)
59 // a few defines to avoid nameclashes
60 #define __MAC_OS_X_MEMORY_MANAGER_CLEAN__ 1
62 #include "wx/mac/private.h"
65 IMPLEMENT_DYNAMIC_CLASS(wxFrameManagerEvent
, wxEvent
)
68 // -- static utility functions --
70 static wxBitmap
wxPaneCreateStippleBitmap()
72 unsigned char data
[] = { 0,0,0,192,192,192, 192,192,192,0,0,0 };
73 wxImage
img(2,2,data
,true);
77 static void DrawResizeHint(wxDC
& dc
, const wxRect
& rect
)
79 wxBitmap stipple
= wxPaneCreateStippleBitmap();
80 wxBrush
brush(stipple
);
82 dc
.SetPen(*wxTRANSPARENT_PEN
);
84 dc
.SetLogicalFunction(wxXOR
);
85 dc
.DrawRectangle(rect
);
90 // CopyDocksAndPanes() - this utility function creates copies of
91 // the dock and pane info. wxDockInfo's usually contain pointers
92 // to wxPaneInfo classes, thus this function is necessary to reliably
93 // reconstruct that relationship in the new dock info and pane info arrays
95 static void CopyDocksAndPanes(wxDockInfoArray
& dest_docks
,
96 wxPaneInfoArray
& dest_panes
,
97 const wxDockInfoArray
& src_docks
,
98 const wxPaneInfoArray
& src_panes
)
100 dest_docks
= src_docks
;
101 dest_panes
= src_panes
;
102 int i
, j
, k
, dock_count
, pc1
, pc2
;
103 for (i
= 0, dock_count
= dest_docks
.GetCount(); i
< dock_count
; ++i
)
105 wxDockInfo
& dock
= dest_docks
.Item(i
);
106 for (j
= 0, pc1
= dock
.panes
.GetCount(); j
< pc1
; ++j
)
107 for (k
= 0, pc2
= src_panes
.GetCount(); k
< pc2
; ++k
)
108 if (dock
.panes
.Item(j
) == &src_panes
.Item(k
))
109 dock
.panes
.Item(j
) = &dest_panes
.Item(k
);
113 // GetMaxLayer() is an internal function which returns
114 // the highest layer inside the specified dock
115 static int GetMaxLayer(const wxDockInfoArray
& docks
, int dock_direction
)
117 int i
, dock_count
, max_layer
= 0;
118 for (i
= 0, dock_count
= docks
.GetCount(); i
< dock_count
; ++i
)
120 wxDockInfo
& dock
= docks
.Item(i
);
121 if (dock
.dock_direction
== dock_direction
&&
122 dock
.dock_layer
> max_layer
&& !dock
.fixed
)
123 max_layer
= dock
.dock_layer
;
129 // GetMaxRow() is an internal function which returns
130 // the highest layer inside the specified dock
131 static int GetMaxRow(const wxPaneInfoArray
& panes
, int direction
, int layer
)
133 int i
, pane_count
, max_row
= 0;
134 for (i
= 0, pane_count
= panes
.GetCount(); i
< pane_count
; ++i
)
136 wxPaneInfo
& pane
= panes
.Item(i
);
137 if (pane
.dock_direction
== direction
&&
138 pane
.dock_layer
== layer
&&
139 pane
.dock_row
> max_row
)
140 max_row
= pane
.dock_row
;
147 // DoInsertDockLayer() is an internal function that inserts a new dock
148 // layer by incrementing all existing dock layer values by one
149 static void DoInsertDockLayer(wxPaneInfoArray
& panes
,
154 for (i
= 0, pane_count
= panes
.GetCount(); i
< pane_count
; ++i
)
156 wxPaneInfo
& pane
= panes
.Item(i
);
157 if (!pane
.IsFloating() &&
158 pane
.dock_direction
== dock_direction
&&
159 pane
.dock_layer
>= dock_layer
)
164 // DoInsertDockLayer() is an internal function that inserts a new dock
165 // row by incrementing all existing dock row values by one
166 static void DoInsertDockRow(wxPaneInfoArray
& panes
,
172 for (i
= 0, pane_count
= panes
.GetCount(); i
< pane_count
; ++i
)
174 wxPaneInfo
& pane
= panes
.Item(i
);
175 if (!pane
.IsFloating() &&
176 pane
.dock_direction
== dock_direction
&&
177 pane
.dock_layer
== dock_layer
&&
178 pane
.dock_row
>= dock_row
)
183 // DoInsertDockLayer() is an internal function that inserts a space for
184 // another dock pane by incrementing all existing dock row values by one
185 static void DoInsertPane(wxPaneInfoArray
& panes
,
192 for (i
= 0, pane_count
= panes
.GetCount(); i
< pane_count
; ++i
)
194 wxPaneInfo
& pane
= panes
.Item(i
);
195 if (!pane
.IsFloating() &&
196 pane
.dock_direction
== dock_direction
&&
197 pane
.dock_layer
== dock_layer
&&
198 pane
.dock_row
== dock_row
&&
199 pane
.dock_pos
>= dock_pos
)
204 // FindDocks() is an internal function that returns a list of docks which meet
205 // the specified conditions in the parameters and returns a sorted array
206 // (sorted by layer and then row)
207 static void FindDocks(wxDockInfoArray
& docks
,
211 wxDockInfoPtrArray
& arr
)
213 int begin_layer
= dock_layer
;
214 int end_layer
= dock_layer
;
215 int begin_row
= dock_row
;
216 int end_row
= dock_row
;
217 int dock_count
= docks
.GetCount();
218 int layer
, row
, i
, max_row
= 0, max_layer
= 0;
220 // discover the maximum dock layer and the max row
221 for (i
= 0; i
< dock_count
; ++i
)
223 max_row
= wxMax(max_row
, docks
.Item(i
).dock_row
);
224 max_layer
= wxMax(max_layer
, docks
.Item(i
).dock_layer
);
227 // if no dock layer was specified, search all dock layers
228 if (dock_layer
== -1)
231 end_layer
= max_layer
;
234 // if no dock row was specified, search all dock row
243 for (layer
= begin_layer
; layer
<= end_layer
; ++layer
)
244 for (row
= begin_row
; row
<= end_row
; ++row
)
245 for (i
= 0; i
< dock_count
; ++i
)
247 wxDockInfo
& d
= docks
.Item(i
);
248 if (dock_direction
== -1 || dock_direction
== d
.dock_direction
)
250 if (d
.dock_layer
== layer
&& d
.dock_row
== row
)
256 // FindPaneInDock() looks up a specified window pointer inside a dock.
257 // If found, the corresponding wxPaneInfo pointer is returned, otherwise NULL.
258 static wxPaneInfo
* FindPaneInDock(const wxDockInfo
& dock
, wxWindow
* window
)
260 int i
, count
= dock
.panes
.GetCount();
261 for (i
= 0; i
< count
; ++i
)
263 wxPaneInfo
* p
= dock
.panes
.Item(i
);
264 if (p
->window
== window
)
270 // RemovePaneFromDocks() removes a pane window from all docks
271 // with a possible exception specified by parameter "except"
272 static void RemovePaneFromDocks(wxDockInfoArray
& docks
,
274 wxDockInfo
* except
= NULL
)
277 for (i
= 0, dock_count
= docks
.GetCount(); i
< dock_count
; ++i
)
279 wxDockInfo
& d
= docks
.Item(i
);
282 wxPaneInfo
* pi
= FindPaneInDock(d
, pane
.window
);
288 // RenumberDockRows() takes a dock and assigns sequential numbers
289 // to existing rows. Basically it takes out the gaps; so if a
290 // dock has rows with numbers 0,2,5, they will become 0,1,2
291 static void RenumberDockRows(wxDockInfoPtrArray
& docks
)
293 int i
, dock_count
, j
, pane_count
;
294 for (i
= 0, dock_count
= docks
.GetCount(); i
< dock_count
; ++i
)
296 wxDockInfo
& dock
= *docks
.Item(i
);
298 for (j
= 0, pane_count
= dock
.panes
.GetCount(); j
< pane_count
; ++j
)
299 dock
.panes
.Item(j
)->dock_row
= i
;
304 // SetActivePane() sets the active pane, as well as cycles through
305 // every other pane and makes sure that all others' active flags
307 static void SetActivePane(wxPaneInfoArray
& panes
, wxWindow
* active_pane
)
310 for (i
= 0, pane_count
= panes
.GetCount(); i
< pane_count
; ++i
)
312 wxPaneInfo
& pane
= panes
.Item(i
);
313 pane
.state
&= ~wxPaneInfo::optionActive
;
314 if (pane
.window
== active_pane
)
315 pane
.state
|= wxPaneInfo::optionActive
;
320 // this function is used to sort panes by dock position
321 static int PaneSortFunc(wxPaneInfo
** p1
, wxPaneInfo
** p2
)
323 return ((*p1
)->dock_pos
< (*p2
)->dock_pos
) ? -1 : 1;
327 // -- wxFrameManager class implementation --
330 BEGIN_EVENT_TABLE(wxFrameManager
, wxEvtHandler
)
331 EVT_AUI_PANEBUTTON(wxFrameManager::OnPaneButton
)
332 EVT_AUI_RENDER(wxFrameManager::OnRender
)
333 EVT_PAINT(wxFrameManager::OnPaint
)
334 EVT_ERASE_BACKGROUND(wxFrameManager::OnEraseBackground
)
335 EVT_SIZE(wxFrameManager::OnSize
)
336 EVT_SET_CURSOR(wxFrameManager::OnSetCursor
)
337 EVT_LEFT_DOWN(wxFrameManager::OnLeftDown
)
338 EVT_LEFT_UP(wxFrameManager::OnLeftUp
)
339 EVT_MOTION(wxFrameManager::OnMotion
)
340 EVT_LEAVE_WINDOW(wxFrameManager::OnLeaveWindow
)
341 EVT_CHILD_FOCUS(wxFrameManager::OnChildFocus
)
342 EVT_TIMER(101, wxFrameManager::OnHintFadeTimer
)
346 wxFrameManager::wxFrameManager(wxWindow
* managed_wnd
, unsigned int flags
)
348 m_action
= actionNone
;
349 m_last_mouse_move
= wxPoint();
350 m_hover_button
= NULL
;
351 m_art
= new wxDefaultDockArt
;
357 SetManagedWindow(managed_wnd
);
361 wxFrameManager::~wxFrameManager()
366 // GetPane() looks up a wxPaneInfo structure based
367 // on the supplied window pointer. Upon failure, GetPane()
368 // returns an empty wxPaneInfo, a condition which can be checked
369 // by calling wxPaneInfo::IsOk().
371 // The pane info's structure may then be modified. Once a pane's
372 // info is modified, wxFrameManager::Update() must be called to
373 // realize the changes in the UI.
375 wxPaneInfo
& wxFrameManager::GetPane(wxWindow
* window
)
378 for (i
= 0, pane_count
= m_panes
.GetCount(); i
< pane_count
; ++i
)
380 wxPaneInfo
& p
= m_panes
.Item(i
);
381 if (p
.window
== window
)
384 return wxNullPaneInfo
;
387 // this version of GetPane() looks up a pane based on a
388 // 'pane name', see above comment for more info
389 wxPaneInfo
& wxFrameManager::GetPane(const wxString
& name
)
392 for (i
= 0, pane_count
= m_panes
.GetCount(); i
< pane_count
; ++i
)
394 wxPaneInfo
& p
= m_panes
.Item(i
);
398 return wxNullPaneInfo
;
401 // GetAllPanes() returns a reference to all the pane info structures
402 wxPaneInfoArray
& wxFrameManager::GetAllPanes()
407 // HitTest() is an internal function which determines
408 // which UI item the specified coordinates are over
409 // (x,y) specify a position in client coordinates
410 wxDockUIPart
* wxFrameManager::HitTest(int x
, int y
)
412 wxDockUIPart
* result
= NULL
;
415 for (i
= 0, part_count
= m_uiparts
.GetCount(); i
< part_count
; ++i
)
417 wxDockUIPart
* item
= &m_uiparts
.Item(i
);
419 // we are not interested in typeDock, because this space
420 // isn't used to draw anything, just for measurements;
421 // besides, the entire dock area is covered with other
422 // rectangles, which we are interested in.
423 if (item
->type
== wxDockUIPart::typeDock
)
426 // if we already have a hit on a more specific item, we are not
427 // interested in a pane hit. If, however, we don't already have
428 // a hit, returning a pane hit is necessary for some operations
429 if ((item
->type
== wxDockUIPart::typePane
||
430 item
->type
== wxDockUIPart::typePaneBorder
) && result
)
433 // if the point is inside the rectangle, we have a hit
434 if (item
->rect
.Inside(x
,y
))
442 // SetFlags() and GetFlags() allow the owner to set various
443 // options which are global to wxFrameManager
444 void wxFrameManager::SetFlags(unsigned int flags
)
449 unsigned int wxFrameManager::GetFlags() const
455 // don't use these anymore as they are deprecated
456 // use Set/GetManagedFrame() instead
457 void wxFrameManager::SetFrame(wxFrame
* frame
)
459 SetManagedWindow((wxWindow
*)frame
);
462 wxFrame
* wxFrameManager::GetFrame() const
464 return (wxFrame
*)m_frame
;
470 // SetManagedWindow() is usually called once when the frame
471 // manager class is being initialized. "frame" specifies
472 // the frame which should be managed by the frame mananger
473 void wxFrameManager::SetManagedWindow(wxWindow
* frame
)
475 wxASSERT_MSG(frame
, wxT("specified frame must be non-NULL"));
478 m_frame
->PushEventHandler(this);
481 // if the owner is going to manage an MDI parent frame,
482 // we need to add the MDI client window as the default
485 if (frame
->IsKindOf(CLASSINFO(wxMDIParentFrame
)))
487 wxMDIParentFrame
* mdi_frame
= (wxMDIParentFrame
*)frame
;
488 wxWindow
* client_window
= mdi_frame
->GetClientWindow();
490 wxASSERT_MSG(client_window
, wxT("Client window is NULL!"));
492 AddPane(client_window
,
493 wxPaneInfo().Name(wxT("mdiclient")).
494 CenterPane().PaneBorder(false));
498 // Make a window to use for a transparent hint
499 #if defined(__WXMSW__)
500 m_hint_wnd
= new wxFrame(m_frame
, -1, wxEmptyString
, wxDefaultPosition
, wxSize(1,1),
501 wxFRAME_TOOL_WINDOW
|
502 wxFRAME_FLOAT_ON_PARENT
|
506 m_hint_wnd
->SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_ACTIVECAPTION
));
508 #elif defined(__WXMAC__)
509 // Using a miniframe with float and tool styles keeps the parent
510 // frame activated and highlighted as such...
511 m_hint_wnd
= new wxMiniFrame(m_frame
, -1, wxEmptyString
, wxDefaultPosition
, wxSize(1,1),
512 wxFRAME_FLOAT_ON_PARENT
513 | wxFRAME_TOOL_WINDOW
516 // Can't set the bg colour of a Frame in wxMac
517 wxPanel
* p
= new wxPanel(m_hint_wnd
);
519 // The default wxSYS_COLOUR_ACTIVECAPTION colour is a light silver
520 // color that is really hard to see, especially transparent.
521 // Until a better system color is decided upon we'll just use
523 p
->SetBackgroundColour(*wxBLUE
);
526 if (m_hint_wnd
&& !m_hint_wnd
->CanSetTransparent())
529 m_hint_wnd
->Destroy();
535 // UnInit() must be called, usually in the destructor
536 // of the frame class. If it is not called, usually this
537 // will result in a crash upon program exit
538 void wxFrameManager::UnInit()
540 m_frame
->RemoveEventHandler(this);
543 // GetManagedWindow() returns the window pointer being managed
544 wxWindow
* wxFrameManager::GetManagedWindow() const
549 wxDockArt
* wxFrameManager::GetArtProvider() const
554 void wxFrameManager::ProcessMgrEvent(wxFrameManagerEvent
& event
)
556 // first, give the owner frame a chance to override
559 if (m_frame
->ProcessEvent(event
))
566 // SetArtProvider() instructs wxFrameManager to use the
567 // specified art provider for all drawing calls. This allows
568 // plugable look-and-feel features. The pointer that is
569 // passed to this method subsequently belongs to wxFrameManager,
570 // and is deleted in the frame manager destructor
571 void wxFrameManager::SetArtProvider(wxDockArt
* art_provider
)
573 // delete the last art provider, if any
576 // assign the new art provider
577 m_art
= art_provider
;
581 bool wxFrameManager::AddPane(wxWindow
* window
, const wxPaneInfo
& pane_info
)
583 // check if the pane has a valid window
587 // check if the pane already exists
588 if (GetPane(pane_info
.window
).IsOk())
591 m_panes
.Add(pane_info
);
593 wxPaneInfo
& pinfo
= m_panes
.Last();
595 // set the pane window
596 pinfo
.window
= window
;
598 // if the pane's name identifier is blank, create a random string
599 if (pinfo
.name
.empty())
601 pinfo
.name
.Printf(wxT("%08lx%08x%08x%08lx"),
602 ((unsigned long)pinfo
.window
) & 0xffffffff,
603 (unsigned int)time(NULL
),
605 (unsigned int)GetTickCount(),
607 (unsigned int)clock(),
609 (unsigned long)m_panes
.GetCount());
612 // set initial proportion (if not already set)
613 if (pinfo
.dock_proportion
== 0)
614 pinfo
.dock_proportion
= 100000;
616 if (pinfo
.HasCloseButton() &&
617 pinfo
.buttons
.size() == 0)
620 button
.button_id
= wxPaneInfo::buttonClose
;
621 pinfo
.buttons
.Add(button
);
624 if (pinfo
.best_size
== wxDefaultSize
&&
627 pinfo
.best_size
= pinfo
.window
->GetClientSize();
629 if (pinfo
.window
->IsKindOf(CLASSINFO(wxToolBar
)))
631 // GetClientSize() doesn't get the best size for
632 // a toolbar under some newer versions of wxWidgets,
633 // so use GetBestSize()
634 pinfo
.best_size
= pinfo
.window
->GetBestSize();
636 // for some reason, wxToolBar::GetBestSize() is returning
637 // a size that is a pixel shy of the correct amount.
638 // I believe this to be the correct action, until
639 // wxToolBar::GetBestSize() is fixed. Is this assumption
644 if (pinfo
.min_size
!= wxDefaultSize
)
646 if (pinfo
.best_size
.x
< pinfo
.min_size
.x
)
647 pinfo
.best_size
.x
= pinfo
.min_size
.x
;
648 if (pinfo
.best_size
.y
< pinfo
.min_size
.y
)
649 pinfo
.best_size
.y
= pinfo
.min_size
.y
;
656 bool wxFrameManager::AddPane(wxWindow
* window
,
658 const wxString
& caption
)
661 pinfo
.Caption(caption
);
664 case wxTOP
: pinfo
.Top(); break;
665 case wxBOTTOM
: pinfo
.Bottom(); break;
666 case wxLEFT
: pinfo
.Left(); break;
667 case wxRIGHT
: pinfo
.Right(); break;
668 case wxCENTER
: pinfo
.CenterPane(); break;
670 return AddPane(window
, pinfo
);
673 bool wxFrameManager::AddPane(wxWindow
* window
,
674 const wxPaneInfo
& pane_info
,
675 const wxPoint
& drop_pos
)
677 if (!AddPane(window
, pane_info
))
680 wxPaneInfo
& pane
= GetPane(window
);
682 DoDrop(m_docks
, m_panes
, pane
, drop_pos
, wxPoint(0,0));
687 bool wxFrameManager::InsertPane(wxWindow
* window
, const wxPaneInfo
& pane_info
,
690 // shift the panes around, depending on the insert level
691 switch (insert_level
)
693 case wxAUI_INSERT_PANE
:
694 DoInsertPane(m_panes
,
695 pane_info
.dock_direction
,
696 pane_info
.dock_layer
,
700 case wxAUI_INSERT_ROW
:
701 DoInsertDockRow(m_panes
,
702 pane_info
.dock_direction
,
703 pane_info
.dock_layer
,
706 case wxAUI_INSERT_DOCK
:
707 DoInsertDockLayer(m_panes
,
708 pane_info
.dock_direction
,
709 pane_info
.dock_layer
);
713 // if the window already exists, we are basically just moving/inserting the
714 // existing window. If it doesn't exist, we need to add it and insert it
715 wxPaneInfo
& existing_pane
= GetPane(window
);
716 if (!existing_pane
.IsOk())
718 return AddPane(window
, pane_info
);
722 if (pane_info
.IsFloating())
724 existing_pane
.Float();
725 if (pane_info
.floating_pos
!= wxDefaultPosition
)
726 existing_pane
.FloatingPosition(pane_info
.floating_pos
);
727 if (pane_info
.floating_size
!= wxDefaultSize
)
728 existing_pane
.FloatingSize(pane_info
.floating_size
);
732 existing_pane
.Direction(pane_info
.dock_direction
);
733 existing_pane
.Layer(pane_info
.dock_layer
);
734 existing_pane
.Row(pane_info
.dock_row
);
735 existing_pane
.Position(pane_info
.dock_pos
);
743 // DetachPane() removes a pane from the frame manager. This
744 // method will not destroy the window that is removed.
745 bool wxFrameManager::DetachPane(wxWindow
* window
)
748 for (i
= 0, count
= m_panes
.GetCount(); i
< count
; ++i
)
750 wxPaneInfo
& p
= m_panes
.Item(i
);
751 if (p
.window
== window
)
755 // we have a floating frame which is being detached. We need to
756 // reparent it to m_frame and destroy the floating frame
759 p
.window
->SetSize(1,1);
760 p
.frame
->Show(false);
762 // reparent to m_frame and destroy the pane
763 p
.window
->Reparent(m_frame
);
764 p
.frame
->SetSizer(NULL
);
769 // make sure there are no references to this pane in our uiparts,
770 // just in case the caller doesn't call Update() immediately after
771 // the DetachPane() call. This prevets obscure crashes which would
772 // happen at window repaint if the caller forgets to call Update()
774 for (pi
= 0, part_count
= (int)m_uiparts
.GetCount(); pi
< part_count
; ++pi
)
776 wxDockUIPart
& part
= m_uiparts
.Item(pi
);
779 m_uiparts
.RemoveAt(pi
);
794 // EscapeDelimiters() changes ";" into "\;" and "|" into "\|"
795 // in the input string. This is an internal functions which is
796 // used for saving perspectives
797 static wxString
EscapeDelimiters(const wxString
& s
)
800 result
.Alloc(s
.length());
801 const wxChar
* ch
= s
.c_str();
804 if (*ch
== wxT(';') || *ch
== wxT('|'))
813 // SavePerspective() saves all pane information as a single string.
814 // This string may later be fed into LoadPerspective() to restore
815 // all pane settings. This save and load mechanism allows an
816 // exact pane configuration to be saved and restored at a later time
818 wxString
wxFrameManager::SavePerspective()
822 result
= wxT("layout1|");
824 int pane_i
, pane_count
= m_panes
.GetCount();
825 for (pane_i
= 0; pane_i
< pane_count
; ++pane_i
)
827 wxPaneInfo
& pane
= m_panes
.Item(pane_i
);
829 result
+= wxT("name=");
830 result
+= EscapeDelimiters(pane
.name
);
833 result
+= wxT("caption=");
834 result
+= EscapeDelimiters(pane
.caption
);
837 result
+= wxString::Format(wxT("state=%u;"), pane
.state
);
838 result
+= wxString::Format(wxT("dir=%d;"), pane
.dock_direction
);
839 result
+= wxString::Format(wxT("layer=%d;"), pane
.dock_layer
);
840 result
+= wxString::Format(wxT("row=%d;"), pane
.dock_row
);
841 result
+= wxString::Format(wxT("pos=%d;"), pane
.dock_pos
);
842 result
+= wxString::Format(wxT("prop=%d;"), pane
.dock_proportion
);
843 result
+= wxString::Format(wxT("bestw=%d;"), pane
.best_size
.x
);
844 result
+= wxString::Format(wxT("besth=%d;"), pane
.best_size
.y
);
845 result
+= wxString::Format(wxT("minw=%d;"), pane
.min_size
.x
);
846 result
+= wxString::Format(wxT("minh=%d;"), pane
.min_size
.y
);
847 result
+= wxString::Format(wxT("maxw=%d;"), pane
.max_size
.x
);
848 result
+= wxString::Format(wxT("maxh=%d;"), pane
.max_size
.y
);
849 result
+= wxString::Format(wxT("floatx=%d;"), pane
.floating_pos
.x
);
850 result
+= wxString::Format(wxT("floaty=%d;"), pane
.floating_pos
.y
);
851 result
+= wxString::Format(wxT("floatw=%d;"), pane
.floating_size
.x
);
852 result
+= wxString::Format(wxT("floath=%d"), pane
.floating_size
.y
);
856 int dock_i
, dock_count
= m_docks
.GetCount();
857 for (dock_i
= 0; dock_i
< dock_count
; ++dock_i
)
859 wxDockInfo
& dock
= m_docks
.Item(dock_i
);
861 result
+= wxString::Format(wxT("dock_size(%d,%d,%d)=%d|"),
862 dock
.dock_direction
, dock
.dock_layer
,
863 dock
.dock_row
, dock
.size
);
869 // LoadPerspective() loads a layout which was saved with SavePerspective()
870 // If the "update" flag parameter is true, the GUI will immediately be updated
872 bool wxFrameManager::LoadPerspective(const wxString
& layout
, bool update
)
874 wxString input
= layout
;
877 // check layout string version
878 part
= input
.BeforeFirst(wxT('|'));
879 input
= input
.AfterFirst(wxT('|'));
882 if (part
!= wxT("layout1"))
886 // mark all panes currently managed as docked and hidden
887 int pane_i
, pane_count
= m_panes
.GetCount();
888 for (pane_i
= 0; pane_i
< pane_count
; ++pane_i
)
889 m_panes
.Item(pane_i
).Dock().Hide();
891 // clear out the dock array; this will be reconstructed
894 // replace escaped characters so we can
895 // split up the string easily
896 input
.Replace(wxT("\\|"), wxT("\a"));
897 input
.Replace(wxT("\\;"), wxT("\b"));
903 wxString pane_part
= input
.BeforeFirst(wxT('|'));
904 input
= input
.AfterFirst(wxT('|'));
905 pane_part
.Trim(true);
907 // if the string is empty, we're done parsing
908 if (pane_part
.empty())
912 if (pane_part
.Left(9) == wxT("dock_size"))
914 wxString val_name
= pane_part
.BeforeFirst(wxT('='));
915 wxString value
= pane_part
.AfterFirst(wxT('='));
917 long dir
, layer
, row
, size
;
918 wxString piece
= val_name
.AfterFirst(wxT('('));
919 piece
= piece
.BeforeLast(wxT(')'));
920 piece
.BeforeFirst(wxT(',')).ToLong(&dir
);
921 piece
= piece
.AfterFirst(wxT(','));
922 piece
.BeforeFirst(wxT(',')).ToLong(&layer
);
923 piece
.AfterFirst(wxT(',')).ToLong(&row
);
927 dock
.dock_direction
= dir
;
928 dock
.dock_layer
= layer
;
937 wxString val_part
= pane_part
.BeforeFirst(wxT(';'));
938 pane_part
= pane_part
.AfterFirst(wxT(';'));
939 wxString val_name
= val_part
.BeforeFirst(wxT('='));
940 wxString value
= val_part
.AfterFirst(wxT('='));
941 val_name
.MakeLower();
943 val_name
.Trim(false);
947 if (val_name
.empty())
950 if (val_name
== wxT("name"))
952 else if (val_name
== wxT("caption"))
953 pane
.caption
= value
;
954 else if (val_name
== wxT("state"))
955 pane
.state
= (unsigned int)wxAtoi(value
.c_str());
956 else if (val_name
== wxT("dir"))
957 pane
.dock_direction
= wxAtoi(value
.c_str());
958 else if (val_name
== wxT("layer"))
959 pane
.dock_layer
= wxAtoi(value
.c_str());
960 else if (val_name
== wxT("row"))
961 pane
.dock_row
= wxAtoi(value
.c_str());
962 else if (val_name
== wxT("pos"))
963 pane
.dock_pos
= wxAtoi(value
.c_str());
964 else if (val_name
== wxT("prop"))
965 pane
.dock_proportion
= wxAtoi(value
.c_str());
966 else if (val_name
== wxT("bestw"))
967 pane
.best_size
.x
= wxAtoi(value
.c_str());
968 else if (val_name
== wxT("besth"))
969 pane
.best_size
.y
= wxAtoi(value
.c_str());
970 else if (val_name
== wxT("minw"))
971 pane
.min_size
.x
= wxAtoi(value
.c_str());
972 else if (val_name
== wxT("minh"))
973 pane
.min_size
.y
= wxAtoi(value
.c_str());
974 else if (val_name
== wxT("maxw"))
975 pane
.max_size
.x
= wxAtoi(value
.c_str());
976 else if (val_name
== wxT("maxh"))
977 pane
.max_size
.y
= wxAtoi(value
.c_str());
978 else if (val_name
== wxT("floatx"))
979 pane
.floating_pos
.x
= wxAtoi(value
.c_str());
980 else if (val_name
== wxT("floaty"))
981 pane
.floating_pos
.y
= wxAtoi(value
.c_str());
982 else if (val_name
== wxT("floatw"))
983 pane
.floating_size
.x
= wxAtoi(value
.c_str());
984 else if (val_name
== wxT("floath"))
985 pane
.floating_size
.y
= wxAtoi(value
.c_str());
987 wxFAIL_MSG(wxT("Bad Perspective String"));
991 // replace escaped characters so we can
992 // split up the string easily
993 pane
.name
.Replace(wxT("\a"), wxT("|"));
994 pane
.name
.Replace(wxT("\b"), wxT(";"));
995 pane
.caption
.Replace(wxT("\a"), wxT("|"));
996 pane
.caption
.Replace(wxT("\b"), wxT(";"));
998 wxPaneInfo
& p
= GetPane(pane
.name
);
1001 // the pane window couldn't be found
1002 // in the existing layout
1006 pane
.window
= p
.window
;
1007 pane
.frame
= p
.frame
;
1008 pane
.buttons
= p
.buttons
;
1019 void wxFrameManager::GetPanePositionsAndSizes(wxDockInfo
& dock
,
1020 wxArrayInt
& positions
,
1023 int caption_size
= m_art
->GetMetric(wxAUI_ART_CAPTION_SIZE
);
1024 int pane_border_size
= m_art
->GetMetric(wxAUI_ART_PANE_BORDER_SIZE
);
1025 int gripper_size
= m_art
->GetMetric(wxAUI_ART_GRIPPER_SIZE
);
1030 int offset
, action_pane
= -1;
1031 int pane_i
, pane_count
= dock
.panes
.GetCount();
1033 // find the pane marked as our action pane
1034 for (pane_i
= 0; pane_i
< pane_count
; ++pane_i
)
1036 wxPaneInfo
& pane
= *(dock
.panes
.Item(pane_i
));
1038 if (pane
.state
& wxPaneInfo::actionPane
)
1040 wxASSERT_MSG(action_pane
==-1, wxT("Too many fixed action panes"));
1041 action_pane
= pane_i
;
1045 // set up each panes default position, and
1046 // determine the size (width or height, depending
1047 // on the dock's orientation) of each pane
1048 for (pane_i
= 0; pane_i
< pane_count
; ++pane_i
)
1050 wxPaneInfo
& pane
= *(dock
.panes
.Item(pane_i
));
1051 positions
.Add(pane
.dock_pos
);
1054 if (pane
.HasBorder())
1055 size
+= (pane_border_size
*2);
1057 if (dock
.IsHorizontal())
1059 if (pane
.HasGripper() && !pane
.HasGripperTop())
1060 size
+= gripper_size
;
1061 size
+= pane
.best_size
.x
;
1065 if (pane
.HasGripper() && pane
.HasGripperTop())
1066 size
+= gripper_size
;
1068 if (pane
.HasCaption())
1069 size
+= caption_size
;
1070 size
+= pane
.best_size
.y
;
1076 // if there is no action pane, just return the default
1077 // positions (as specified in pane.pane_pos)
1078 if (action_pane
== -1)
1082 for (pane_i
= action_pane
-1; pane_i
>= 0; --pane_i
)
1084 int amount
= positions
[pane_i
+1] - (positions
[pane_i
] + sizes
[pane_i
]);
1089 positions
[pane_i
] -= -amount
;
1091 offset
+= sizes
[pane_i
];
1094 // if the dock mode is fixed, make sure none of the panes
1095 // overlap; we will bump panes that overlap
1097 for (pane_i
= action_pane
; pane_i
< pane_count
; ++pane_i
)
1099 int amount
= positions
[pane_i
] - offset
;
1103 positions
[pane_i
] += -amount
;
1105 offset
+= sizes
[pane_i
];
1110 void wxFrameManager::LayoutAddPane(wxSizer
* cont
,
1113 wxDockUIPartArray
& uiparts
,
1117 wxSizerItem
* sizer_item
;
1119 int caption_size
= m_art
->GetMetric(wxAUI_ART_CAPTION_SIZE
);
1120 int gripper_size
= m_art
->GetMetric(wxAUI_ART_GRIPPER_SIZE
);
1121 int pane_border_size
= m_art
->GetMetric(wxAUI_ART_PANE_BORDER_SIZE
);
1122 int pane_button_size
= m_art
->GetMetric(wxAUI_ART_PANE_BUTTON_SIZE
);
1124 // find out the orientation of the item (orientation for panes
1125 // is the same as the dock's orientation)
1127 if (dock
.IsHorizontal())
1128 orientation
= wxHORIZONTAL
;
1130 orientation
= wxVERTICAL
;
1132 // this variable will store the proportion
1133 // value that the pane will receive
1134 int pane_proportion
= pane
.dock_proportion
;
1136 wxBoxSizer
* horz_pane_sizer
= new wxBoxSizer(wxHORIZONTAL
);
1137 wxBoxSizer
* vert_pane_sizer
= new wxBoxSizer(wxVERTICAL
);
1139 if (pane
.HasGripper())
1141 if (pane
.HasGripperTop())
1142 sizer_item
= vert_pane_sizer
->Add(1, gripper_size
, 0, wxEXPAND
);
1144 sizer_item
= horz_pane_sizer
->Add(gripper_size
, 1, 0, wxEXPAND
);
1146 part
.type
= wxDockUIPart::typeGripper
;
1150 part
.orientation
= orientation
;
1151 part
.cont_sizer
= horz_pane_sizer
;
1152 part
.sizer_item
= sizer_item
;
1156 if (pane
.HasCaption())
1158 // create the caption sizer
1159 wxBoxSizer
* caption_sizer
= new wxBoxSizer(wxHORIZONTAL
);
1161 sizer_item
= caption_sizer
->Add(1, caption_size
, 1, wxEXPAND
);
1163 part
.type
= wxDockUIPart::typeCaption
;
1167 part
.orientation
= orientation
;
1168 part
.cont_sizer
= vert_pane_sizer
;
1169 part
.sizer_item
= sizer_item
;
1170 int caption_part_idx
= uiparts
.GetCount();
1173 // add pane buttons to the caption
1174 int i
, button_count
;
1175 for (i
= 0, button_count
= pane
.buttons
.GetCount();
1176 i
< button_count
; ++i
)
1178 wxPaneButton
& button
= pane
.buttons
.Item(i
);
1180 sizer_item
= caption_sizer
->Add(pane_button_size
,
1184 part
.type
= wxDockUIPart::typePaneButton
;
1187 part
.button
= &button
;
1188 part
.orientation
= orientation
;
1189 part
.cont_sizer
= caption_sizer
;
1190 part
.sizer_item
= sizer_item
;
1194 // add the caption sizer
1195 sizer_item
= vert_pane_sizer
->Add(caption_sizer
, 0, wxEXPAND
);
1197 uiparts
.Item(caption_part_idx
).sizer_item
= sizer_item
;
1200 // add the pane window itself
1203 sizer_item
= vert_pane_sizer
->Add(1, 1, 1, wxEXPAND
);
1207 sizer_item
= vert_pane_sizer
->Add(pane
.window
, 1, wxEXPAND
);
1208 // Don't do this because it breaks the pane size in floating windows
1209 // BIW: Right now commenting this out is causing problems with
1210 // an mdi client window as the center pane.
1211 vert_pane_sizer
->SetItemMinSize(pane
.window
, 1, 1);
1214 part
.type
= wxDockUIPart::typePane
;
1218 part
.orientation
= orientation
;
1219 part
.cont_sizer
= vert_pane_sizer
;
1220 part
.sizer_item
= sizer_item
;
1224 // determine if the pane should have a minimum size; if the pane is
1225 // non-resizable (fixed) then we must set a minimum size. Alternitavely,
1226 // if the pane.min_size is set, we must use that value as well
1228 wxSize min_size
= pane
.min_size
;
1231 if (min_size
== wxDefaultSize
)
1233 min_size
= pane
.best_size
;
1234 pane_proportion
= 0;
1238 if (min_size
!= wxDefaultSize
)
1240 vert_pane_sizer
->SetItemMinSize(
1241 vert_pane_sizer
->GetChildren().GetCount()-1,
1242 min_size
.x
, min_size
.y
);
1246 // add the verticle sizer (caption, pane window) to the
1247 // horizontal sizer (gripper, verticle sizer)
1248 horz_pane_sizer
->Add(vert_pane_sizer
, 1, wxEXPAND
);
1250 // finally, add the pane sizer to the dock sizer
1252 if (pane
.HasBorder())
1254 // allowing space for the pane's border
1255 sizer_item
= cont
->Add(horz_pane_sizer
, pane_proportion
,
1256 wxEXPAND
| wxALL
, pane_border_size
);
1258 part
.type
= wxDockUIPart::typePaneBorder
;
1262 part
.orientation
= orientation
;
1263 part
.cont_sizer
= cont
;
1264 part
.sizer_item
= sizer_item
;
1269 sizer_item
= cont
->Add(horz_pane_sizer
, pane_proportion
, wxEXPAND
);
1273 void wxFrameManager::LayoutAddDock(wxSizer
* cont
,
1275 wxDockUIPartArray
& uiparts
,
1278 wxSizerItem
* sizer_item
;
1281 int sash_size
= m_art
->GetMetric(wxAUI_ART_SASH_SIZE
);
1282 int orientation
= dock
.IsHorizontal() ? wxHORIZONTAL
: wxVERTICAL
;
1284 // resizable bottom and right docks have a sash before them
1285 if (!dock
.fixed
&& (dock
.dock_direction
== wxAUI_DOCK_BOTTOM
||
1286 dock
.dock_direction
== wxAUI_DOCK_RIGHT
))
1288 sizer_item
= cont
->Add(sash_size
, sash_size
, 0, wxEXPAND
);
1290 part
.type
= wxDockUIPart::typeDockSizer
;
1291 part
.orientation
= orientation
;
1295 part
.cont_sizer
= cont
;
1296 part
.sizer_item
= sizer_item
;
1300 // create the sizer for the dock
1301 wxSizer
* dock_sizer
= new wxBoxSizer(orientation
);
1303 // add each pane to the dock
1304 int pane_i
, pane_count
= dock
.panes
.GetCount();
1308 wxArrayInt pane_positions
, pane_sizes
;
1310 // figure out the real pane positions we will
1311 // use, without modifying the each pane's pane_pos member
1312 GetPanePositionsAndSizes(dock
, pane_positions
, pane_sizes
);
1315 for (pane_i
= 0; pane_i
< pane_count
; ++pane_i
)
1317 wxPaneInfo
& pane
= *(dock
.panes
.Item(pane_i
));
1318 int pane_pos
= pane_positions
.Item(pane_i
);
1320 int amount
= pane_pos
- offset
;
1323 if (dock
.IsVertical())
1324 sizer_item
= dock_sizer
->Add(1, amount
, 0, wxEXPAND
);
1326 sizer_item
= dock_sizer
->Add(amount
, 1, 0, wxEXPAND
);
1328 part
.type
= wxDockUIPart::typeBackground
;
1332 part
.orientation
= (orientation
==wxHORIZONTAL
) ? wxVERTICAL
:wxHORIZONTAL
;
1333 part
.cont_sizer
= dock_sizer
;
1334 part
.sizer_item
= sizer_item
;
1340 LayoutAddPane(dock_sizer
, dock
, pane
, uiparts
, spacer_only
);
1342 offset
+= pane_sizes
.Item(pane_i
);
1345 // at the end add a very small stretchable background area
1346 sizer_item
= dock_sizer
->Add(1,1, 1, wxEXPAND
);
1348 part
.type
= wxDockUIPart::typeBackground
;
1352 part
.orientation
= orientation
;
1353 part
.cont_sizer
= dock_sizer
;
1354 part
.sizer_item
= sizer_item
;
1359 for (pane_i
= 0; pane_i
< pane_count
; ++pane_i
)
1361 wxPaneInfo
& pane
= *(dock
.panes
.Item(pane_i
));
1363 // if this is not the first pane being added,
1364 // we need to add a pane sizer
1367 sizer_item
= dock_sizer
->Add(sash_size
, sash_size
, 0, wxEXPAND
);
1369 part
.type
= wxDockUIPart::typePaneSizer
;
1371 part
.pane
= dock
.panes
.Item(pane_i
-1);
1373 part
.orientation
= (orientation
==wxHORIZONTAL
) ? wxVERTICAL
:wxHORIZONTAL
;
1374 part
.cont_sizer
= dock_sizer
;
1375 part
.sizer_item
= sizer_item
;
1379 LayoutAddPane(dock_sizer
, dock
, pane
, uiparts
, spacer_only
);
1383 if (dock
.dock_direction
== wxAUI_DOCK_CENTER
)
1384 sizer_item
= cont
->Add(dock_sizer
, 1, wxEXPAND
);
1386 sizer_item
= cont
->Add(dock_sizer
, 0, wxEXPAND
);
1388 part
.type
= wxDockUIPart::typeDock
;
1392 part
.orientation
= orientation
;
1393 part
.cont_sizer
= cont
;
1394 part
.sizer_item
= sizer_item
;
1397 if (dock
.IsHorizontal())
1398 cont
->SetItemMinSize(dock_sizer
, 0, dock
.size
);
1400 cont
->SetItemMinSize(dock_sizer
, dock
.size
, 0);
1402 // top and left docks have a sash after them
1403 if (!dock
.fixed
&& (dock
.dock_direction
== wxAUI_DOCK_TOP
||
1404 dock
.dock_direction
== wxAUI_DOCK_LEFT
))
1406 sizer_item
= cont
->Add(sash_size
, sash_size
, 0, wxEXPAND
);
1408 part
.type
= wxDockUIPart::typeDockSizer
;
1412 part
.orientation
= orientation
;
1413 part
.cont_sizer
= cont
;
1414 part
.sizer_item
= sizer_item
;
1419 wxSizer
* wxFrameManager::LayoutAll(wxPaneInfoArray
& panes
,
1420 wxDockInfoArray
& docks
,
1421 wxDockUIPartArray
& uiparts
,
1424 wxBoxSizer
* container
= new wxBoxSizer(wxVERTICAL
);
1426 int pane_border_size
= m_art
->GetMetric(wxAUI_ART_PANE_BORDER_SIZE
);
1427 int caption_size
= m_art
->GetMetric(wxAUI_ART_CAPTION_SIZE
);
1428 wxSize cli_size
= m_frame
->GetClientSize();
1429 int i
, dock_count
, pane_count
;
1432 // empty all docks out
1433 for (i
= 0, dock_count
= docks
.GetCount(); i
< dock_count
; ++i
)
1434 docks
.Item(i
).panes
.Empty();
1436 // iterate through all known panes, filing each
1437 // of them into the appropriate dock. If the
1438 // pane does not exist in the dock, add it
1439 for (i
= 0, pane_count
= panes
.GetCount(); i
< pane_count
; ++i
)
1441 wxPaneInfo
& p
= panes
.Item(i
);
1443 // find any docks in this layer
1445 wxDockInfoPtrArray arr
;
1446 FindDocks(docks
, p
.dock_direction
, p
.dock_layer
, p
.dock_row
, arr
);
1448 if (arr
.GetCount() > 0)
1454 // dock was not found, so we need to create a new one
1456 d
.dock_direction
= p
.dock_direction
;
1457 d
.dock_layer
= p
.dock_layer
;
1458 d
.dock_row
= p
.dock_row
;
1460 dock
= &docks
.Last();
1464 if (p
.IsDocked() && p
.IsShown())
1466 // remove the pane from any existing docks except this one
1467 RemovePaneFromDocks(docks
, p
, dock
);
1469 // pane needs to be added to the dock,
1470 // if it doesn't already exist
1471 if (!FindPaneInDock(*dock
, p
.window
))
1472 dock
->panes
.Add(&p
);
1476 // remove the pane from any existing docks
1477 RemovePaneFromDocks(docks
, p
);
1482 // remove any empty docks
1483 for (i
= docks
.GetCount()-1; i
>= 0; --i
)
1485 if (docks
.Item(i
).panes
.GetCount() == 0)
1489 // configure the docks further
1490 for (i
= 0, dock_count
= docks
.GetCount(); i
< dock_count
; ++i
)
1492 wxDockInfo
& dock
= docks
.Item(i
);
1493 int j
, dock_pane_count
= dock
.panes
.GetCount();
1495 // sort the dock pane array by the pane's
1496 // dock position (dock_pos), in ascending order
1497 dock
.panes
.Sort(PaneSortFunc
);
1499 // for newly created docks, set up their initial size
1504 for (j
= 0; j
< dock_pane_count
; ++j
)
1506 wxPaneInfo
& pane
= *dock
.panes
.Item(j
);
1507 wxSize pane_size
= pane
.best_size
;
1508 if (pane_size
== wxDefaultSize
)
1509 pane_size
= pane
.min_size
;
1510 if (pane_size
== wxDefaultSize
)
1511 pane_size
= pane
.window
->GetSize();
1513 if (dock
.IsHorizontal())
1514 size
= wxMax(pane_size
.y
, size
);
1516 size
= wxMax(pane_size
.x
, size
);
1519 // add space for the border (two times), but only
1520 // if at least one pane inside the dock has a pane border
1521 for (j
= 0; j
< dock_pane_count
; ++j
)
1523 if (dock
.panes
.Item(j
)->HasBorder())
1525 size
+= (pane_border_size
*2);
1530 // if pane is on the top or bottom, add the caption height,
1531 // but only if at least one pane inside the dock has a caption
1532 if (dock
.IsHorizontal())
1534 for (j
= 0; j
< dock_pane_count
; ++j
)
1536 if (dock
.panes
.Item(j
)->HasCaption())
1538 size
+= caption_size
;
1544 // new dock's size may not be more than 1/3 of the frame size
1545 if (dock
.IsHorizontal())
1546 size
= wxMin(size
, cli_size
.y
/3);
1548 size
= wxMin(size
, cli_size
.x
/3);
1556 // determine the dock's minimum size
1557 bool plus_border
= false;
1558 bool plus_caption
= false;
1559 int dock_min_size
= 0;
1560 for (j
= 0; j
< dock_pane_count
; ++j
)
1562 wxPaneInfo
& pane
= *dock
.panes
.Item(j
);
1563 if (pane
.min_size
!= wxDefaultSize
)
1565 if (pane
.HasBorder())
1567 if (pane
.HasCaption())
1568 plus_caption
= true;
1569 if (dock
.IsHorizontal())
1571 if (pane
.min_size
.y
> dock_min_size
)
1572 dock_min_size
= pane
.min_size
.y
;
1576 if (pane
.min_size
.x
> dock_min_size
)
1577 dock_min_size
= pane
.min_size
.x
;
1583 dock_min_size
+= (pane_border_size
*2);
1584 if (plus_caption
&& dock
.IsHorizontal())
1585 dock_min_size
+= (caption_size
);
1587 dock
.min_size
= dock_min_size
;
1590 // if the pane's current size is less than it's
1591 // minimum, increase the dock's size to it's minimum
1592 if (dock
.size
< dock
.min_size
)
1593 dock
.size
= dock
.min_size
;
1596 // determine the dock's mode (fixed or proportional);
1597 // determine whether the dock has only toolbars
1598 bool action_pane_marked
= false;
1600 dock
.toolbar
= true;
1601 for (j
= 0; j
< dock_pane_count
; ++j
)
1603 wxPaneInfo
& pane
= *dock
.panes
.Item(j
);
1604 if (!pane
.IsFixed())
1606 if (!pane
.IsToolbar())
1607 dock
.toolbar
= false;
1608 if (pane
.state
& wxPaneInfo::actionPane
)
1609 action_pane_marked
= true;
1613 // if the dock mode is proportional and not fixed-pixel,
1614 // reassign the dock_pos to the sequential 0, 1, 2, 3;
1615 // e.g. remove gaps like 1, 2, 30, 500
1618 for (j
= 0; j
< dock_pane_count
; ++j
)
1620 wxPaneInfo
& pane
= *dock
.panes
.Item(j
);
1625 // if the dock mode is fixed, and none of the panes
1626 // are being moved right now, make sure the panes
1627 // do not overlap each other. If they do, we will
1628 // adjust the panes' positions
1629 if (dock
.fixed
&& !action_pane_marked
)
1631 wxArrayInt pane_positions
, pane_sizes
;
1632 GetPanePositionsAndSizes(dock
, pane_positions
, pane_sizes
);
1635 for (j
= 0; j
< dock_pane_count
; ++j
)
1637 wxPaneInfo
& pane
= *(dock
.panes
.Item(j
));
1638 pane
.dock_pos
= pane_positions
[j
];
1640 int amount
= pane
.dock_pos
- offset
;
1644 pane
.dock_pos
+= -amount
;
1646 offset
+= pane_sizes
[j
];
1651 // discover the maximum dock layer
1653 for (i
= 0; i
< dock_count
; ++i
)
1654 max_layer
= wxMax(max_layer
, docks
.Item(i
).dock_layer
);
1657 // clear out uiparts
1660 // create a bunch of box sizers,
1661 // from the innermost level outwards.
1662 wxSizer
* cont
= NULL
;
1663 wxSizer
* middle
= NULL
;
1667 for (layer
= 0; layer
<= max_layer
; ++layer
)
1669 wxDockInfoPtrArray arr
;
1671 // find any docks in this layer
1672 FindDocks(docks
, -1, layer
, -1, arr
);
1674 // if there aren't any, skip to the next layer
1678 wxSizer
* old_cont
= cont
;
1680 // create a container which will hold this layer's
1681 // docks (top, bottom, left, right)
1682 cont
= new wxBoxSizer(wxVERTICAL
);
1685 // find any top docks in this layer
1686 FindDocks(docks
, wxAUI_DOCK_TOP
, layer
, -1, arr
);
1687 RenumberDockRows(arr
);
1690 for (row
= 0, row_count
= arr
.GetCount(); row
< row_count
; ++row
)
1691 LayoutAddDock(cont
, *arr
.Item(row
), uiparts
, spacer_only
);
1695 // fill out the middle layer (which consists
1696 // of left docks, content area and right docks)
1698 middle
= new wxBoxSizer(wxHORIZONTAL
);
1700 // find any left docks in this layer
1701 FindDocks(docks
, wxAUI_DOCK_LEFT
, layer
, -1, arr
);
1702 RenumberDockRows(arr
);
1705 for (row
= 0, row_count
= arr
.GetCount(); row
< row_count
; ++row
)
1706 LayoutAddDock(middle
, *arr
.Item(row
), uiparts
, spacer_only
);
1709 // add content dock (or previous layer's sizer
1713 // find any center docks
1714 FindDocks(docks
, wxAUI_DOCK_CENTER
, -1, -1, arr
);
1717 for (row
= 0,row_count
= arr
.GetCount(); row
<row_count
; ++row
)
1718 LayoutAddDock(middle
, *arr
.Item(row
), uiparts
, spacer_only
);
1722 // there are no center docks, add a background area
1723 wxSizerItem
* sizer_item
= middle
->Add(1,1, 1, wxEXPAND
);
1725 part
.type
= wxDockUIPart::typeBackground
;
1729 part
.cont_sizer
= middle
;
1730 part
.sizer_item
= sizer_item
;
1736 middle
->Add(old_cont
, 1, wxEXPAND
);
1739 // find any right docks in this layer
1740 FindDocks(docks
, wxAUI_DOCK_RIGHT
, layer
, -1, arr
);
1741 RenumberDockRows(arr
);
1744 for (row
= arr
.GetCount()-1; row
>= 0; --row
)
1745 LayoutAddDock(middle
, *arr
.Item(row
), uiparts
, spacer_only
);
1748 cont
->Add(middle
, 1, wxEXPAND
);
1752 // find any bottom docks in this layer
1753 FindDocks(docks
, wxAUI_DOCK_BOTTOM
, layer
, -1, arr
);
1754 RenumberDockRows(arr
);
1757 for (row
= arr
.GetCount()-1; row
>= 0; --row
)
1758 LayoutAddDock(cont
, *arr
.Item(row
), uiparts
, spacer_only
);
1765 // no sizer available, because there are no docks,
1766 // therefore we will create a simple background area
1767 cont
= new wxBoxSizer(wxVERTICAL
);
1768 wxSizerItem
* sizer_item
= cont
->Add(1,1, 1, wxEXPAND
);
1770 part
.type
= wxDockUIPart::typeBackground
;
1774 part
.cont_sizer
= middle
;
1775 part
.sizer_item
= sizer_item
;
1779 container
->Add(cont
, 1, wxEXPAND
);
1784 // Update() updates the layout. Whenever changes are made to
1785 // one or more panes, this function should be called. It is the
1786 // external entry point for running the layout engine.
1788 void wxFrameManager::Update()
1791 int i
, pane_count
= m_panes
.GetCount();
1793 // delete old sizer first
1794 m_frame
->SetSizer(NULL
);
1796 // destroy floating panes which have been
1797 // redocked or are becoming non-floating
1798 for (i
= 0; i
< pane_count
; ++i
)
1800 wxPaneInfo
& p
= m_panes
.Item(i
);
1802 if (!p
.IsFloating() && p
.frame
)
1804 // because the pane is no longer in a floating, we need to
1805 // reparent it to m_frame and destroy the floating frame
1808 p
.window
->SetSize(1,1);
1809 p
.frame
->Show(false);
1811 // reparent to m_frame and destroy the pane
1812 p
.window
->Reparent(m_frame
);
1813 p
.frame
->SetSizer(NULL
);
1820 // create a layout for all of the panes
1821 sizer
= LayoutAll(m_panes
, m_docks
, m_uiparts
, false);
1823 // hide or show panes as necessary,
1824 // and float panes as necessary
1825 for (i
= 0; i
< pane_count
; ++i
)
1827 wxPaneInfo
& p
= m_panes
.Item(i
);
1831 if (p
.frame
== NULL
)
1833 // we need to create a frame for this
1834 // pane, which has recently been floated
1835 wxFloatingPane
* frame
= new wxFloatingPane(m_frame
,
1839 // on MSW and Mac, if the owner desires transparent dragging, and
1840 // the dragging is happening right now, then the floating
1841 // window should have this style by default
1842 if (m_action
== actionDragFloatingPane
&&
1843 (m_flags
& wxAUI_MGR_TRANSPARENT_DRAG
))
1844 frame
->SetTransparent(150);
1846 frame
->SetPaneWindow(p
);
1856 // frame already exists, make sure it's position
1857 // and size reflect the information in wxPaneInfo
1858 if (p
.frame
->GetPosition() != p
.floating_pos
)
1860 p
.frame
->SetSize(p
.floating_pos
.x
, p
.floating_pos
.y
,
1861 wxDefaultCoord
, wxDefaultCoord
,
1862 wxSIZE_USE_EXISTING
);
1863 //p.frame->Move(p.floating_pos.x, p.floating_pos.y);
1866 p
.frame
->Show(p
.IsShown());
1871 p
.window
->Show(p
.IsShown());
1874 // if "active panes" are no longer allowed, clear
1875 // any optionActive values from the pane states
1876 if ((m_flags
& wxAUI_MGR_ALLOW_ACTIVE_PANE
) == 0)
1878 p
.state
&= ~wxPaneInfo::optionActive
;
1883 // keep track of the old window rectangles so we can
1884 // refresh those windows whose rect has changed
1885 wxAuiRectArray old_pane_rects
;
1886 for (i
= 0; i
< pane_count
; ++i
)
1889 wxPaneInfo
& p
= m_panes
.Item(i
);
1891 if (p
.window
&& p
.IsShown() && p
.IsDocked())
1894 old_pane_rects
.Add(r
);
1900 // apply the new sizer
1901 m_frame
->SetSizer(sizer
);
1902 m_frame
->SetAutoLayout(false);
1907 // now that the frame layout is done, we need to check
1908 // the new pane rectangles against the old rectangles that
1909 // we saved a few lines above here. If the rectangles have
1910 // changed, the corresponding panes must also be updated
1911 for (i
= 0; i
< pane_count
; ++i
)
1913 wxPaneInfo
& p
= m_panes
.Item(i
);
1914 if (p
.window
&& p
.window
->IsShown() && p
.IsDocked())
1916 if (p
.rect
!= old_pane_rects
[i
])
1918 p
.window
->Refresh();
1927 // set frame's minimum size
1930 // N.B. More work needs to be done on frame minimum sizes;
1931 // this is some intresting code that imposes the minimum size,
1932 // but we may want to include a more flexible mechanism or
1933 // options for multiple minimum-size modes, e.g. strict or lax
1934 wxSize min_size = sizer->GetMinSize();
1935 wxSize frame_size = m_frame->GetSize();
1936 wxSize client_size = m_frame->GetClientSize();
1938 wxSize minframe_size(min_size.x+frame_size.x-client_size.x,
1939 min_size.y+frame_size.y-client_size.y );
1941 m_frame->SetMinSize(minframe_size);
1943 if (frame_size.x < minframe_size.x ||
1944 frame_size.y < minframe_size.y)
1945 sizer->Fit(m_frame);
1950 // DoFrameLayout() is an internal function which invokes wxSizer::Layout
1951 // on the frame's main sizer, then measures all the various UI items
1952 // and updates their internal rectangles. This should always be called
1953 // instead of calling m_frame->Layout() directly
1955 void wxFrameManager::DoFrameLayout()
1960 for (i
= 0, part_count
= m_uiparts
.GetCount(); i
< part_count
; ++i
)
1962 wxDockUIPart
& part
= m_uiparts
.Item(i
);
1964 // get the rectangle of the UI part
1965 // originally, this code looked like this:
1966 // part.rect = wxRect(part.sizer_item->GetPosition(),
1967 // part.sizer_item->GetSize());
1968 // this worked quite well, with one exception: the mdi
1969 // client window had a "deferred" size variable
1970 // that returned the wrong size. It looks like
1971 // a bug in wx, because the former size of the window
1972 // was being returned. So, we will retrieve the part's
1973 // rectangle via other means
1976 part
.rect
= part
.sizer_item
->GetRect();
1977 int flag
= part
.sizer_item
->GetFlag();
1978 int border
= part
.sizer_item
->GetBorder();
1981 part
.rect
.y
-= border
;
1982 part
.rect
.height
+= border
;
1986 part
.rect
.x
-= border
;
1987 part
.rect
.width
+= border
;
1989 if (flag
& wxBOTTOM
)
1990 part
.rect
.height
+= border
;
1992 part
.rect
.width
+= border
;
1995 if (part
.type
== wxDockUIPart::typeDock
)
1996 part
.dock
->rect
= part
.rect
;
1997 if (part
.type
== wxDockUIPart::typePane
)
1998 part
.pane
->rect
= part
.rect
;
2002 // GetPanePart() looks up the pane the pane border UI part (or the regular
2003 // pane part if there is no border). This allows the caller to get the exact
2004 // rectangle of the pane in question, including decorations like
2005 // caption and border (if any).
2007 wxDockUIPart
* wxFrameManager::GetPanePart(wxWindow
* wnd
)
2010 for (i
= 0, part_count
= m_uiparts
.GetCount(); i
< part_count
; ++i
)
2012 wxDockUIPart
& part
= m_uiparts
.Item(i
);
2013 if (part
.type
== wxDockUIPart::typePaneBorder
&&
2014 part
.pane
&& part
.pane
->window
== wnd
)
2017 for (i
= 0, part_count
= m_uiparts
.GetCount(); i
< part_count
; ++i
)
2019 wxDockUIPart
& part
= m_uiparts
.Item(i
);
2020 if (part
.type
== wxDockUIPart::typePane
&&
2021 part
.pane
&& part
.pane
->window
== wnd
)
2029 // GetDockPixelOffset() is an internal function which returns
2030 // a dock's offset in pixels from the left side of the window
2031 // (for horizontal docks) or from the top of the window (for
2032 // vertical docks). This value is necessary for calculating
2033 // fixel-pane/toolbar offsets when they are dragged.
2035 int wxFrameManager::GetDockPixelOffset(wxPaneInfo
& test
)
2037 // the only way to accurately calculate the dock's
2038 // offset is to actually run a theoretical layout
2040 int i
, part_count
, dock_count
;
2041 wxDockInfoArray docks
;
2042 wxPaneInfoArray panes
;
2043 wxDockUIPartArray uiparts
;
2044 CopyDocksAndPanes(docks
, panes
, m_docks
, m_panes
);
2047 wxSizer
* sizer
= LayoutAll(panes
, docks
, uiparts
, true);
2048 wxSize client_size
= m_frame
->GetClientSize();
2049 sizer
->SetDimension(0, 0, client_size
.x
, client_size
.y
);
2052 for (i
= 0, part_count
= uiparts
.GetCount(); i
< part_count
; ++i
)
2054 wxDockUIPart
& part
= uiparts
.Item(i
);
2055 part
.rect
= wxRect(part
.sizer_item
->GetPosition(),
2056 part
.sizer_item
->GetSize());
2057 if (part
.type
== wxDockUIPart::typeDock
)
2058 part
.dock
->rect
= part
.rect
;
2063 for (i
= 0, dock_count
= docks
.GetCount(); i
< dock_count
; ++i
)
2065 wxDockInfo
& dock
= docks
.Item(i
);
2066 if (test
.dock_direction
== dock
.dock_direction
&&
2067 test
.dock_layer
==dock
.dock_layer
&& test
.dock_row
==dock
.dock_row
)
2069 if (dock
.IsVertical())
2081 // ProcessDockResult() is a utility function used by DoDrop() - it checks
2082 // if a dock operation is allowed, the new dock position is copied into
2083 // the target info. If the operation was allowed, the function returns true.
2085 bool wxFrameManager::ProcessDockResult(wxPaneInfo
& target
,
2086 const wxPaneInfo
& new_pos
)
2088 bool allowed
= false;
2089 switch (new_pos
.dock_direction
)
2091 case wxAUI_DOCK_TOP
: allowed
= target
.IsTopDockable(); break;
2092 case wxAUI_DOCK_BOTTOM
: allowed
= target
.IsBottomDockable(); break;
2093 case wxAUI_DOCK_LEFT
: allowed
= target
.IsLeftDockable(); break;
2094 case wxAUI_DOCK_RIGHT
: allowed
= target
.IsRightDockable(); break;
2104 // DoDrop() is an important function. It basically takes a mouse position,
2105 // and determines where the pane's new position would be. If the pane is to be
2106 // dropped, it performs the drop operation using the specified dock and pane
2107 // arrays. By specifying copied dock and pane arrays when calling, a "what-if"
2108 // scenario can be performed, giving precise coordinates for drop hints.
2109 // If, however, wxFrameManager:m_docks and wxFrameManager::m_panes are specified
2110 // as parameters, the changes will be made to the main state arrays
2112 const int auiInsertRowPixels
= 10;
2113 const int auiNewRowPixels
= 40;
2114 const int auiLayerInsertPixels
= 40;
2115 const int auiLayerInsertOffset
= 5;
2117 bool wxFrameManager::DoDrop(wxDockInfoArray
& docks
,
2118 wxPaneInfoArray
& panes
,
2121 const wxPoint
& offset
)
2123 wxSize cli_size
= m_frame
->GetClientSize();
2125 wxPaneInfo drop
= target
;
2128 // The result should always be shown
2132 // Check to see if the pane has been dragged outside of the window
2133 // (or near to the outside of the window), if so, dock it along the edge
2136 int layer_insert_offset
= auiLayerInsertOffset
;
2137 if (target
.IsToolbar())
2138 layer_insert_offset
= 0;
2140 if (pt
.x
< layer_insert_offset
&&
2141 pt
.x
> layer_insert_offset
-auiLayerInsertPixels
)
2143 int new_layer
= wxMax(wxMax(GetMaxLayer(docks
, wxAUI_DOCK_LEFT
),
2144 GetMaxLayer(docks
, wxAUI_DOCK_BOTTOM
)),
2145 GetMaxLayer(docks
, wxAUI_DOCK_TOP
)) + 1;
2149 Position(pt
.y
- GetDockPixelOffset(drop
) - offset
.y
);
2150 return ProcessDockResult(target
, drop
);
2152 else if (pt
.y
< layer_insert_offset
&&
2153 pt
.y
> layer_insert_offset
-auiLayerInsertPixels
)
2155 int new_layer
= wxMax(wxMax(GetMaxLayer(docks
, wxAUI_DOCK_TOP
),
2156 GetMaxLayer(docks
, wxAUI_DOCK_LEFT
)),
2157 GetMaxLayer(docks
, wxAUI_DOCK_RIGHT
)) + 1;
2161 Position(pt
.x
- GetDockPixelOffset(drop
) - offset
.x
);
2162 return ProcessDockResult(target
, drop
);
2164 else if (pt
.x
>= cli_size
.x
- layer_insert_offset
&&
2165 pt
.x
< cli_size
.x
- layer_insert_offset
+ auiLayerInsertPixels
)
2167 int new_layer
= wxMax(wxMax(GetMaxLayer(docks
, wxAUI_DOCK_RIGHT
),
2168 GetMaxLayer(docks
, wxAUI_DOCK_TOP
)),
2169 GetMaxLayer(docks
, wxAUI_DOCK_BOTTOM
)) + 1;
2170 drop
.Dock().Right().
2173 Position(pt
.y
- GetDockPixelOffset(drop
) - offset
.y
);
2174 return ProcessDockResult(target
, drop
);
2176 else if (pt
.y
>= cli_size
.y
- layer_insert_offset
&&
2177 pt
.y
< cli_size
.y
- layer_insert_offset
+ auiLayerInsertPixels
)
2179 int new_layer
= wxMax(wxMax(GetMaxLayer(docks
, wxAUI_DOCK_BOTTOM
),
2180 GetMaxLayer(docks
, wxAUI_DOCK_LEFT
)),
2181 GetMaxLayer(docks
, wxAUI_DOCK_RIGHT
)) + 1;
2182 drop
.Dock().Bottom().
2185 Position(pt
.x
- GetDockPixelOffset(drop
) - offset
.x
);
2186 return ProcessDockResult(target
, drop
);
2190 wxDockUIPart
* part
= HitTest(pt
.x
, pt
.y
);
2193 if (drop
.IsToolbar())
2195 if (!part
|| !part
->dock
)
2199 // calculate the offset from where the dock begins
2200 // to the point where the user dropped the pane
2201 int dock_drop_offset
= 0;
2202 if (part
->dock
->IsHorizontal())
2203 dock_drop_offset
= pt
.x
- part
->dock
->rect
.x
- offset
.x
;
2205 dock_drop_offset
= pt
.y
- part
->dock
->rect
.y
- offset
.y
;
2208 // toolbars may only be moved in and to fixed-pane docks,
2209 // otherwise we will try to float the pane. Also, the pane
2210 // should float if being dragged over center pane windows
2211 if (!part
->dock
->fixed
|| part
->dock
->dock_direction
== wxAUI_DOCK_CENTER
)
2213 if ((m_flags
& wxAUI_MGR_ALLOW_FLOATING
) &&
2214 (drop
.IsFloatable() ||
2215 (part
->dock
->dock_direction
!= wxAUI_DOCK_CENTER
&&
2216 part
->dock
->dock_direction
!= wxAUI_DOCK_NONE
)))
2221 return ProcessDockResult(target
, drop
);
2225 Direction(part
->dock
->dock_direction
).
2226 Layer(part
->dock
->dock_layer
).
2227 Row(part
->dock
->dock_row
).
2228 Position(dock_drop_offset
);
2231 ((pt
.y
< part
->dock
->rect
.y
+ 2) && part
->dock
->IsHorizontal()) ||
2232 ((pt
.x
< part
->dock
->rect
.x
+ 2) && part
->dock
->IsVertical())
2233 ) && part
->dock
->panes
.GetCount() > 1)
2235 int row
= drop
.dock_row
;
2236 DoInsertDockRow(panes
, part
->dock
->dock_direction
,
2237 part
->dock
->dock_layer
,
2238 part
->dock
->dock_row
);
2239 drop
.dock_row
= row
;
2243 ((pt
.y
> part
->dock
->rect
.y
+ part
->dock
->rect
.height
- 2 ) && part
->dock
->IsHorizontal()) ||
2244 ((pt
.x
> part
->dock
->rect
.x
+ part
->dock
->rect
.width
- 2 ) && part
->dock
->IsVertical())
2245 ) && part
->dock
->panes
.GetCount() > 1)
2247 DoInsertDockRow(panes
, part
->dock
->dock_direction
,
2248 part
->dock
->dock_layer
,
2249 part
->dock
->dock_row
+1);
2250 drop
.dock_row
= part
->dock
->dock_row
+1;
2253 return ProcessDockResult(target
, drop
);
2262 if (part
->type
== wxDockUIPart::typePaneBorder
||
2263 part
->type
== wxDockUIPart::typeCaption
||
2264 part
->type
== wxDockUIPart::typeGripper
||
2265 part
->type
== wxDockUIPart::typePaneButton
||
2266 part
->type
== wxDockUIPart::typePane
||
2267 part
->type
== wxDockUIPart::typePaneSizer
||
2268 part
->type
== wxDockUIPart::typeDockSizer
||
2269 part
->type
== wxDockUIPart::typeBackground
)
2271 if (part
->type
== wxDockUIPart::typeDockSizer
)
2273 if (part
->dock
->panes
.GetCount() != 1)
2275 part
= GetPanePart(part
->dock
->panes
.Item(0)->window
);
2282 // If a normal frame is being dragged over a toolbar, insert it
2283 // along the edge under the toolbar, but over all other panes.
2284 // (this could be done much better, but somehow factoring this
2285 // calculation with the one at the beginning of this function)
2286 if (part
->dock
&& part
->dock
->toolbar
)
2290 switch (part
->dock
->dock_direction
)
2292 case wxAUI_DOCK_LEFT
:
2293 layer
= wxMax(wxMax(GetMaxLayer(docks
, wxAUI_DOCK_LEFT
),
2294 GetMaxLayer(docks
, wxAUI_DOCK_BOTTOM
)),
2295 GetMaxLayer(docks
, wxAUI_DOCK_TOP
));
2297 case wxAUI_DOCK_TOP
:
2298 layer
= wxMax(wxMax(GetMaxLayer(docks
, wxAUI_DOCK_TOP
),
2299 GetMaxLayer(docks
, wxAUI_DOCK_LEFT
)),
2300 GetMaxLayer(docks
, wxAUI_DOCK_RIGHT
));
2302 case wxAUI_DOCK_RIGHT
:
2303 layer
= wxMax(wxMax(GetMaxLayer(docks
, wxAUI_DOCK_RIGHT
),
2304 GetMaxLayer(docks
, wxAUI_DOCK_TOP
)),
2305 GetMaxLayer(docks
, wxAUI_DOCK_BOTTOM
));
2307 case wxAUI_DOCK_BOTTOM
:
2308 layer
= wxMax(wxMax(GetMaxLayer(docks
, wxAUI_DOCK_BOTTOM
),
2309 GetMaxLayer(docks
, wxAUI_DOCK_LEFT
)),
2310 GetMaxLayer(docks
, wxAUI_DOCK_RIGHT
));
2314 DoInsertDockRow(panes
, part
->dock
->dock_direction
,
2317 Direction(part
->dock
->dock_direction
).
2318 Layer(layer
).Row(0).Position(0);
2319 return ProcessDockResult(target
, drop
);
2326 part
= GetPanePart(part
->pane
->window
);
2330 bool insert_dock_row
= false;
2331 int insert_row
= part
->pane
->dock_row
;
2332 int insert_dir
= part
->pane
->dock_direction
;
2333 int insert_layer
= part
->pane
->dock_layer
;
2335 switch (part
->pane
->dock_direction
)
2337 case wxAUI_DOCK_TOP
:
2338 if (pt
.y
>= part
->rect
.y
&&
2339 pt
.y
< part
->rect
.y
+auiInsertRowPixels
)
2340 insert_dock_row
= true;
2342 case wxAUI_DOCK_BOTTOM
:
2343 if (pt
.y
> part
->rect
.y
+part
->rect
.height
-auiInsertRowPixels
&&
2344 pt
.y
<= part
->rect
.y
+ part
->rect
.height
)
2345 insert_dock_row
= true;
2347 case wxAUI_DOCK_LEFT
:
2348 if (pt
.x
>= part
->rect
.x
&&
2349 pt
.x
< part
->rect
.x
+auiInsertRowPixels
)
2350 insert_dock_row
= true;
2352 case wxAUI_DOCK_RIGHT
:
2353 if (pt
.x
> part
->rect
.x
+part
->rect
.width
-auiInsertRowPixels
&&
2354 pt
.x
<= part
->rect
.x
+part
->rect
.width
)
2355 insert_dock_row
= true;
2357 case wxAUI_DOCK_CENTER
:
2359 // "new row pixels" will be set to the default, but
2360 // must never exceed 20% of the window size
2361 int new_row_pixels_x
= auiNewRowPixels
;
2362 int new_row_pixels_y
= auiNewRowPixels
;
2364 if (new_row_pixels_x
> (part
->rect
.width
*20)/100)
2365 new_row_pixels_x
= (part
->rect
.width
*20)/100;
2367 if (new_row_pixels_y
> (part
->rect
.height
*20)/100)
2368 new_row_pixels_y
= (part
->rect
.height
*20)/100;
2371 // determine if the mouse pointer is in a location that
2372 // will cause a new row to be inserted. The hot spot positions
2373 // are along the borders of the center pane
2376 insert_dock_row
= true;
2377 if (pt
.x
>= part
->rect
.x
&&
2378 pt
.x
< part
->rect
.x
+new_row_pixels_x
)
2379 insert_dir
= wxAUI_DOCK_LEFT
;
2381 if (pt
.y
>= part
->rect
.y
&&
2382 pt
.y
< part
->rect
.y
+new_row_pixels_y
)
2383 insert_dir
= wxAUI_DOCK_TOP
;
2385 if (pt
.x
>= part
->rect
.x
+ part
->rect
.width
-new_row_pixels_x
&&
2386 pt
.x
< part
->rect
.x
+ part
->rect
.width
)
2387 insert_dir
= wxAUI_DOCK_RIGHT
;
2389 if (pt
.y
>= part
->rect
.y
+ part
->rect
.height
-new_row_pixels_y
&&
2390 pt
.y
< part
->rect
.y
+ part
->rect
.height
)
2391 insert_dir
= wxAUI_DOCK_BOTTOM
;
2395 insert_row
= GetMaxRow(panes
, insert_dir
, insert_layer
) + 1;
2399 if (insert_dock_row
)
2401 DoInsertDockRow(panes
, insert_dir
, insert_layer
, insert_row
);
2402 drop
.Dock().Direction(insert_dir
).
2403 Layer(insert_layer
).
2406 return ProcessDockResult(target
, drop
);
2409 // determine the mouse offset and the pane size, both in the
2410 // direction of the dock itself, and perpendicular to the dock
2414 if (part
->orientation
== wxVERTICAL
)
2416 offset
= pt
.y
- part
->rect
.y
;
2417 size
= part
->rect
.GetHeight();
2421 offset
= pt
.x
- part
->rect
.x
;
2422 size
= part
->rect
.GetWidth();
2425 int drop_position
= part
->pane
->dock_pos
;
2427 // if we are in the top/left part of the pane,
2428 // insert the pane before the pane being hovered over
2429 if (offset
<= size
/2)
2431 drop_position
= part
->pane
->dock_pos
;
2433 part
->pane
->dock_direction
,
2434 part
->pane
->dock_layer
,
2435 part
->pane
->dock_row
,
2436 part
->pane
->dock_pos
);
2439 // if we are in the bottom/right part of the pane,
2440 // insert the pane before the pane being hovered over
2441 if (offset
> size
/2)
2443 drop_position
= part
->pane
->dock_pos
+1;
2445 part
->pane
->dock_direction
,
2446 part
->pane
->dock_layer
,
2447 part
->pane
->dock_row
,
2448 part
->pane
->dock_pos
+1);
2452 Direction(part
->dock
->dock_direction
).
2453 Layer(part
->dock
->dock_layer
).
2454 Row(part
->dock
->dock_row
).
2455 Position(drop_position
);
2456 return ProcessDockResult(target
, drop
);
2463 void wxFrameManager::OnHintFadeTimer(wxTimerEvent
& WXUNUSED(event
))
2465 if (!m_hint_wnd
|| m_hint_fadeamt
>= 50)
2467 m_hint_fadetimer
.Stop();
2471 m_hint_fadeamt
+= 5;
2472 m_hint_wnd
->SetTransparent(m_hint_fadeamt
);
2475 void wxFrameManager::ShowHint(const wxRect
& rect
)
2477 if ((m_flags
& wxAUI_MGR_TRANSPARENT_HINT
) != 0 && m_hint_wnd
)
2479 if (m_last_hint
== rect
)
2483 wxByte initial_fade
= 50;
2484 if (m_flags
& wxAUI_MGR_TRANSPARENT_HINT_FADE
)
2487 if (! m_hint_wnd
->IsShown())
2490 // if we are dragging a floating pane, set the focus
2491 // back to that floating pane (otherwise it becomes unfocused)
2492 if (m_action
== actionDragFloatingPane
&& m_action_window
)
2493 m_action_window
->SetFocus();
2495 m_hint_wnd
->SetTransparent(initial_fade
);
2496 m_hint_wnd
->SetSize(rect
);
2497 m_hint_wnd
->Raise();
2500 if (m_flags
& wxAUI_MGR_TRANSPARENT_HINT_FADE
)
2502 // start fade in timer
2504 m_hint_fadetimer
.SetOwner(this, 101);
2505 m_hint_fadetimer
.Start(5);
2509 else // Not using a transparent hint window...
2512 if (m_last_hint
!= rect
)
2514 // remove the last hint rectangle
2520 wxScreenDC screendc
;
2521 wxRegion
clip(1, 1, 10000, 10000);
2523 // clip all floating windows, so we don't draw over them
2525 for (i
= 0, pane_count
= m_panes
.GetCount(); i
< pane_count
; ++i
)
2527 wxPaneInfo
& pane
= m_panes
.Item(i
);
2529 if (pane
.IsFloating() &&
2530 pane
.frame
->IsShown())
2532 wxRect rect
= pane
.frame
->GetRect();
2534 // wxGTK returns the client size, not the whole frame size
2540 clip
.Subtract(rect
);
2544 // As we can only hide the hint by redrawing the managed window, we
2545 // need to clip the region to the managed window too or we get
2546 // nasty redrawn problems.
2547 clip
.Intersect(m_frame
->GetRect());
2549 screendc
.SetClippingRegion(clip
);
2551 wxBitmap stipple
= wxPaneCreateStippleBitmap();
2552 wxBrush
brush(stipple
);
2553 screendc
.SetBrush(brush
);
2554 screendc
.SetPen(*wxTRANSPARENT_PEN
);
2556 screendc
.DrawRectangle(rect
.x
, rect
.y
, 5, rect
.height
);
2557 screendc
.DrawRectangle(rect
.x
+5, rect
.y
, rect
.width
-10, 5);
2558 screendc
.DrawRectangle(rect
.x
+rect
.width
-5, rect
.y
, 5, rect
.height
);
2559 screendc
.DrawRectangle(rect
.x
+5, rect
.y
+rect
.height
-5, rect
.width
-10, 5);
2563 void wxFrameManager::HideHint()
2565 // hides a transparent window hint, if there is one
2568 m_hint_wnd
->SetTransparent(0);
2569 m_hint_fadetimer
.Stop();
2570 m_last_hint
= wxRect();
2574 // hides a painted hint by redrawing the frame window
2575 if (!m_last_hint
.IsEmpty())
2579 m_last_hint
= wxRect();
2585 // DrawHintRect() draws a drop hint rectangle. First calls DoDrop() to
2586 // determine the exact position the pane would be at were if dropped. If
2587 // the pame would indeed become docked at the specified drop point,
2588 // DrawHintRect() then calls ShowHint() to indicate this drop rectangle.
2589 // "pane_window" is the window pointer of the pane being dragged, pt is
2590 // the mouse position, in client coordinates
2591 void wxFrameManager::DrawHintRect(wxWindow
* pane_window
,
2593 const wxPoint
& offset
)
2597 // we need to paint a hint rectangle; to find out the exact hint rectangle,
2598 // we will create a new temporary layout and then measure the resulting
2599 // rectangle; we will create a copy of the docking structures (m_dock)
2600 // so that we don't modify the real thing on screen
2602 int i
, pane_count
, part_count
;
2603 wxDockInfoArray docks
;
2604 wxPaneInfoArray panes
;
2605 wxDockUIPartArray uiparts
;
2606 wxPaneInfo hint
= GetPane(pane_window
);
2607 hint
.name
= wxT("__HINT__");
2613 CopyDocksAndPanes(docks
, panes
, m_docks
, m_panes
);
2615 // remove any pane already there which bears the same window;
2616 // this happens when you are moving a pane around in a dock
2617 for (i
= 0, pane_count
= panes
.GetCount(); i
< pane_count
; ++i
)
2619 if (panes
.Item(i
).window
== pane_window
)
2621 RemovePaneFromDocks(docks
, panes
.Item(i
));
2627 // find out where the new pane would be
2628 if (!DoDrop(docks
, panes
, hint
, pt
, offset
))
2636 wxSizer
* sizer
= LayoutAll(panes
, docks
, uiparts
, true);
2637 wxSize client_size
= m_frame
->GetClientSize();
2638 sizer
->SetDimension(0, 0, client_size
.x
, client_size
.y
);
2641 for (i
= 0, part_count
= uiparts
.GetCount();
2642 i
< part_count
; ++i
)
2644 wxDockUIPart
& part
= uiparts
.Item(i
);
2646 if (part
.type
== wxDockUIPart::typePaneBorder
&&
2647 part
.pane
&& part
.pane
->name
== wxT("__HINT__"))
2649 rect
= wxRect(part
.sizer_item
->GetPosition(),
2650 part
.sizer_item
->GetSize());
2663 // actually show the hint rectangle on the screen
2664 m_frame
->ClientToScreen(&rect
.x
, &rect
.y
);
2668 void wxFrameManager::OnFloatingPaneMoveStart(wxWindow
* wnd
)
2670 // try to find the pane
2671 wxPaneInfo
& pane
= GetPane(wnd
);
2672 wxASSERT_MSG(pane
.IsOk(), wxT("Pane window not found"));
2674 if (m_flags
& wxAUI_MGR_TRANSPARENT_DRAG
)
2675 pane
.frame
->SetTransparent(150);
2678 void wxFrameManager::OnFloatingPaneMoving(wxWindow
* wnd
)
2680 // try to find the pane
2681 wxPaneInfo
& pane
= GetPane(wnd
);
2682 wxASSERT_MSG(pane
.IsOk(), wxT("Pane window not found"));
2684 wxPoint pt
= ::wxGetMousePosition();
2685 wxPoint client_pt
= m_frame
->ScreenToClient(pt
);
2687 // calculate the offset from the upper left-hand corner
2688 // of the frame to the mouse pointer
2689 wxPoint frame_pos
= pane
.frame
->GetPosition();
2690 wxPoint
action_offset(pt
.x
-frame_pos
.x
, pt
.y
-frame_pos
.y
);
2692 // no hint for toolbar floating windows
2693 if (pane
.IsToolbar() && m_action
== actionDragFloatingPane
)
2695 if (m_action
== actionDragFloatingPane
)
2697 wxDockInfoArray docks
;
2698 wxPaneInfoArray panes
;
2699 wxDockUIPartArray uiparts
;
2700 wxPaneInfo hint
= pane
;
2702 CopyDocksAndPanes(docks
, panes
, m_docks
, m_panes
);
2704 // find out where the new pane would be
2705 if (!DoDrop(docks
, panes
, hint
, client_pt
))
2707 if (hint
.IsFloating())
2711 m_action
= actionDragToolbarPane
;
2712 m_action_window
= pane
.window
;
2721 // if a key modifier is pressed while dragging the frame,
2722 // don't dock the window
2723 if (wxGetKeyState(WXK_CONTROL
) || wxGetKeyState(WXK_ALT
))
2730 DrawHintRect(wnd
, client_pt
, action_offset
);
2733 // this cleans up some screen artifacts that are caused on GTK because
2734 // we aren't getting the exact size of the window (see comment
2744 void wxFrameManager::OnFloatingPaneMoved(wxWindow
* wnd
)
2746 // try to find the pane
2747 wxPaneInfo
& pane
= GetPane(wnd
);
2748 wxASSERT_MSG(pane
.IsOk(), wxT("Pane window not found"));
2750 wxPoint pt
= ::wxGetMousePosition();
2751 wxPoint client_pt
= m_frame
->ScreenToClient(pt
);
2753 // calculate the offset from the upper left-hand corner
2754 // of the frame to the mouse pointer
2755 wxPoint frame_pos
= pane
.frame
->GetPosition();
2756 wxPoint
action_offset(pt
.x
-frame_pos
.x
, pt
.y
-frame_pos
.y
);
2759 // if a key modifier is pressed while dragging the frame,
2760 // don't dock the window
2761 if (!wxGetKeyState(WXK_CONTROL
) && !wxGetKeyState(WXK_ALT
))
2763 // do the drop calculation
2764 DoDrop(m_docks
, m_panes
, pane
, client_pt
, action_offset
);
2767 // if the pane is still floating, update it's floating
2768 // position (that we store)
2769 if (pane
.IsFloating())
2771 pane
.floating_pos
= pane
.frame
->GetPosition();
2773 if (m_flags
& wxAUI_MGR_TRANSPARENT_DRAG
)
2774 pane
.frame
->SetTransparent(255);
2782 void wxFrameManager::OnFloatingPaneResized(wxWindow
* wnd
, const wxSize
& size
)
2784 // try to find the pane
2785 wxPaneInfo
& pane
= GetPane(wnd
);
2786 wxASSERT_MSG(pane
.IsOk(), wxT("Pane window not found"));
2788 pane
.floating_size
= size
;
2792 void wxFrameManager::OnFloatingPaneClosed(wxWindow
* wnd
, wxCloseEvent
& evt
)
2794 // try to find the pane
2795 wxPaneInfo
& pane
= GetPane(wnd
);
2796 wxASSERT_MSG(pane
.IsOk(), wxT("Pane window not found"));
2799 // fire pane close event
2800 wxFrameManagerEvent
e(wxEVT_AUI_PANECLOSE
);
2802 e
.SetCanVeto(evt
.CanVeto());
2812 // reparent the pane window back to us and
2813 // prepare the frame window for destruction
2814 pane
.window
->Show(false);
2815 pane
.window
->Reparent(m_frame
);
2823 void wxFrameManager::OnFloatingPaneActivated(wxWindow
* wnd
)
2825 if (GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE
)
2827 // try to find the pane
2828 wxASSERT_MSG(GetPane(wnd
).IsOk(), wxT("Pane window not found"));
2830 SetActivePane(m_panes
, wnd
);
2835 // OnRender() draws all of the pane captions, sashes,
2836 // backgrounds, captions, grippers, pane borders and buttons.
2837 // It renders the entire user interface.
2839 void wxFrameManager::OnRender(wxFrameManagerEvent
& evt
)
2841 wxDC
* dc
= evt
.GetDC();
2847 for (i
= 0, part_count
= m_uiparts
.GetCount();
2848 i
< part_count
; ++i
)
2850 wxDockUIPart
& part
= m_uiparts
.Item(i
);
2852 // don't draw hidden pane items
2853 if (part
.sizer_item
&& !part
.sizer_item
->IsShown())
2858 case wxDockUIPart::typeDockSizer
:
2859 case wxDockUIPart::typePaneSizer
:
2860 m_art
->DrawSash(*dc
, part
.orientation
, part
.rect
);
2862 case wxDockUIPart::typeBackground
:
2863 m_art
->DrawBackground(*dc
, part
.orientation
, part
.rect
);
2865 case wxDockUIPart::typeCaption
:
2866 m_art
->DrawCaption(*dc
, part
.pane
->caption
, part
.rect
, *part
.pane
);
2868 case wxDockUIPart::typeGripper
:
2869 m_art
->DrawGripper(*dc
, part
.rect
, *part
.pane
);
2871 case wxDockUIPart::typePaneBorder
:
2872 m_art
->DrawBorder(*dc
, part
.rect
, *part
.pane
);
2874 case wxDockUIPart::typePaneButton
:
2875 m_art
->DrawPaneButton(*dc
, part
.button
->button_id
,
2876 wxAUI_BUTTON_STATE_NORMAL
, part
.rect
, *part
.pane
);
2883 // Render() fire a render event, which is normally handled by
2884 // wxFrameManager::OnRender(). This allows the render function to
2885 // be overridden via the render event. This can be useful for paintin
2886 // custom graphics in the main window. Default behavior can be
2887 // invoked in the overridden function by calling OnRender()
2889 void wxFrameManager::Render(wxDC
* dc
)
2891 wxFrameManagerEvent
e(wxEVT_AUI_RENDER
);
2896 void wxFrameManager::Repaint(wxDC
* dc
)
2901 m_frame
->Refresh() ;
2907 m_frame
->GetClientSize(&w
, &h
);
2909 // figure out which dc to use; if one
2910 // has been specified, use it, otherwise
2912 wxClientDC
* client_dc
= NULL
;
2915 client_dc
= new wxClientDC(m_frame
);
2919 // if the frame has a toolbar, the client area
2920 // origin will not be (0,0).
2921 wxPoint pt
= m_frame
->GetClientAreaOrigin();
2922 if (pt
.x
!= 0 || pt
.y
!= 0)
2923 dc
->SetDeviceOrigin(pt
.x
, pt
.y
);
2925 // render all the items
2928 // if we created a client_dc, delete it
2933 void wxFrameManager::OnPaint(wxPaintEvent
& WXUNUSED(event
))
2935 wxPaintDC
dc(m_frame
);
2939 void wxFrameManager::OnEraseBackground(wxEraseEvent
& event
)
2948 void wxFrameManager::OnSize(wxSizeEvent
& WXUNUSED(event
))
2958 void wxFrameManager::OnSetCursor(wxSetCursorEvent
& event
)
2961 wxDockUIPart
* part
= HitTest(event
.GetX(), event
.GetY());
2962 wxCursor cursor
= wxNullCursor
;
2966 if (part
->type
== wxDockUIPart::typeDockSizer
||
2967 part
->type
== wxDockUIPart::typePaneSizer
)
2969 // a dock may not be resized if it has a single
2970 // pane which is not resizable
2971 if (part
->type
== wxDockUIPart::typeDockSizer
&& part
->dock
&&
2972 part
->dock
->panes
.GetCount() == 1 &&
2973 part
->dock
->panes
.Item(0)->IsFixed())
2976 // panes that may not be resized do not get a sizing cursor
2977 if (part
->pane
&& part
->pane
->IsFixed())
2980 if (part
->orientation
== wxVERTICAL
)
2981 cursor
= wxCursor(wxCURSOR_SIZEWE
);
2983 cursor
= wxCursor(wxCURSOR_SIZENS
);
2985 else if (part
->type
== wxDockUIPart::typeGripper
)
2987 cursor
= wxCursor(wxCURSOR_SIZING
);
2991 event
.SetCursor(cursor
);
2996 void wxFrameManager::UpdateButtonOnScreen(wxDockUIPart
* button_ui_part
,
2997 const wxMouseEvent
& event
)
2999 wxDockUIPart
* hit_test
= HitTest(event
.GetX(), event
.GetY());
3001 int state
= wxAUI_BUTTON_STATE_NORMAL
;
3003 if (hit_test
== button_ui_part
)
3005 if (event
.LeftDown())
3006 state
= wxAUI_BUTTON_STATE_PRESSED
;
3008 state
= wxAUI_BUTTON_STATE_HOVER
;
3012 if (event
.LeftDown())
3013 state
= wxAUI_BUTTON_STATE_HOVER
;
3016 // now repaint the button with hover state
3017 wxClientDC
cdc(m_frame
);
3019 // if the frame has a toolbar, the client area
3020 // origin will not be (0,0).
3021 wxPoint pt
= m_frame
->GetClientAreaOrigin();
3022 if (pt
.x
!= 0 || pt
.y
!= 0)
3023 cdc
.SetDeviceOrigin(pt
.x
, pt
.y
);
3025 m_art
->DrawPaneButton(cdc
,
3026 button_ui_part
->button
->button_id
,
3028 button_ui_part
->rect
,
3032 void wxFrameManager::OnLeftDown(wxMouseEvent
& event
)
3034 wxDockUIPart
* part
= HitTest(event
.GetX(), event
.GetY());
3037 if (part
->dock
&& part
->dock
->dock_direction
== wxAUI_DOCK_CENTER
)
3040 if (part
->type
== wxDockUIPart::typeDockSizer
||
3041 part
->type
== wxDockUIPart::typePaneSizer
)
3043 // a dock may not be resized if it has a single
3044 // pane which is not resizable
3045 if (part
->type
== wxDockUIPart::typeDockSizer
&& part
->dock
&&
3046 part
->dock
->panes
.GetCount() == 1 &&
3047 part
->dock
->panes
.Item(0)->IsFixed())
3050 // panes that may not be resized should be ignored here
3051 if (part
->pane
&& part
->pane
->IsFixed())
3054 m_action
= actionResize
;
3055 m_action_part
= part
;
3056 m_action_hintrect
= wxRect();
3057 m_action_start
= wxPoint(event
.m_x
, event
.m_y
);
3058 m_action_offset
= wxPoint(event
.m_x
- part
->rect
.x
,
3059 event
.m_y
- part
->rect
.y
);
3060 m_frame
->CaptureMouse();
3062 else if (part
->type
== wxDockUIPart::typePaneButton
)
3064 m_action
= actionClickButton
;
3065 m_action_part
= part
;
3066 m_action_start
= wxPoint(event
.m_x
, event
.m_y
);
3067 m_frame
->CaptureMouse();
3069 UpdateButtonOnScreen(part
, event
);
3071 else if (part
->type
== wxDockUIPart::typeCaption
||
3072 part
->type
== wxDockUIPart::typeGripper
)
3074 if (GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE
)
3076 // set the caption as active
3077 SetActivePane(m_panes
, part
->pane
->window
);
3081 m_action
= actionClickCaption
;
3082 m_action_part
= part
;
3083 m_action_start
= wxPoint(event
.m_x
, event
.m_y
);
3084 m_action_offset
= wxPoint(event
.m_x
- part
->rect
.x
,
3085 event
.m_y
- part
->rect
.y
);
3086 m_frame
->CaptureMouse();
3106 void wxFrameManager::OnLeftUp(wxMouseEvent
& event
)
3108 if (m_action
== actionResize
)
3110 m_frame
->ReleaseMouse();
3112 // get rid of the hint rectangle
3114 DrawResizeHint(dc
, m_action_hintrect
);
3116 // resize the dock or the pane
3117 if (m_action_part
&& m_action_part
->type
==wxDockUIPart::typeDockSizer
)
3119 wxRect
& rect
= m_action_part
->dock
->rect
;
3121 wxPoint
new_pos(event
.m_x
- m_action_offset
.x
,
3122 event
.m_y
- m_action_offset
.y
);
3124 switch (m_action_part
->dock
->dock_direction
)
3126 case wxAUI_DOCK_LEFT
:
3127 m_action_part
->dock
->size
= new_pos
.x
- rect
.x
;
3129 case wxAUI_DOCK_TOP
:
3130 m_action_part
->dock
->size
= new_pos
.y
- rect
.y
;
3132 case wxAUI_DOCK_RIGHT
:
3133 m_action_part
->dock
->size
= rect
.x
+ rect
.width
-
3134 new_pos
.x
- m_action_part
->rect
.GetWidth();
3136 case wxAUI_DOCK_BOTTOM
:
3137 m_action_part
->dock
->size
= rect
.y
+ rect
.height
-
3138 new_pos
.y
- m_action_part
->rect
.GetHeight();
3145 else if (m_action_part
&&
3146 m_action_part
->type
== wxDockUIPart::typePaneSizer
)
3148 wxDockInfo
& dock
= *m_action_part
->dock
;
3149 wxPaneInfo
& pane
= *m_action_part
->pane
;
3151 int total_proportion
= 0;
3152 int dock_pixels
= 0;
3153 int new_pixsize
= 0;
3155 int caption_size
= m_art
->GetMetric(wxAUI_ART_CAPTION_SIZE
);
3156 int pane_border_size
= m_art
->GetMetric(wxAUI_ART_PANE_BORDER_SIZE
);
3157 int sash_size
= m_art
->GetMetric(wxAUI_ART_SASH_SIZE
);
3159 wxPoint
new_pos(event
.m_x
- m_action_offset
.x
,
3160 event
.m_y
- m_action_offset
.y
);
3162 // determine the pane rectangle by getting the pane part
3163 wxDockUIPart
* pane_part
= GetPanePart(pane
.window
);
3164 wxASSERT_MSG(pane_part
,
3165 wxT("Pane border part not found -- shouldn't happen"));
3167 // determine the new pixel size that the user wants;
3168 // this will help us recalculate the pane's proportion
3169 if (dock
.IsHorizontal())
3170 new_pixsize
= new_pos
.x
- pane_part
->rect
.x
;
3172 new_pixsize
= new_pos
.y
- pane_part
->rect
.y
;
3174 // determine the size of the dock, based on orientation
3175 if (dock
.IsHorizontal())
3176 dock_pixels
= dock
.rect
.GetWidth();
3178 dock_pixels
= dock
.rect
.GetHeight();
3180 // determine the total proportion of all resizable panes,
3181 // and the total size of the dock minus the size of all
3183 int i
, dock_pane_count
= dock
.panes
.GetCount();
3184 int pane_position
= -1;
3185 for (i
= 0; i
< dock_pane_count
; ++i
)
3187 wxPaneInfo
& p
= *dock
.panes
.Item(i
);
3188 if (p
.window
== pane
.window
)
3191 // while we're at it, subtract the pane sash
3192 // width from the dock width, because this would
3193 // skew our proportion calculations
3195 dock_pixels
-= sash_size
;
3197 // also, the whole size (including decorations) of
3198 // all fixed panes must also be subtracted, because they
3199 // are not part of the proportion calculation
3202 if (dock
.IsHorizontal())
3203 dock_pixels
-= p
.best_size
.x
;
3205 dock_pixels
-= p
.best_size
.y
;
3209 total_proportion
+= p
.dock_proportion
;
3213 // find a pane in our dock to 'steal' space from or to 'give'
3214 // space to -- this is essentially what is done when a pane is
3215 // resized; the pane should usually be the first non-fixed pane
3216 // to the right of the action pane
3217 int borrow_pane
= -1;
3218 for (i
= pane_position
+1; i
< dock_pane_count
; ++i
)
3220 wxPaneInfo
& p
= *dock
.panes
.Item(i
);
3229 // demand that the pane being resized is found in this dock
3230 // (this assert really never should be raised)
3231 wxASSERT_MSG(pane_position
!= -1, wxT("Pane not found in dock"));
3233 // prevent division by zero
3234 if (dock_pixels
== 0 || total_proportion
== 0 || borrow_pane
== -1)
3236 m_action
= actionNone
;
3240 // calculate the new proportion of the pane
3241 int new_proportion
= (new_pixsize
*total_proportion
)/dock_pixels
;
3243 // default minimum size
3246 // check against the pane's minimum size, if specified. please note
3247 // that this is not enough to ensure that the minimum size will
3248 // not be violated, because the whole frame might later be shrunk,
3249 // causing the size of the pane to violate it's minimum size
3250 if (pane
.min_size
.IsFullySpecified())
3254 if (pane
.HasBorder())
3255 min_size
+= (pane_border_size
*2);
3257 // calculate minimum size with decorations (border,caption)
3258 if (pane_part
->orientation
== wxVERTICAL
)
3260 min_size
+= pane
.min_size
.y
;
3261 if (pane
.HasCaption())
3262 min_size
+= caption_size
;
3266 min_size
+= pane
.min_size
.x
;
3271 // for some reason, an arithmatic error somewhere is causing
3272 // the proportion calculations to always be off by 1 pixel;
3273 // for now we will add the 1 pixel on, but we really should
3274 // determine what's causing this.
3277 int min_proportion
= (min_size
*total_proportion
)/dock_pixels
;
3279 if (new_proportion
< min_proportion
)
3280 new_proportion
= min_proportion
;
3284 int prop_diff
= new_proportion
- pane
.dock_proportion
;
3286 // borrow the space from our neighbor pane to the
3287 // right or bottom (depending on orientation)
3288 dock
.panes
.Item(borrow_pane
)->dock_proportion
-= prop_diff
;
3289 pane
.dock_proportion
= new_proportion
;
3296 else if (m_action
== actionClickButton
)
3298 m_hover_button
= NULL
;
3299 m_frame
->ReleaseMouse();
3300 UpdateButtonOnScreen(m_action_part
, event
);
3302 // make sure we're still over the item that was originally clicked
3303 if (m_action_part
== HitTest(event
.GetX(), event
.GetY()))
3305 // fire button-click event
3306 wxFrameManagerEvent
e(wxEVT_AUI_PANEBUTTON
);
3307 e
.SetPane(m_action_part
->pane
);
3308 e
.SetButton(m_action_part
->button
->button_id
);
3312 else if (m_action
== actionClickCaption
)
3314 m_frame
->ReleaseMouse();
3316 else if (m_action
== actionDragFloatingPane
)
3318 m_frame
->ReleaseMouse();
3320 else if (m_action
== actionDragToolbarPane
)
3322 m_frame
->ReleaseMouse();
3324 wxPaneInfo
& pane
= GetPane(m_action_window
);
3325 wxASSERT_MSG(pane
.IsOk(), wxT("Pane window not found"));
3327 // save the new positions
3328 wxDockInfoPtrArray docks
;
3329 FindDocks(m_docks
, pane
.dock_direction
,
3330 pane
.dock_layer
, pane
.dock_row
, docks
);
3331 if (docks
.GetCount() == 1)
3333 wxDockInfo
& dock
= *docks
.Item(0);
3335 wxArrayInt pane_positions
, pane_sizes
;
3336 GetPanePositionsAndSizes(dock
, pane_positions
, pane_sizes
);
3338 int i
, dock_pane_count
= dock
.panes
.GetCount();
3339 for (i
= 0; i
< dock_pane_count
; ++i
)
3340 dock
.panes
.Item(i
)->dock_pos
= pane_positions
[i
];
3343 pane
.state
&= ~wxPaneInfo::actionPane
;
3351 m_action
= actionNone
;
3352 m_last_mouse_move
= wxPoint(); // see comment in OnMotion()
3356 void wxFrameManager::OnMotion(wxMouseEvent
& event
)
3358 // sometimes when Update() is called from inside this method,
3359 // a spurious mouse move event is generated; this check will make
3360 // sure that only real mouse moves will get anywhere in this method;
3361 // this appears to be a bug somewhere, and I don't know where the
3362 // mouse move event is being generated. only verified on MSW
3364 wxPoint mouse_pos
= event
.GetPosition();
3365 if (m_last_mouse_move
== mouse_pos
)
3367 m_last_mouse_move
= mouse_pos
;
3370 if (m_action
== actionResize
)
3372 wxPoint pos
= m_action_part
->rect
.GetPosition();
3373 if (m_action_part
->orientation
== wxHORIZONTAL
)
3374 pos
.y
= wxMax(0, event
.m_y
- m_action_offset
.y
);
3376 pos
.x
= wxMax(0, event
.m_x
- m_action_offset
.x
);
3378 wxRect
rect(m_frame
->ClientToScreen(pos
),
3379 m_action_part
->rect
.GetSize());
3382 if (!m_action_hintrect
.IsEmpty())
3383 DrawResizeHint(dc
, m_action_hintrect
);
3384 DrawResizeHint(dc
, rect
);
3385 m_action_hintrect
= rect
;
3387 else if (m_action
== actionClickCaption
)
3389 int drag_x_threshold
= wxSystemSettings::GetMetric(wxSYS_DRAG_X
);
3390 int drag_y_threshold
= wxSystemSettings::GetMetric(wxSYS_DRAG_Y
);
3392 // caption has been clicked. we need to check if the mouse
3393 // is now being dragged. if it is, we need to change the
3394 // mouse action to 'drag'
3395 if (abs(event
.m_x
- m_action_start
.x
) > drag_x_threshold
||
3396 abs(event
.m_y
- m_action_start
.y
) > drag_y_threshold
)
3398 wxPaneInfo
* pane_info
= m_action_part
->pane
;
3400 if (!pane_info
->IsToolbar())
3402 if ((m_flags
& wxAUI_MGR_ALLOW_FLOATING
) &&
3403 pane_info
->IsFloatable())
3405 m_action
= actionDragFloatingPane
;
3407 // set initial float position
3408 wxPoint pt
= m_frame
->ClientToScreen(event
.GetPosition());
3409 pane_info
->floating_pos
= wxPoint(pt
.x
- m_action_offset
.x
,
3410 pt
.y
- m_action_offset
.y
);
3415 m_action_window
= pane_info
->frame
;
3417 // action offset is used here to make it feel "natural" to the user
3418 // to drag a docked pane and suddenly have it become a floating frame.
3419 // Sometimes, however, the offset where the user clicked on the docked
3420 // caption is bigger than the width of the floating frame itself, so
3421 // in that case we need to set the action offset to a sensible value
3422 wxSize frame_size
= m_action_window
->GetSize();
3423 if (frame_size
.x
<= m_action_offset
.x
)
3424 m_action_offset
.x
= 30;
3429 m_action
= actionDragToolbarPane
;
3430 m_action_window
= pane_info
->window
;
3434 else if (m_action
== actionDragFloatingPane
)
3436 wxPoint pt
= m_frame
->ClientToScreen(event
.GetPosition());
3437 m_action_window
->Move(pt
.x
- m_action_offset
.x
,
3438 pt
.y
- m_action_offset
.y
);
3440 else if (m_action
== actionDragToolbarPane
)
3442 wxPaneInfo
& pane
= GetPane(m_action_window
);
3443 wxASSERT_MSG(pane
.IsOk(), wxT("Pane window not found"));
3445 pane
.state
|= wxPaneInfo::actionPane
;
3447 wxPoint pt
= event
.GetPosition();
3448 DoDrop(m_docks
, m_panes
, pane
, pt
, m_action_offset
);
3450 // if DoDrop() decided to float the pane, set up
3451 // the floating pane's initial position
3452 if (pane
.IsFloating())
3454 wxPoint pt
= m_frame
->ClientToScreen(event
.GetPosition());
3455 pane
.floating_pos
= wxPoint(pt
.x
- m_action_offset
.x
,
3456 pt
.y
- m_action_offset
.y
);
3459 // this will do the actiual move operation;
3460 // in the case that the pane has been floated,
3461 // this call will create the floating pane
3462 // and do the reparenting
3465 // if the pane has been floated, change the mouse
3466 // action actionDragFloatingPane so that subsequent
3467 // EVT_MOTION() events will move the floating pane
3468 if (pane
.IsFloating())
3470 pane
.state
&= ~wxPaneInfo::actionPane
;
3471 m_action
= actionDragFloatingPane
;
3472 m_action_window
= pane
.frame
;
3477 wxDockUIPart
* part
= HitTest(event
.GetX(), event
.GetY());
3478 if (part
&& part
->type
== wxDockUIPart::typePaneButton
)
3480 if (part
!= m_hover_button
)
3482 // make the old button normal
3484 UpdateButtonOnScreen(m_hover_button
, event
);
3486 // mouse is over a button, so repaint the
3487 // button in hover mode
3488 UpdateButtonOnScreen(part
, event
);
3489 m_hover_button
= part
;
3496 m_hover_button
= NULL
;
3507 void wxFrameManager::OnLeaveWindow(wxMouseEvent
& WXUNUSED(event
))
3511 m_hover_button
= NULL
;
3516 void wxFrameManager::OnChildFocus(wxChildFocusEvent
& event
)
3518 // when a child pane has it's focus set, we should change the
3519 // pane's active state to reflect this. (this is only true if
3520 // active panes are allowed by the owner)
3521 if (GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE
)
3523 if (GetPane(event
.GetWindow()).IsOk())
3525 SetActivePane(m_panes
, event
.GetWindow());
3534 // OnPaneButton() is an event handler that is called
3535 // when a pane button has been pressed.
3536 void wxFrameManager::OnPaneButton(wxFrameManagerEvent
& evt
)
3538 wxASSERT_MSG(evt
.pane
, wxT("Pane Info passed to wxFrameManager::OnPaneButton must be non-null"));
3540 wxPaneInfo
& pane
= *(evt
.pane
);
3542 if (evt
.button
== wxPaneInfo::buttonClose
)
3544 // fire pane close event
3545 wxFrameManagerEvent
e(wxEVT_AUI_PANECLOSE
);
3546 e
.SetPane(evt
.pane
);
3555 else if (evt
.button
== wxPaneInfo::buttonPin
)
3557 if ((m_flags
& wxAUI_MGR_ALLOW_FLOATING
) &&