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"
34 #include "wx/settings.h"
36 #include "wx/dcclient.h"
37 #include "wx/dcscreen.h"
38 #include "wx/toolbar.h"
43 WX_CHECK_BUILD_OPTIONS("wxAUI")
45 #include "wx/arrimpl.cpp"
46 WX_DECLARE_OBJARRAY(wxRect
, wxAuiRectArray
);
47 WX_DEFINE_OBJARRAY(wxAuiRectArray
)
48 WX_DEFINE_OBJARRAY(wxAuiDockUIPartArray
)
49 WX_DEFINE_OBJARRAY(wxAuiDockInfoArray
)
50 WX_DEFINE_OBJARRAY(wxAuiPaneButtonArray
)
51 WX_DEFINE_OBJARRAY(wxAuiPaneInfoArray
)
53 wxAuiPaneInfo wxAuiNullPaneInfo
;
54 wxAuiDockInfo wxAuiNullDockInfo
;
55 DEFINE_EVENT_TYPE(wxEVT_AUI_PANE_BUTTON
)
56 DEFINE_EVENT_TYPE(wxEVT_AUI_PANE_CLOSE
)
57 DEFINE_EVENT_TYPE(wxEVT_AUI_PANE_MAXIMIZE
)
58 DEFINE_EVENT_TYPE(wxEVT_AUI_PANE_RESTORE
)
59 DEFINE_EVENT_TYPE(wxEVT_AUI_RENDER
)
60 DEFINE_EVENT_TYPE(wxEVT_AUI_FIND_MANAGER
)
63 // a few defines to avoid nameclashes
64 #define __MAC_OS_X_MEMORY_MANAGER_CLEAN__ 1
66 #include "wx/mac/private.h"
69 IMPLEMENT_DYNAMIC_CLASS(wxAuiManagerEvent
, wxEvent
)
70 IMPLEMENT_CLASS(wxAuiManager
, wxEvtHandler
)
74 const int auiToolBarLayer
= 10;
77 class wxPseudoTransparentFrame
: public wxFrame
80 wxPseudoTransparentFrame(wxWindow
* parent
= NULL
,
81 wxWindowID id
= wxID_ANY
,
82 const wxString
& title
= wxEmptyString
,
83 const wxPoint
& pos
= wxDefaultPosition
,
84 const wxSize
& size
= wxDefaultSize
,
85 long style
= wxDEFAULT_FRAME_STYLE
,
86 const wxString
&name
= wxT("frame"))
87 : wxFrame(parent
, id
, title
, pos
, size
, style
| wxFRAME_SHAPED
, name
)
89 SetBackgroundStyle(wxBG_STYLE_CUSTOM
);
96 m_CanSetShape
= false; // have to wait for window create event on GTK
100 m_Region
= wxRegion(0, 0, 0, 0);
104 virtual bool SetTransparent(wxByte alpha
)
108 int w
=100; // some defaults
110 GetClientSize(&w
, &h
);
116 // m_Region.Union(0, 0, 1, m_MaxWidth);
119 for (int y
=0; y
<m_MaxHeight
; y
++)
121 // Reverse the order of the bottom 4 bits
122 int j
=((y
&8)?
1:0)|((y
&4)?
2:0)|((y
&2)?
4:0)|((y
&1)?
8:0);
123 if ((j
*16+8)<m_Amount
)
124 m_Region
.Union(0, y
, m_MaxWidth
, 1);
133 void OnPaint(wxPaintEvent
& WXUNUSED(event
))
137 if (m_Region
.IsEmpty())
141 dc
.SetBrush(wxColour(128, 192, 255));
143 dc
.SetBrush(wxSystemSettings
::GetColour(wxSYS_COLOUR_ACTIVECAPTION
));
145 dc
.SetPen(*wxTRANSPARENT_PEN
);
147 wxRegionIterator
upd(GetUpdateRegion()); // get the update rect list
151 wxRect
rect(upd
.GetRect());
152 dc
.DrawRectangle(rect
.x
, rect
.y
, rect
.width
, rect
.height
);
159 void OnWindowCreate(wxWindowCreateEvent
& WXUNUSED(event
))
166 void OnSize(wxSizeEvent
& event
)
168 // We sometimes get surplus size events
169 if ((event
.GetSize().GetWidth() == m_lastWidth
) &&
170 (event
.GetSize().GetHeight() == m_lastHeight
))
175 m_lastWidth
= event
.GetSize().GetWidth();
176 m_lastHeight
= event
.GetSize().GetHeight();
178 SetTransparent(m_Amount
);
179 m_Region
.Intersect(0, 0, event
.GetSize().GetWidth(),
180 event
.GetSize().GetHeight());
191 int m_lastWidth
,m_lastHeight
;
195 DECLARE_DYNAMIC_CLASS(wxPseudoTransparentFrame
)
196 DECLARE_EVENT_TABLE()
200 IMPLEMENT_DYNAMIC_CLASS(wxPseudoTransparentFrame
, wxFrame
)
202 BEGIN_EVENT_TABLE(wxPseudoTransparentFrame
, wxFrame
)
203 EVT_PAINT(wxPseudoTransparentFrame
::OnPaint
)
204 EVT_SIZE(wxPseudoTransparentFrame
::OnSize
)
206 EVT_WINDOW_CREATE(wxPseudoTransparentFrame
::OnWindowCreate
)
211 // -- static utility functions --
213 static wxBitmap
wxPaneCreateStippleBitmap()
215 unsigned char data
[] = { 0,0,0,192,192,192, 192,192,192,0,0,0 };
216 wxImage
img(2,2,data
,true);
217 return wxBitmap(img
);
220 static void DrawResizeHint(wxDC
& dc
, const wxRect
& rect
)
222 wxBitmap stipple
= wxPaneCreateStippleBitmap();
223 wxBrush
brush(stipple
);
225 dc
.SetPen(*wxTRANSPARENT_PEN
);
227 dc
.SetLogicalFunction(wxXOR
);
228 dc
.DrawRectangle(rect
);
233 // CopyDocksAndPanes() - this utility function creates copies of
234 // the dock and pane info. wxAuiDockInfo's usually contain pointers
235 // to wxAuiPaneInfo classes, thus this function is necessary to reliably
236 // reconstruct that relationship in the new dock info and pane info arrays
238 static void CopyDocksAndPanes(wxAuiDockInfoArray
& dest_docks
,
239 wxAuiPaneInfoArray
& dest_panes
,
240 const wxAuiDockInfoArray
& src_docks
,
241 const wxAuiPaneInfoArray
& src_panes
)
243 dest_docks
= src_docks
;
244 dest_panes
= src_panes
;
245 int i
, j
, k
, dock_count
, pc1
, pc2
;
246 for (i
= 0, dock_count
= dest_docks
.GetCount(); i
< dock_count
; ++i
)
248 wxAuiDockInfo
& dock
= dest_docks
.Item(i
);
249 for (j
= 0, pc1
= dock
.panes
.GetCount(); j
< pc1
; ++j
)
250 for (k
= 0, pc2
= src_panes
.GetCount(); k
< pc2
; ++k
)
251 if (dock
.panes
.Item(j
) == &src_panes
.Item(k
))
252 dock
.panes
.Item(j
) = &dest_panes
.Item(k
);
256 // GetMaxLayer() is an internal function which returns
257 // the highest layer inside the specified dock
258 static int GetMaxLayer(const wxAuiDockInfoArray
& docks
,
261 int i
, dock_count
, max_layer
= 0;
262 for (i
= 0, dock_count
= docks
.GetCount(); i
< dock_count
; ++i
)
264 wxAuiDockInfo
& dock
= docks
.Item(i
);
265 if (dock
.dock_direction
== dock_direction
&&
266 dock
.dock_layer
> max_layer
&& !dock
.fixed
)
267 max_layer
= dock
.dock_layer
;
273 // GetMaxRow() is an internal function which returns
274 // the highest layer inside the specified dock
275 static int GetMaxRow(const wxAuiPaneInfoArray
& panes
, int direction
, int layer
)
277 int i
, pane_count
, max_row
= 0;
278 for (i
= 0, pane_count
= panes
.GetCount(); i
< pane_count
; ++i
)
280 wxAuiPaneInfo
& pane
= panes
.Item(i
);
281 if (pane
.dock_direction
== direction
&&
282 pane
.dock_layer
== layer
&&
283 pane
.dock_row
> max_row
)
284 max_row
= pane
.dock_row
;
291 // DoInsertDockLayer() is an internal function that inserts a new dock
292 // layer by incrementing all existing dock layer values by one
293 static void DoInsertDockLayer(wxAuiPaneInfoArray
& panes
,
298 for (i
= 0, pane_count
= panes
.GetCount(); i
< pane_count
; ++i
)
300 wxAuiPaneInfo
& pane
= panes
.Item(i
);
301 if (!pane
.IsFloating() &&
302 pane
.dock_direction
== dock_direction
&&
303 pane
.dock_layer
>= dock_layer
)
308 // DoInsertDockLayer() is an internal function that inserts a new dock
309 // row by incrementing all existing dock row values by one
310 static void DoInsertDockRow(wxAuiPaneInfoArray
& panes
,
316 for (i
= 0, pane_count
= panes
.GetCount(); i
< pane_count
; ++i
)
318 wxAuiPaneInfo
& pane
= panes
.Item(i
);
319 if (!pane
.IsFloating() &&
320 pane
.dock_direction
== dock_direction
&&
321 pane
.dock_layer
== dock_layer
&&
322 pane
.dock_row
>= dock_row
)
327 // DoInsertDockLayer() is an internal function that inserts a space for
328 // another dock pane by incrementing all existing dock row values by one
329 static void DoInsertPane(wxAuiPaneInfoArray
& panes
,
336 for (i
= 0, pane_count
= panes
.GetCount(); i
< pane_count
; ++i
)
338 wxAuiPaneInfo
& pane
= panes
.Item(i
);
339 if (!pane
.IsFloating() &&
340 pane
.dock_direction
== dock_direction
&&
341 pane
.dock_layer
== dock_layer
&&
342 pane
.dock_row
== dock_row
&&
343 pane
.dock_pos
>= dock_pos
)
348 // FindDocks() is an internal function that returns a list of docks which meet
349 // the specified conditions in the parameters and returns a sorted array
350 // (sorted by layer and then row)
351 static void FindDocks(wxAuiDockInfoArray
& docks
,
355 wxAuiDockInfoPtrArray
& arr
)
357 int begin_layer
= dock_layer
;
358 int end_layer
= dock_layer
;
359 int begin_row
= dock_row
;
360 int end_row
= dock_row
;
361 int dock_count
= docks
.GetCount();
362 int layer
, row
, i
, max_row
= 0, max_layer
= 0;
364 // discover the maximum dock layer and the max row
365 for (i
= 0; i
< dock_count
; ++i
)
367 max_row
= wxMax(max_row
, docks
.Item(i
).dock_row
);
368 max_layer
= wxMax(max_layer
, docks
.Item(i
).dock_layer
);
371 // if no dock layer was specified, search all dock layers
372 if (dock_layer
== -1)
375 end_layer
= max_layer
;
378 // if no dock row was specified, search all dock row
387 for (layer
= begin_layer
; layer
<= end_layer
; ++layer
)
388 for (row
= begin_row
; row
<= end_row
; ++row
)
389 for (i
= 0; i
< dock_count
; ++i
)
391 wxAuiDockInfo
& d
= docks
.Item(i
);
392 if (dock_direction
== -1 || dock_direction
== d
.dock_direction
)
394 if (d
.dock_layer
== layer
&& d
.dock_row
== row
)
400 // FindPaneInDock() looks up a specified window pointer inside a dock.
401 // If found, the corresponding wxAuiPaneInfo pointer is returned, otherwise NULL.
402 static wxAuiPaneInfo
* FindPaneInDock(const wxAuiDockInfo
& dock
, wxWindow
* window
)
404 int i
, count
= dock
.panes
.GetCount();
405 for (i
= 0; i
< count
; ++i
)
407 wxAuiPaneInfo
* p
= dock
.panes
.Item(i
);
408 if (p
->window
== window
)
414 // RemovePaneFromDocks() removes a pane window from all docks
415 // with a possible exception specified by parameter "ex_cept"
416 static void RemovePaneFromDocks(wxAuiDockInfoArray
& docks
,
418 wxAuiDockInfo
* ex_cept
= NULL
)
421 for (i
= 0, dock_count
= docks
.GetCount(); i
< dock_count
; ++i
)
423 wxAuiDockInfo
& d
= docks
.Item(i
);
426 wxAuiPaneInfo
* pi
= FindPaneInDock(d
, pane
.window
);
432 // RenumberDockRows() takes a dock and assigns sequential numbers
433 // to existing rows. Basically it takes out the gaps; so if a
434 // dock has rows with numbers 0,2,5, they will become 0,1,2
435 static void RenumberDockRows(wxAuiDockInfoPtrArray
& docks
)
437 int i
, dock_count
, j
, pane_count
;
438 for (i
= 0, dock_count
= docks
.GetCount(); i
< dock_count
; ++i
)
440 wxAuiDockInfo
& dock
= *docks
.Item(i
);
442 for (j
= 0, pane_count
= dock
.panes
.GetCount(); j
< pane_count
; ++j
)
443 dock
.panes
.Item(j
)->dock_row
= i
;
448 // SetActivePane() sets the active pane, as well as cycles through
449 // every other pane and makes sure that all others' active flags
451 static void SetActivePane(wxAuiPaneInfoArray
& panes
, wxWindow
* active_pane
)
454 for (i
= 0, pane_count
= panes
.GetCount(); i
< pane_count
; ++i
)
456 wxAuiPaneInfo
& pane
= panes
.Item(i
);
457 pane
.state
&= ~wxAuiPaneInfo
::optionActive
;
458 if (pane
.window
== active_pane
)
459 pane
.state
|= wxAuiPaneInfo
::optionActive
;
464 // this function is used to sort panes by dock position
465 static int PaneSortFunc(wxAuiPaneInfo
** p1
, wxAuiPaneInfo
** p2
)
467 return ((*p1
)->dock_pos
< (*p2
)->dock_pos
) ?
-1 : 1;
471 // -- wxAuiManager class implementation --
474 BEGIN_EVENT_TABLE(wxAuiManager
, wxEvtHandler
)
475 EVT_AUI_PANE_BUTTON(wxAuiManager
::OnPaneButton
)
476 EVT_AUI_RENDER(wxAuiManager
::OnRender
)
477 EVT_PAINT(wxAuiManager
::OnPaint
)
478 EVT_ERASE_BACKGROUND(wxAuiManager
::OnEraseBackground
)
479 EVT_SIZE(wxAuiManager
::OnSize
)
480 EVT_SET_CURSOR(wxAuiManager
::OnSetCursor
)
481 EVT_LEFT_DOWN(wxAuiManager
::OnLeftDown
)
482 EVT_LEFT_UP(wxAuiManager
::OnLeftUp
)
483 EVT_MOTION(wxAuiManager
::OnMotion
)
484 EVT_LEAVE_WINDOW(wxAuiManager
::OnLeaveWindow
)
485 EVT_CHILD_FOCUS(wxAuiManager
::OnChildFocus
)
486 EVT_AUI_FIND_MANAGER(wxAuiManager
::OnFindManager
)
487 EVT_TIMER(101, wxAuiManager
::OnHintFadeTimer
)
491 wxAuiManager
::wxAuiManager(wxWindow
* managed_wnd
, unsigned int flags
)
493 m_action
= actionNone
;
494 m_last_mouse_move
= wxPoint();
495 m_hover_button
= NULL
;
496 m_art
= new wxAuiDefaultDockArt
;
500 m_has_maximized
= false;
502 m_dock_constraint_x
= 0.3;
503 m_dock_constraint_y
= 0.3;
507 SetManagedWindow(managed_wnd
);
511 wxAuiManager
::~wxAuiManager()
516 // creates a floating frame for the windows
517 wxAuiFloatingFrame
* wxAuiManager
::CreateFloatingFrame(wxWindow
* parent
,
518 const wxAuiPaneInfo
& pane_info
)
520 return new wxAuiFloatingFrame(parent
, this, pane_info
);
523 // GetPane() looks up a wxAuiPaneInfo structure based
524 // on the supplied window pointer. Upon failure, GetPane()
525 // returns an empty wxAuiPaneInfo, a condition which can be checked
526 // by calling wxAuiPaneInfo::IsOk().
528 // The pane info's structure may then be modified. Once a pane's
529 // info is modified, wxAuiManager::Update() must be called to
530 // realize the changes in the UI.
532 wxAuiPaneInfo
& wxAuiManager
::GetPane(wxWindow
* window
)
535 for (i
= 0, pane_count
= m_panes
.GetCount(); i
< pane_count
; ++i
)
537 wxAuiPaneInfo
& p
= m_panes
.Item(i
);
538 if (p
.window
== window
)
541 return wxAuiNullPaneInfo
;
544 // this version of GetPane() looks up a pane based on a
545 // 'pane name', see above comment for more info
546 wxAuiPaneInfo
& wxAuiManager
::GetPane(const wxString
& name
)
549 for (i
= 0, pane_count
= m_panes
.GetCount(); i
< pane_count
; ++i
)
551 wxAuiPaneInfo
& p
= m_panes
.Item(i
);
555 return wxAuiNullPaneInfo
;
558 // GetAllPanes() returns a reference to all the pane info structures
559 wxAuiPaneInfoArray
& wxAuiManager
::GetAllPanes()
564 // HitTest() is an internal function which determines
565 // which UI item the specified coordinates are over
566 // (x,y) specify a position in client coordinates
567 wxAuiDockUIPart
* wxAuiManager
::HitTest(int x
, int y
)
569 wxAuiDockUIPart
* result
= NULL
;
572 for (i
= 0, part_count
= m_uiparts
.GetCount(); i
< part_count
; ++i
)
574 wxAuiDockUIPart
* item
= &m_uiparts
.Item(i
);
576 // we are not interested in typeDock, because this space
577 // isn't used to draw anything, just for measurements;
578 // besides, the entire dock area is covered with other
579 // rectangles, which we are interested in.
580 if (item
->type
== wxAuiDockUIPart
::typeDock
)
583 // if we already have a hit on a more specific item, we are not
584 // interested in a pane hit. If, however, we don't already have
585 // a hit, returning a pane hit is necessary for some operations
586 if ((item
->type
== wxAuiDockUIPart
::typePane
||
587 item
->type
== wxAuiDockUIPart
::typePaneBorder
) && result
)
590 // if the point is inside the rectangle, we have a hit
591 if (item
->rect
.Contains(x
,y
))
599 // SetFlags() and GetFlags() allow the owner to set various
600 // options which are global to wxAuiManager
601 void wxAuiManager
::SetFlags(unsigned int flags
)
603 // find out if we have to call UpdateHintWindowConfig()
604 bool update_hint_wnd
= false;
605 unsigned int hint_mask
= wxAUI_MGR_TRANSPARENT_HINT
|
606 wxAUI_MGR_VENETIAN_BLINDS_HINT
|
607 wxAUI_MGR_RECTANGLE_HINT
;
608 if ((flags
& hint_mask
) != (m_flags
& hint_mask
))
609 update_hint_wnd
= true;
617 UpdateHintWindowConfig();
621 unsigned int wxAuiManager
::GetFlags() const
627 // don't use these anymore as they are deprecated
628 // use Set/GetManagedFrame() instead
629 void wxAuiManager
::SetFrame(wxFrame
* frame
)
631 SetManagedWindow((wxWindow
*)frame
);
634 wxFrame
* wxAuiManager
::GetFrame() const
636 return (wxFrame
*)m_frame
;
640 // this function will return the aui manager for a given
641 // window. The |window| parameter should be any child window
642 // or grand-child window (and so on) of the frame/window
643 // managed by wxAuiManager. The |window| parameter does not
644 // need to be managed by the manager itself.
645 wxAuiManager
* wxAuiManager
::GetManager(wxWindow
* window
)
647 wxAuiManagerEvent
evt(wxEVT_AUI_FIND_MANAGER
);
648 evt
.SetManager(NULL
);
649 evt
.ResumePropagation(wxEVENT_PROPAGATE_MAX
);
650 if (!window
->ProcessEvent(evt
))
653 return evt
.GetManager();
657 void wxAuiManager
::UpdateHintWindowConfig()
659 // find out if the the system can do transparent frames
660 bool can_do_transparent
= false;
662 wxWindow
* w
= m_frame
;
665 if (w
->IsKindOf(CLASSINFO(wxFrame
)))
667 wxFrame
* f
= static_cast<wxFrame
*>(w
);
668 can_do_transparent
= f
->CanSetTransparent();
675 // if there is an existing hint window, delete it
678 m_hint_wnd
->Destroy();
685 if ((m_flags
& wxAUI_MGR_TRANSPARENT_HINT
) && can_do_transparent
)
687 // Make a window to use for a transparent hint
688 #if defined(__WXMSW__) || defined(__WXGTK__)
689 m_hint_wnd
= new wxFrame(m_frame
, wxID_ANY
, wxEmptyString
,
690 wxDefaultPosition
, wxSize(1,1),
691 wxFRAME_TOOL_WINDOW
|
692 wxFRAME_FLOAT_ON_PARENT
|
696 m_hint_wnd
->SetBackgroundColour(wxSystemSettings
::GetColour(wxSYS_COLOUR_ACTIVECAPTION
));
697 #elif defined(__WXMAC__)
698 // Using a miniframe with float and tool styles keeps the parent
699 // frame activated and highlighted as such...
700 m_hint_wnd
= new wxMiniFrame(m_frame
, wxID_ANY
, wxEmptyString
,
701 wxDefaultPosition
, wxSize(1,1),
702 wxFRAME_FLOAT_ON_PARENT
703 | wxFRAME_TOOL_WINDOW
);
705 // Can't set the bg colour of a Frame in wxMac
706 wxPanel
* p
= new wxPanel(m_hint_wnd
);
708 // The default wxSYS_COLOUR_ACTIVECAPTION colour is a light silver
709 // color that is really hard to see, especially transparent.
710 // Until a better system color is decided upon we'll just use
712 p
->SetBackgroundColour(*wxBLUE
);
718 if ((m_flags
& wxAUI_MGR_TRANSPARENT_HINT
) != 0 ||
719 (m_flags
& wxAUI_MGR_VENETIAN_BLINDS_HINT
) != 0)
721 // system can't support transparent fade, or the venetian
722 // blinds effect was explicitly requested
723 m_hint_wnd
= new wxPseudoTransparentFrame(m_frame
,
728 wxFRAME_TOOL_WINDOW
|
729 wxFRAME_FLOAT_ON_PARENT
|
732 m_hint_fademax
= 128;
738 // SetManagedWindow() is usually called once when the frame
739 // manager class is being initialized. "frame" specifies
740 // the frame which should be managed by the frame mananger
741 void wxAuiManager
::SetManagedWindow(wxWindow
* wnd
)
743 wxASSERT_MSG(wnd
, wxT("specified window must be non-NULL"));
746 m_frame
->PushEventHandler(this);
749 // if the owner is going to manage an MDI parent frame,
750 // we need to add the MDI client window as the default
753 if (m_frame
->IsKindOf(CLASSINFO(wxMDIParentFrame
)))
755 wxMDIParentFrame
* mdi_frame
= (wxMDIParentFrame
*)m_frame
;
756 wxWindow
* client_window
= mdi_frame
->GetClientWindow();
758 wxASSERT_MSG(client_window
, wxT("Client window is NULL!"));
760 AddPane(client_window
,
761 wxAuiPaneInfo().Name(wxT("mdiclient")).
762 CenterPane().PaneBorder(false));
766 UpdateHintWindowConfig();
770 // UnInit() must be called, usually in the destructor
771 // of the frame class. If it is not called, usually this
772 // will result in a crash upon program exit
773 void wxAuiManager
::UnInit()
777 m_frame
->RemoveEventHandler(this);
781 // GetManagedWindow() returns the window pointer being managed
782 wxWindow
* wxAuiManager
::GetManagedWindow() const
787 wxAuiDockArt
* wxAuiManager
::GetArtProvider() const
792 void wxAuiManager
::ProcessMgrEvent(wxAuiManagerEvent
& event
)
794 // first, give the owner frame a chance to override
797 if (m_frame
->ProcessEvent(event
))
804 // SetArtProvider() instructs wxAuiManager to use the
805 // specified art provider for all drawing calls. This allows
806 // plugable look-and-feel features. The pointer that is
807 // passed to this method subsequently belongs to wxAuiManager,
808 // and is deleted in the frame manager destructor
809 void wxAuiManager
::SetArtProvider(wxAuiDockArt
* art_provider
)
811 // delete the last art provider, if any
814 // assign the new art provider
815 m_art
= art_provider
;
819 bool wxAuiManager
::AddPane(wxWindow
* window
, const wxAuiPaneInfo
& pane_info
)
821 // check if the pane has a valid window
825 // check if the window is already managed by us
826 if (GetPane(pane_info
.window
).IsOk())
829 // check if the pane name already exists, this could reveal a
830 // bug in the library user's application
831 bool already_exists
= false;
832 if (!pane_info
.name
.empty() && GetPane(pane_info
.name
).IsOk())
834 wxFAIL_MSG(wxT("A pane with that name already exists in the manager!"));
835 already_exists
= true;
838 // if the new pane is docked then we should undo maximize
839 if (pane_info
.IsDocked())
840 RestoreMaximizedPane();
842 m_panes
.Add(pane_info
);
844 wxAuiPaneInfo
& pinfo
= m_panes
.Last();
846 // set the pane window
847 pinfo
.window
= window
;
850 // if the pane's name identifier is blank, create a random string
851 if (pinfo
.name
.empty() || already_exists
)
853 pinfo
.name
.Printf(wxT("%08lx%08x%08x%08lx"),
854 ((unsigned long)pinfo
.window
) & 0xffffffff,
855 (unsigned int)time(NULL
),
857 (unsigned int)GetTickCount(),
859 (unsigned int)clock(),
861 (unsigned long)m_panes
.GetCount());
864 // set initial proportion (if not already set)
865 if (pinfo
.dock_proportion
== 0)
866 pinfo
.dock_proportion
= 100000;
868 if (pinfo
.HasMaximizeButton())
870 wxAuiPaneButton button
;
871 button
.button_id
= wxAUI_BUTTON_MAXIMIZE_RESTORE
;
872 pinfo
.buttons
.Add(button
);
875 if (pinfo
.HasPinButton())
877 wxAuiPaneButton button
;
878 button
.button_id
= wxAUI_BUTTON_PIN
;
879 pinfo
.buttons
.Add(button
);
882 if (pinfo
.HasCloseButton())
884 wxAuiPaneButton button
;
885 button
.button_id
= wxAUI_BUTTON_CLOSE
;
886 pinfo
.buttons
.Add(button
);
889 if (pinfo
.best_size
== wxDefaultSize
&&
892 pinfo
.best_size
= pinfo
.window
->GetClientSize();
894 if (pinfo
.window
->IsKindOf(CLASSINFO(wxToolBar
)))
896 // GetClientSize() doesn't get the best size for
897 // a toolbar under some newer versions of wxWidgets,
898 // so use GetBestSize()
899 pinfo
.best_size
= pinfo
.window
->GetBestSize();
901 // for some reason, wxToolBar::GetBestSize() is returning
902 // a size that is a pixel shy of the correct amount.
903 // I believe this to be the correct action, until
904 // wxToolBar::GetBestSize() is fixed. Is this assumption
909 if (pinfo
.min_size
!= wxDefaultSize
)
911 if (pinfo
.best_size
.x
< pinfo
.min_size
.x
)
912 pinfo
.best_size
.x
= pinfo
.min_size
.x
;
913 if (pinfo
.best_size
.y
< pinfo
.min_size
.y
)
914 pinfo
.best_size
.y
= pinfo
.min_size
.y
;
921 bool wxAuiManager
::AddPane(wxWindow
* window
,
923 const wxString
& caption
)
926 pinfo
.Caption(caption
);
929 case wxTOP
: pinfo
.Top(); break;
930 case wxBOTTOM
: pinfo
.Bottom(); break;
931 case wxLEFT
: pinfo
.Left(); break;
932 case wxRIGHT
: pinfo
.Right(); break;
933 case wxCENTER
: pinfo
.CenterPane(); break;
935 return AddPane(window
, pinfo
);
938 bool wxAuiManager
::AddPane(wxWindow
* window
,
939 const wxAuiPaneInfo
& pane_info
,
940 const wxPoint
& drop_pos
)
942 if (!AddPane(window
, pane_info
))
945 wxAuiPaneInfo
& pane
= GetPane(window
);
947 DoDrop(m_docks
, m_panes
, pane
, drop_pos
, wxPoint(0,0));
952 bool wxAuiManager
::InsertPane(wxWindow
* window
, const wxAuiPaneInfo
& pane_info
,
955 // shift the panes around, depending on the insert level
956 switch (insert_level
)
958 case wxAUI_INSERT_PANE
:
959 DoInsertPane(m_panes
,
960 pane_info
.dock_direction
,
961 pane_info
.dock_layer
,
965 case wxAUI_INSERT_ROW
:
966 DoInsertDockRow(m_panes
,
967 pane_info
.dock_direction
,
968 pane_info
.dock_layer
,
971 case wxAUI_INSERT_DOCK
:
972 DoInsertDockLayer(m_panes
,
973 pane_info
.dock_direction
,
974 pane_info
.dock_layer
);
978 // if the window already exists, we are basically just moving/inserting the
979 // existing window. If it doesn't exist, we need to add it and insert it
980 wxAuiPaneInfo
& existing_pane
= GetPane(window
);
981 if (!existing_pane
.IsOk())
983 return AddPane(window
, pane_info
);
987 if (pane_info
.IsFloating())
989 existing_pane
.Float();
990 if (pane_info
.floating_pos
!= wxDefaultPosition
)
991 existing_pane
.FloatingPosition(pane_info
.floating_pos
);
992 if (pane_info
.floating_size
!= wxDefaultSize
)
993 existing_pane
.FloatingSize(pane_info
.floating_size
);
997 // if the new pane is docked then we should undo maximize
998 RestoreMaximizedPane();
1000 existing_pane
.Direction(pane_info
.dock_direction
);
1001 existing_pane
.Layer(pane_info
.dock_layer
);
1002 existing_pane
.Row(pane_info
.dock_row
);
1003 existing_pane
.Position(pane_info
.dock_pos
);
1011 // DetachPane() removes a pane from the frame manager. This
1012 // method will not destroy the window that is removed.
1013 bool wxAuiManager
::DetachPane(wxWindow
* window
)
1016 for (i
= 0, count
= m_panes
.GetCount(); i
< count
; ++i
)
1018 wxAuiPaneInfo
& p
= m_panes
.Item(i
);
1019 if (p
.window
== window
)
1023 // we have a floating frame which is being detached. We need to
1024 // reparent it to m_frame and destroy the floating frame
1027 p
.window
->SetSize(1,1);
1029 if (p
.frame
->IsShown())
1030 p
.frame
->Show(false);
1032 // reparent to m_frame and destroy the pane
1033 if (m_action_window
== p
.frame
)
1035 m_action_window
= NULL
;
1038 p
.window
->Reparent(m_frame
);
1039 p
.frame
->SetSizer(NULL
);
1044 // make sure there are no references to this pane in our uiparts,
1045 // just in case the caller doesn't call Update() immediately after
1046 // the DetachPane() call. This prevets obscure crashes which would
1047 // happen at window repaint if the caller forgets to call Update()
1049 for (pi
= 0, part_count
= (int)m_uiparts
.GetCount(); pi
< part_count
; ++pi
)
1051 wxAuiDockUIPart
& part
= m_uiparts
.Item(pi
);
1052 if (part
.pane
== &p
)
1054 m_uiparts
.RemoveAt(pi
);
1061 m_panes
.RemoveAt(i
);
1068 // ClosePane() destroys or hides the pane depending on its
1070 void wxAuiManager
::ClosePane(wxAuiPaneInfo
& pane_info
)
1072 // if we were maximized, restore
1073 if (pane_info
.IsMaximized())
1075 RestorePane(pane_info
);
1078 // first, hide the window
1079 if (pane_info
.window
&& pane_info
.window
->IsShown())
1081 pane_info
.window
->Show(false);
1084 // make sure that we are the parent of this window
1085 if (pane_info
.window
&& pane_info
.window
->GetParent() != m_frame
)
1087 pane_info
.window
->Reparent(m_frame
);
1090 // if we have a frame, destroy it
1091 if (pane_info
.frame
)
1093 pane_info
.frame
->Destroy();
1094 pane_info
.frame
= NULL
;
1097 // now we need to either destroy or hide the pane
1098 if (pane_info
.IsDestroyOnClose())
1100 wxWindow
* window
= pane_info
.window
;
1113 void wxAuiManager
::MaximizePane(wxAuiPaneInfo
& pane_info
)
1117 // un-maximize and hide all other panes
1118 for (i
= 0, pane_count
= m_panes
.GetCount(); i
< pane_count
; ++i
)
1120 wxAuiPaneInfo
& p
= m_panes
.Item(i
);
1125 // save hidden state
1126 p
.SetFlag(wxAuiPaneInfo
::savedHiddenState
, p
.HasFlag(wxAuiPaneInfo
::optionHidden
));
1128 // hide the pane, because only the newly
1129 // maximized pane should show
1134 // mark ourselves maximized
1135 pane_info
.Maximize();
1137 m_has_maximized
= true;
1139 // last, show the window
1140 if (pane_info
.window
&& !pane_info
.window
->IsShown())
1142 pane_info
.window
->Show(true);
1146 void wxAuiManager
::RestorePane(wxAuiPaneInfo
& pane_info
)
1150 // restore all the panes
1151 for (i
= 0, pane_count
= m_panes
.GetCount(); i
< pane_count
; ++i
)
1153 wxAuiPaneInfo
& p
= m_panes
.Item(i
);
1156 p
.SetFlag(wxAuiPaneInfo
::optionHidden
, p
.HasFlag(wxAuiPaneInfo
::savedHiddenState
));
1160 // mark ourselves non-maximized
1161 pane_info
.Restore();
1162 m_has_maximized
= false;
1164 // last, show the window
1165 if (pane_info
.window
&& !pane_info
.window
->IsShown())
1167 pane_info
.window
->Show(true);
1171 void wxAuiManager
::RestoreMaximizedPane()
1175 // restore all the panes
1176 for (i
= 0, pane_count
= m_panes
.GetCount(); i
< pane_count
; ++i
)
1178 wxAuiPaneInfo
& p
= m_panes
.Item(i
);
1179 if (p
.IsMaximized())
1187 // EscapeDelimiters() changes ";" into "\;" and "|" into "\|"
1188 // in the input string. This is an internal functions which is
1189 // used for saving perspectives
1190 static wxString
EscapeDelimiters(const wxString
& s
)
1193 result
.Alloc(s
.length());
1194 const wxChar
* ch
= s
.c_str();
1197 if (*ch
== wxT(';') || *ch
== wxT('|'))
1198 result
+= wxT('\\');
1205 wxString wxAuiManager
::SavePaneInfo(wxAuiPaneInfo
& pane
)
1207 wxString result
= wxT("name=");
1208 result
+= EscapeDelimiters(pane
.name
);
1211 result
+= wxT("caption=");
1212 result
+= EscapeDelimiters(pane
.caption
);
1215 result
+= wxString
::Format(wxT("state=%u;"), pane
.state
);
1216 result
+= wxString
::Format(wxT("dir=%d;"), pane
.dock_direction
);
1217 result
+= wxString
::Format(wxT("layer=%d;"), pane
.dock_layer
);
1218 result
+= wxString
::Format(wxT("row=%d;"), pane
.dock_row
);
1219 result
+= wxString
::Format(wxT("pos=%d;"), pane
.dock_pos
);
1220 result
+= wxString
::Format(wxT("prop=%d;"), pane
.dock_proportion
);
1221 result
+= wxString
::Format(wxT("bestw=%d;"), pane
.best_size
.x
);
1222 result
+= wxString
::Format(wxT("besth=%d;"), pane
.best_size
.y
);
1223 result
+= wxString
::Format(wxT("minw=%d;"), pane
.min_size
.x
);
1224 result
+= wxString
::Format(wxT("minh=%d;"), pane
.min_size
.y
);
1225 result
+= wxString
::Format(wxT("maxw=%d;"), pane
.max_size
.x
);
1226 result
+= wxString
::Format(wxT("maxh=%d;"), pane
.max_size
.y
);
1227 result
+= wxString
::Format(wxT("floatx=%d;"), pane
.floating_pos
.x
);
1228 result
+= wxString
::Format(wxT("floaty=%d;"), pane
.floating_pos
.y
);
1229 result
+= wxString
::Format(wxT("floatw=%d;"), pane
.floating_size
.x
);
1230 result
+= wxString
::Format(wxT("floath=%d"), pane
.floating_size
.y
);
1235 // Load a "pane" with the pane infor settings in pane_part
1236 void wxAuiManager
::LoadPaneInfo(wxString pane_part
, wxAuiPaneInfo
&pane
)
1238 // replace escaped characters so we can
1239 // split up the string easily
1240 pane_part
.Replace(wxT("\\|"), wxT("\a"));
1241 pane_part
.Replace(wxT("\\;"), wxT("\b"));
1245 wxString val_part
= pane_part
.BeforeFirst(wxT(';'));
1246 pane_part
= pane_part
.AfterFirst(wxT(';'));
1247 wxString val_name
= val_part
.BeforeFirst(wxT('='));
1248 wxString value
= val_part
.AfterFirst(wxT('='));
1249 val_name
.MakeLower();
1250 val_name
.Trim(true);
1251 val_name
.Trim(false);
1255 if (val_name
.empty())
1258 if (val_name
== wxT("name"))
1260 else if (val_name
== wxT("caption"))
1261 pane
.caption
= value
;
1262 else if (val_name
== wxT("state"))
1263 pane
.state
= (unsigned int)wxAtoi(value
.c_str());
1264 else if (val_name
== wxT("dir"))
1265 pane
.dock_direction
= wxAtoi(value
.c_str());
1266 else if (val_name
== wxT("layer"))
1267 pane
.dock_layer
= wxAtoi(value
.c_str());
1268 else if (val_name
== wxT("row"))
1269 pane
.dock_row
= wxAtoi(value
.c_str());
1270 else if (val_name
== wxT("pos"))
1271 pane
.dock_pos
= wxAtoi(value
.c_str());
1272 else if (val_name
== wxT("prop"))
1273 pane
.dock_proportion
= wxAtoi(value
.c_str());
1274 else if (val_name
== wxT("bestw"))
1275 pane
.best_size
.x
= wxAtoi(value
.c_str());
1276 else if (val_name
== wxT("besth"))
1277 pane
.best_size
.y
= wxAtoi(value
.c_str());
1278 else if (val_name
== wxT("minw"))
1279 pane
.min_size
.x
= wxAtoi(value
.c_str());
1280 else if (val_name
== wxT("minh"))
1281 pane
.min_size
.y
= wxAtoi(value
.c_str());
1282 else if (val_name
== wxT("maxw"))
1283 pane
.max_size
.x
= wxAtoi(value
.c_str());
1284 else if (val_name
== wxT("maxh"))
1285 pane
.max_size
.y
= wxAtoi(value
.c_str());
1286 else if (val_name
== wxT("floatx"))
1287 pane
.floating_pos
.x
= wxAtoi(value
.c_str());
1288 else if (val_name
== wxT("floaty"))
1289 pane
.floating_pos
.y
= wxAtoi(value
.c_str());
1290 else if (val_name
== wxT("floatw"))
1291 pane
.floating_size
.x
= wxAtoi(value
.c_str());
1292 else if (val_name
== wxT("floath"))
1293 pane
.floating_size
.y
= wxAtoi(value
.c_str());
1295 wxFAIL_MSG(wxT("Bad Perspective String"));
1299 // replace escaped characters so we can
1300 // split up the string easily
1301 pane
.name
.Replace(wxT("\a"), wxT("|"));
1302 pane
.name
.Replace(wxT("\b"), wxT(";"));
1303 pane
.caption
.Replace(wxT("\a"), wxT("|"));
1304 pane
.caption
.Replace(wxT("\b"), wxT(";"));
1305 pane_part
.Replace(wxT("\a"), wxT("|"));
1306 pane_part
.Replace(wxT("\b"), wxT(";"));
1312 // SavePerspective() saves all pane information as a single string.
1313 // This string may later be fed into LoadPerspective() to restore
1314 // all pane settings. This save and load mechanism allows an
1315 // exact pane configuration to be saved and restored at a later time
1317 wxString wxAuiManager
::SavePerspective()
1321 result
= wxT("layout1|");
1323 int pane_i
, pane_count
= m_panes
.GetCount();
1324 for (pane_i
= 0; pane_i
< pane_count
; ++pane_i
)
1326 wxAuiPaneInfo
& pane
= m_panes
.Item(pane_i
);
1327 result
+= SavePaneInfo(pane
)+wxT("|");
1330 int dock_i
, dock_count
= m_docks
.GetCount();
1331 for (dock_i
= 0; dock_i
< dock_count
; ++dock_i
)
1333 wxAuiDockInfo
& dock
= m_docks
.Item(dock_i
);
1335 result
+= wxString
::Format(wxT("dock_size(%d,%d,%d)=%d|"),
1336 dock
.dock_direction
, dock
.dock_layer
,
1337 dock
.dock_row
, dock
.size
);
1343 // LoadPerspective() loads a layout which was saved with SavePerspective()
1344 // If the "update" flag parameter is true, the GUI will immediately be updated
1346 bool wxAuiManager
::LoadPerspective(const wxString
& layout
, bool update
)
1348 wxString input
= layout
;
1351 // check layout string version
1352 part
= input
.BeforeFirst(wxT('|'));
1353 input
= input
.AfterFirst(wxT('|'));
1356 if (part
!= wxT("layout1"))
1359 // mark all panes currently managed as docked and hidden
1360 int pane_i
, pane_count
= m_panes
.GetCount();
1361 for (pane_i
= 0; pane_i
< pane_count
; ++pane_i
)
1362 m_panes
.Item(pane_i
).Dock().Hide();
1364 // clear out the dock array; this will be reconstructed
1367 // replace escaped characters so we can
1368 // split up the string easily
1369 input
.Replace(wxT("\\|"), wxT("\a"));
1370 input
.Replace(wxT("\\;"), wxT("\b"));
1376 wxString pane_part
= input
.BeforeFirst(wxT('|'));
1377 input
= input
.AfterFirst(wxT('|'));
1378 pane_part
.Trim(true);
1380 // if the string is empty, we're done parsing
1381 if (pane_part
.empty())
1384 if (pane_part
.Left(9) == wxT("dock_size"))
1386 wxString val_name
= pane_part
.BeforeFirst(wxT('='));
1387 wxString value
= pane_part
.AfterFirst(wxT('='));
1389 long dir
, layer
, row
, size
;
1390 wxString piece
= val_name
.AfterFirst(wxT('('));
1391 piece
= piece
.BeforeLast(wxT(')'));
1392 piece
.BeforeFirst(wxT(',')).ToLong(&dir
);
1393 piece
= piece
.AfterFirst(wxT(','));
1394 piece
.BeforeFirst(wxT(',')).ToLong(&layer
);
1395 piece
.AfterFirst(wxT(',')).ToLong(&row
);
1396 value
.ToLong(&size
);
1399 dock
.dock_direction
= dir
;
1400 dock
.dock_layer
= layer
;
1401 dock
.dock_row
= row
;
1407 // Undo our escaping as LoadPaneInfo needs to take an unescaped
1408 // name so it can be called by external callers
1409 pane_part
.Replace(wxT("\a"), wxT("|"));
1410 pane_part
.Replace(wxT("\b"), wxT(";"));
1412 LoadPaneInfo(pane_part
, pane
);
1414 wxAuiPaneInfo
& p
= GetPane(pane
.name
);
1417 // the pane window couldn't be found
1418 // in the existing layout
1432 void wxAuiManager
::GetPanePositionsAndSizes(wxAuiDockInfo
& dock
,
1433 wxArrayInt
& positions
,
1436 int caption_size
= m_art
->GetMetric(wxAUI_DOCKART_CAPTION_SIZE
);
1437 int pane_border_size
= m_art
->GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE
);
1438 int gripper_size
= m_art
->GetMetric(wxAUI_DOCKART_GRIPPER_SIZE
);
1443 int offset
, action_pane
= -1;
1444 int pane_i
, pane_count
= dock
.panes
.GetCount();
1446 // find the pane marked as our action pane
1447 for (pane_i
= 0; pane_i
< pane_count
; ++pane_i
)
1449 wxAuiPaneInfo
& pane
= *(dock
.panes
.Item(pane_i
));
1451 if (pane
.state
& wxAuiPaneInfo
::actionPane
)
1453 wxASSERT_MSG(action_pane
==-1, wxT("Too many fixed action panes"));
1454 action_pane
= pane_i
;
1458 // set up each panes default position, and
1459 // determine the size (width or height, depending
1460 // on the dock's orientation) of each pane
1461 for (pane_i
= 0; pane_i
< pane_count
; ++pane_i
)
1463 wxAuiPaneInfo
& pane
= *(dock
.panes
.Item(pane_i
));
1464 positions
.Add(pane
.dock_pos
);
1467 if (pane
.HasBorder())
1468 size
+= (pane_border_size
*2);
1470 if (dock
.IsHorizontal())
1472 if (pane
.HasGripper() && !pane
.HasGripperTop())
1473 size
+= gripper_size
;
1474 size
+= pane
.best_size
.x
;
1478 if (pane
.HasGripper() && pane
.HasGripperTop())
1479 size
+= gripper_size
;
1481 if (pane
.HasCaption())
1482 size
+= caption_size
;
1483 size
+= pane
.best_size
.y
;
1489 // if there is no action pane, just return the default
1490 // positions (as specified in pane.pane_pos)
1491 if (action_pane
== -1)
1495 for (pane_i
= action_pane
-1; pane_i
>= 0; --pane_i
)
1497 int amount
= positions
[pane_i
+1] - (positions
[pane_i
] + sizes
[pane_i
]);
1502 positions
[pane_i
] -= -amount
;
1504 offset
+= sizes
[pane_i
];
1507 // if the dock mode is fixed, make sure none of the panes
1508 // overlap; we will bump panes that overlap
1510 for (pane_i
= action_pane
; pane_i
< pane_count
; ++pane_i
)
1512 int amount
= positions
[pane_i
] - offset
;
1516 positions
[pane_i
] += -amount
;
1518 offset
+= sizes
[pane_i
];
1523 void wxAuiManager
::LayoutAddPane(wxSizer
* cont
,
1524 wxAuiDockInfo
& dock
,
1525 wxAuiPaneInfo
& pane
,
1526 wxAuiDockUIPartArray
& uiparts
,
1529 wxAuiDockUIPart part
;
1530 wxSizerItem
* sizer_item
;
1532 int caption_size
= m_art
->GetMetric(wxAUI_DOCKART_CAPTION_SIZE
);
1533 int gripper_size
= m_art
->GetMetric(wxAUI_DOCKART_GRIPPER_SIZE
);
1534 int pane_border_size
= m_art
->GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE
);
1535 int pane_button_size
= m_art
->GetMetric(wxAUI_DOCKART_PANE_BUTTON_SIZE
);
1537 // find out the orientation of the item (orientation for panes
1538 // is the same as the dock's orientation)
1540 if (dock
.IsHorizontal())
1541 orientation
= wxHORIZONTAL
;
1543 orientation
= wxVERTICAL
;
1545 // this variable will store the proportion
1546 // value that the pane will receive
1547 int pane_proportion
= pane
.dock_proportion
;
1549 wxBoxSizer
* horz_pane_sizer
= new wxBoxSizer(wxHORIZONTAL
);
1550 wxBoxSizer
* vert_pane_sizer
= new wxBoxSizer(wxVERTICAL
);
1552 if (pane
.HasGripper())
1554 if (pane
.HasGripperTop())
1555 sizer_item
= vert_pane_sizer
->Add(1, gripper_size
, 0, wxEXPAND
);
1557 sizer_item
= horz_pane_sizer
->Add(gripper_size
, 1, 0, wxEXPAND
);
1559 part
.type
= wxAuiDockUIPart
::typeGripper
;
1563 part
.orientation
= orientation
;
1564 part
.cont_sizer
= horz_pane_sizer
;
1565 part
.sizer_item
= sizer_item
;
1569 if (pane
.HasCaption())
1571 // create the caption sizer
1572 wxBoxSizer
* caption_sizer
= new wxBoxSizer(wxHORIZONTAL
);
1574 sizer_item
= caption_sizer
->Add(1, caption_size
, 1, wxEXPAND
);
1576 part
.type
= wxAuiDockUIPart
::typeCaption
;
1580 part
.orientation
= orientation
;
1581 part
.cont_sizer
= vert_pane_sizer
;
1582 part
.sizer_item
= sizer_item
;
1583 int caption_part_idx
= uiparts
.GetCount();
1586 // add pane buttons to the caption
1587 int i
, button_count
;
1588 for (i
= 0, button_count
= pane
.buttons
.GetCount();
1589 i
< button_count
; ++i
)
1591 wxAuiPaneButton
& button
= pane
.buttons
.Item(i
);
1593 sizer_item
= caption_sizer
->Add(pane_button_size
,
1597 part
.type
= wxAuiDockUIPart
::typePaneButton
;
1600 part
.button
= &button
;
1601 part
.orientation
= orientation
;
1602 part
.cont_sizer
= caption_sizer
;
1603 part
.sizer_item
= sizer_item
;
1607 // if we have buttons, add a little space to the right
1608 // of them to ease visual crowding
1609 if (button_count
>= 1)
1611 caption_sizer
->Add(3,1);
1614 // add the caption sizer
1615 sizer_item
= vert_pane_sizer
->Add(caption_sizer
, 0, wxEXPAND
);
1617 uiparts
.Item(caption_part_idx
).sizer_item
= sizer_item
;
1620 // add the pane window itself
1623 sizer_item
= vert_pane_sizer
->Add(1, 1, 1, wxEXPAND
);
1627 sizer_item
= vert_pane_sizer
->Add(pane
.window
, 1, wxEXPAND
);
1628 // Don't do this because it breaks the pane size in floating windows
1629 // BIW: Right now commenting this out is causing problems with
1630 // an mdi client window as the center pane.
1631 vert_pane_sizer
->SetItemMinSize(pane
.window
, 1, 1);
1634 part
.type
= wxAuiDockUIPart
::typePane
;
1638 part
.orientation
= orientation
;
1639 part
.cont_sizer
= vert_pane_sizer
;
1640 part
.sizer_item
= sizer_item
;
1644 // determine if the pane should have a minimum size; if the pane is
1645 // non-resizable (fixed) then we must set a minimum size. Alternitavely,
1646 // if the pane.min_size is set, we must use that value as well
1648 wxSize min_size
= pane
.min_size
;
1651 if (min_size
== wxDefaultSize
)
1653 min_size
= pane
.best_size
;
1654 pane_proportion
= 0;
1658 if (min_size
!= wxDefaultSize
)
1660 vert_pane_sizer
->SetItemMinSize(
1661 vert_pane_sizer
->GetChildren().GetCount()-1,
1662 min_size
.x
, min_size
.y
);
1666 // add the verticle sizer (caption, pane window) to the
1667 // horizontal sizer (gripper, verticle sizer)
1668 horz_pane_sizer
->Add(vert_pane_sizer
, 1, wxEXPAND
);
1670 // finally, add the pane sizer to the dock sizer
1672 if (pane
.HasBorder())
1674 // allowing space for the pane's border
1675 sizer_item
= cont
->Add(horz_pane_sizer
, pane_proportion
,
1676 wxEXPAND
| wxALL
, pane_border_size
);
1678 part
.type
= wxAuiDockUIPart
::typePaneBorder
;
1682 part
.orientation
= orientation
;
1683 part
.cont_sizer
= cont
;
1684 part
.sizer_item
= sizer_item
;
1689 sizer_item
= cont
->Add(horz_pane_sizer
, pane_proportion
, wxEXPAND
);
1693 void wxAuiManager
::LayoutAddDock(wxSizer
* cont
,
1694 wxAuiDockInfo
& dock
,
1695 wxAuiDockUIPartArray
& uiparts
,
1698 wxSizerItem
* sizer_item
;
1699 wxAuiDockUIPart part
;
1701 int sash_size
= m_art
->GetMetric(wxAUI_DOCKART_SASH_SIZE
);
1702 int orientation
= dock
.IsHorizontal() ? wxHORIZONTAL
: wxVERTICAL
;
1704 // resizable bottom and right docks have a sash before them
1705 if (!m_has_maximized
&& !dock
.fixed
&& (dock
.dock_direction
== wxAUI_DOCK_BOTTOM
||
1706 dock
.dock_direction
== wxAUI_DOCK_RIGHT
))
1708 sizer_item
= cont
->Add(sash_size
, sash_size
, 0, wxEXPAND
);
1710 part
.type
= wxAuiDockUIPart
::typeDockSizer
;
1711 part
.orientation
= orientation
;
1715 part
.cont_sizer
= cont
;
1716 part
.sizer_item
= sizer_item
;
1720 // create the sizer for the dock
1721 wxSizer
* dock_sizer
= new wxBoxSizer(orientation
);
1723 // add each pane to the dock
1724 bool has_maximized_pane
= false;
1725 int pane_i
, pane_count
= dock
.panes
.GetCount();
1729 wxArrayInt pane_positions
, pane_sizes
;
1731 // figure out the real pane positions we will
1732 // use, without modifying the each pane's pane_pos member
1733 GetPanePositionsAndSizes(dock
, pane_positions
, pane_sizes
);
1736 for (pane_i
= 0; pane_i
< pane_count
; ++pane_i
)
1738 wxAuiPaneInfo
& pane
= *(dock
.panes
.Item(pane_i
));
1739 int pane_pos
= pane_positions
.Item(pane_i
);
1741 if (pane
.IsMaximized())
1742 has_maximized_pane
= true;
1745 int amount
= pane_pos
- offset
;
1748 if (dock
.IsVertical())
1749 sizer_item
= dock_sizer
->Add(1, amount
, 0, wxEXPAND
);
1751 sizer_item
= dock_sizer
->Add(amount
, 1, 0, wxEXPAND
);
1753 part
.type
= wxAuiDockUIPart
::typeBackground
;
1757 part
.orientation
= (orientation
==wxHORIZONTAL
) ? wxVERTICAL
:wxHORIZONTAL
;
1758 part
.cont_sizer
= dock_sizer
;
1759 part
.sizer_item
= sizer_item
;
1765 LayoutAddPane(dock_sizer
, dock
, pane
, uiparts
, spacer_only
);
1767 offset
+= pane_sizes
.Item(pane_i
);
1770 // at the end add a very small stretchable background area
1771 sizer_item
= dock_sizer
->Add(0,0, 1, wxEXPAND
);
1773 part
.type
= wxAuiDockUIPart
::typeBackground
;
1777 part
.orientation
= orientation
;
1778 part
.cont_sizer
= dock_sizer
;
1779 part
.sizer_item
= sizer_item
;
1784 for (pane_i
= 0; pane_i
< pane_count
; ++pane_i
)
1786 wxAuiPaneInfo
& pane
= *(dock
.panes
.Item(pane_i
));
1788 if (pane
.IsMaximized())
1789 has_maximized_pane
= true;
1791 // if this is not the first pane being added,
1792 // we need to add a pane sizer
1793 if (!m_has_maximized
&& pane_i
> 0)
1795 sizer_item
= dock_sizer
->Add(sash_size
, sash_size
, 0, wxEXPAND
);
1797 part
.type
= wxAuiDockUIPart
::typePaneSizer
;
1799 part
.pane
= dock
.panes
.Item(pane_i
-1);
1801 part
.orientation
= (orientation
==wxHORIZONTAL
) ? wxVERTICAL
:wxHORIZONTAL
;
1802 part
.cont_sizer
= dock_sizer
;
1803 part
.sizer_item
= sizer_item
;
1807 LayoutAddPane(dock_sizer
, dock
, pane
, uiparts
, spacer_only
);
1811 if (dock
.dock_direction
== wxAUI_DOCK_CENTER
|| has_maximized_pane
)
1812 sizer_item
= cont
->Add(dock_sizer
, 1, wxEXPAND
);
1814 sizer_item
= cont
->Add(dock_sizer
, 0, wxEXPAND
);
1816 part
.type
= wxAuiDockUIPart
::typeDock
;
1820 part
.orientation
= orientation
;
1821 part
.cont_sizer
= cont
;
1822 part
.sizer_item
= sizer_item
;
1825 if (dock
.IsHorizontal())
1826 cont
->SetItemMinSize(dock_sizer
, 0, dock
.size
);
1828 cont
->SetItemMinSize(dock_sizer
, dock
.size
, 0);
1830 // top and left docks have a sash after them
1831 if (!m_has_maximized
&&
1833 (dock
.dock_direction
== wxAUI_DOCK_TOP
||
1834 dock
.dock_direction
== wxAUI_DOCK_LEFT
))
1836 sizer_item
= cont
->Add(sash_size
, sash_size
, 0, wxEXPAND
);
1838 part
.type
= wxAuiDockUIPart
::typeDockSizer
;
1842 part
.orientation
= orientation
;
1843 part
.cont_sizer
= cont
;
1844 part
.sizer_item
= sizer_item
;
1849 wxSizer
* wxAuiManager
::LayoutAll(wxAuiPaneInfoArray
& panes
,
1850 wxAuiDockInfoArray
& docks
,
1851 wxAuiDockUIPartArray
& uiparts
,
1854 wxBoxSizer
* container
= new wxBoxSizer(wxVERTICAL
);
1856 int pane_border_size
= m_art
->GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE
);
1857 int caption_size
= m_art
->GetMetric(wxAUI_DOCKART_CAPTION_SIZE
);
1858 wxSize cli_size
= m_frame
->GetClientSize();
1859 int i
, dock_count
, pane_count
;
1862 // empty all docks out
1863 for (i
= 0, dock_count
= docks
.GetCount(); i
< dock_count
; ++i
)
1864 docks
.Item(i
).panes
.Empty();
1867 // iterate through all known panes, filing each
1868 // of them into the appropriate dock. If the
1869 // pane does not exist in the dock, add it
1870 for (i
= 0, pane_count
= panes
.GetCount(); i
< pane_count
; ++i
)
1872 wxAuiPaneInfo
& p
= panes
.Item(i
);
1874 // find any docks with the same dock direction, dock layer, and
1875 // dock row as the pane we are working on
1876 wxAuiDockInfo
* dock
;
1877 wxAuiDockInfoPtrArray arr
;
1878 FindDocks(docks
, p
.dock_direction
, p
.dock_layer
, p
.dock_row
, arr
);
1880 if (arr
.GetCount() > 0)
1882 // found the right dock
1887 // dock was not found, so we need to create a new one
1889 d
.dock_direction
= p
.dock_direction
;
1890 d
.dock_layer
= p
.dock_layer
;
1891 d
.dock_row
= p
.dock_row
;
1893 dock
= &docks
.Last();
1897 if (p
.IsDocked() && p
.IsShown())
1899 // remove the pane from any existing docks except this one
1900 RemovePaneFromDocks(docks
, p
, dock
);
1902 // pane needs to be added to the dock,
1903 // if it doesn't already exist
1904 if (!FindPaneInDock(*dock
, p
.window
))
1905 dock
->panes
.Add(&p
);
1909 // remove the pane from any existing docks
1910 RemovePaneFromDocks(docks
, p
);
1915 // remove any empty docks
1916 for (i
= docks
.GetCount()-1; i
>= 0; --i
)
1918 if (docks
.Item(i
).panes
.GetCount() == 0)
1922 // configure the docks further
1923 for (i
= 0, dock_count
= docks
.GetCount(); i
< dock_count
; ++i
)
1925 wxAuiDockInfo
& dock
= docks
.Item(i
);
1926 int j
, dock_pane_count
= dock
.panes
.GetCount();
1928 // sort the dock pane array by the pane's
1929 // dock position (dock_pos), in ascending order
1930 dock
.panes
.Sort(PaneSortFunc
);
1932 // for newly created docks, set up their initial size
1937 for (j
= 0; j
< dock_pane_count
; ++j
)
1939 wxAuiPaneInfo
& pane
= *dock
.panes
.Item(j
);
1940 wxSize pane_size
= pane
.best_size
;
1941 if (pane_size
== wxDefaultSize
)
1942 pane_size
= pane
.min_size
;
1943 if (pane_size
== wxDefaultSize
)
1944 pane_size
= pane
.window
->GetSize();
1946 if (dock
.IsHorizontal())
1947 size
= wxMax(pane_size
.y
, size
);
1949 size
= wxMax(pane_size
.x
, size
);
1952 // add space for the border (two times), but only
1953 // if at least one pane inside the dock has a pane border
1954 for (j
= 0; j
< dock_pane_count
; ++j
)
1956 if (dock
.panes
.Item(j
)->HasBorder())
1958 size
+= (pane_border_size
*2);
1963 // if pane is on the top or bottom, add the caption height,
1964 // but only if at least one pane inside the dock has a caption
1965 if (dock
.IsHorizontal())
1967 for (j
= 0; j
< dock_pane_count
; ++j
)
1969 if (dock
.panes
.Item(j
)->HasCaption())
1971 size
+= caption_size
;
1978 // new dock's size may not be more than the dock constraint
1979 // parameter specifies. See SetDockSizeConstraint()
1981 int max_dock_x_size
= (int)(m_dock_constraint_x
* ((double)cli_size
.x
));
1982 int max_dock_y_size
= (int)(m_dock_constraint_y
* ((double)cli_size
.y
));
1984 if (dock
.IsHorizontal())
1985 size
= wxMin(size
, max_dock_y_size
);
1987 size
= wxMin(size
, max_dock_x_size
);
1989 // absolute minimum size for a dock is 10 pixels
1997 // determine the dock's minimum size
1998 bool plus_border
= false;
1999 bool plus_caption
= false;
2000 int dock_min_size
= 0;
2001 for (j
= 0; j
< dock_pane_count
; ++j
)
2003 wxAuiPaneInfo
& pane
= *dock
.panes
.Item(j
);
2004 if (pane
.min_size
!= wxDefaultSize
)
2006 if (pane
.HasBorder())
2008 if (pane
.HasCaption())
2009 plus_caption
= true;
2010 if (dock
.IsHorizontal())
2012 if (pane
.min_size
.y
> dock_min_size
)
2013 dock_min_size
= pane
.min_size
.y
;
2017 if (pane
.min_size
.x
> dock_min_size
)
2018 dock_min_size
= pane
.min_size
.x
;
2024 dock_min_size
+= (pane_border_size
*2);
2025 if (plus_caption
&& dock
.IsHorizontal())
2026 dock_min_size
+= (caption_size
);
2028 dock
.min_size
= dock_min_size
;
2031 // if the pane's current size is less than it's
2032 // minimum, increase the dock's size to it's minimum
2033 if (dock
.size
< dock
.min_size
)
2034 dock
.size
= dock
.min_size
;
2037 // determine the dock's mode (fixed or proportional);
2038 // determine whether the dock has only toolbars
2039 bool action_pane_marked
= false;
2041 dock
.toolbar
= true;
2042 for (j
= 0; j
< dock_pane_count
; ++j
)
2044 wxAuiPaneInfo
& pane
= *dock
.panes
.Item(j
);
2045 if (!pane
.IsFixed())
2047 if (!pane
.IsToolbar())
2048 dock
.toolbar
= false;
2049 if (pane
.state
& wxAuiPaneInfo
::actionPane
)
2050 action_pane_marked
= true;
2054 // if the dock mode is proportional and not fixed-pixel,
2055 // reassign the dock_pos to the sequential 0, 1, 2, 3;
2056 // e.g. remove gaps like 1, 2, 30, 500
2059 for (j
= 0; j
< dock_pane_count
; ++j
)
2061 wxAuiPaneInfo
& pane
= *dock
.panes
.Item(j
);
2066 // if the dock mode is fixed, and none of the panes
2067 // are being moved right now, make sure the panes
2068 // do not overlap each other. If they do, we will
2069 // adjust the positions of the panes
2070 if (dock
.fixed
&& !action_pane_marked
)
2072 wxArrayInt pane_positions
, pane_sizes
;
2073 GetPanePositionsAndSizes(dock
, pane_positions
, pane_sizes
);
2076 for (j
= 0; j
< dock_pane_count
; ++j
)
2078 wxAuiPaneInfo
& pane
= *(dock
.panes
.Item(j
));
2079 pane
.dock_pos
= pane_positions
[j
];
2081 int amount
= pane
.dock_pos
- offset
;
2085 pane
.dock_pos
+= -amount
;
2087 offset
+= pane_sizes
[j
];
2092 // discover the maximum dock layer
2094 for (i
= 0; i
< dock_count
; ++i
)
2095 max_layer
= wxMax(max_layer
, docks
.Item(i
).dock_layer
);
2098 // clear out uiparts
2101 // create a bunch of box sizers,
2102 // from the innermost level outwards.
2103 wxSizer
* cont
= NULL
;
2104 wxSizer
* middle
= NULL
;
2108 for (layer
= 0; layer
<= max_layer
; ++layer
)
2110 wxAuiDockInfoPtrArray arr
;
2112 // find any docks in this layer
2113 FindDocks(docks
, -1, layer
, -1, arr
);
2115 // if there aren't any, skip to the next layer
2119 wxSizer
* old_cont
= cont
;
2121 // create a container which will hold this layer's
2122 // docks (top, bottom, left, right)
2123 cont
= new wxBoxSizer(wxVERTICAL
);
2126 // find any top docks in this layer
2127 FindDocks(docks
, wxAUI_DOCK_TOP
, layer
, -1, arr
);
2128 RenumberDockRows(arr
);
2131 for (row
= 0, row_count
= arr
.GetCount(); row
< row_count
; ++row
)
2132 LayoutAddDock(cont
, *arr
.Item(row
), uiparts
, spacer_only
);
2136 // fill out the middle layer (which consists
2137 // of left docks, content area and right docks)
2139 middle
= new wxBoxSizer(wxHORIZONTAL
);
2141 // find any left docks in this layer
2142 FindDocks(docks
, wxAUI_DOCK_LEFT
, layer
, -1, arr
);
2143 RenumberDockRows(arr
);
2146 for (row
= 0, row_count
= arr
.GetCount(); row
< row_count
; ++row
)
2147 LayoutAddDock(middle
, *arr
.Item(row
), uiparts
, spacer_only
);
2150 // add content dock (or previous layer's sizer
2154 // find any center docks
2155 FindDocks(docks
, wxAUI_DOCK_CENTER
, -1, -1, arr
);
2158 for (row
= 0,row_count
= arr
.GetCount(); row
<row_count
; ++row
)
2159 LayoutAddDock(middle
, *arr
.Item(row
), uiparts
, spacer_only
);
2161 else if (!m_has_maximized
)
2163 // there are no center docks, add a background area
2164 wxSizerItem
* sizer_item
= middle
->Add(1,1, 1, wxEXPAND
);
2165 wxAuiDockUIPart part
;
2166 part
.type
= wxAuiDockUIPart
::typeBackground
;
2170 part
.cont_sizer
= middle
;
2171 part
.sizer_item
= sizer_item
;
2177 middle
->Add(old_cont
, 1, wxEXPAND
);
2180 // find any right docks in this layer
2181 FindDocks(docks
, wxAUI_DOCK_RIGHT
, layer
, -1, arr
);
2182 RenumberDockRows(arr
);
2185 for (row
= arr
.GetCount()-1; row
>= 0; --row
)
2186 LayoutAddDock(middle
, *arr
.Item(row
), uiparts
, spacer_only
);
2189 cont
->Add(middle
, 1, wxEXPAND
);
2193 // find any bottom docks in this layer
2194 FindDocks(docks
, wxAUI_DOCK_BOTTOM
, layer
, -1, arr
);
2195 RenumberDockRows(arr
);
2198 for (row
= arr
.GetCount()-1; row
>= 0; --row
)
2199 LayoutAddDock(cont
, *arr
.Item(row
), uiparts
, spacer_only
);
2206 // no sizer available, because there are no docks,
2207 // therefore we will create a simple background area
2208 cont
= new wxBoxSizer(wxVERTICAL
);
2209 wxSizerItem
* sizer_item
= cont
->Add(1,1, 1, wxEXPAND
);
2210 wxAuiDockUIPart part
;
2211 part
.type
= wxAuiDockUIPart
::typeBackground
;
2215 part
.cont_sizer
= middle
;
2216 part
.sizer_item
= sizer_item
;
2220 container
->Add(cont
, 1, wxEXPAND
);
2225 // SetDockSizeConstraint() allows the dock constraints to be set. For example,
2226 // specifying values of 0.5, 0.5 will mean that upon dock creation, a dock may
2227 // not be larger than half of the window's size
2229 void wxAuiManager
::SetDockSizeConstraint(double width_pct
, double height_pct
)
2231 m_dock_constraint_x
= wxMax(0.0, wxMin(1.0, width_pct
));
2232 m_dock_constraint_y
= wxMax(0.0, wxMin(1.0, height_pct
));
2235 void wxAuiManager
::GetDockSizeConstraint(double* width_pct
, double* height_pct
) const
2238 *width_pct
= m_dock_constraint_x
;
2241 *height_pct
= m_dock_constraint_y
;
2246 // Update() updates the layout. Whenever changes are made to
2247 // one or more panes, this function should be called. It is the
2248 // external entry point for running the layout engine.
2250 void wxAuiManager
::Update()
2253 int i
, pane_count
= m_panes
.GetCount();
2256 // destroy floating panes which have been
2257 // redocked or are becoming non-floating
2258 for (i
= 0; i
< pane_count
; ++i
)
2260 wxAuiPaneInfo
& p
= m_panes
.Item(i
);
2262 if (!p
.IsFloating() && p
.frame
)
2264 // because the pane is no longer in a floating, we need to
2265 // reparent it to m_frame and destroy the floating frame
2268 p
.window
->SetSize(1,1);
2271 // the following block is a workaround for bug #1531361
2272 // (see wxWidgets sourceforge page). On wxGTK (only), when
2273 // a frame is shown/hidden, a move event unfortunately
2274 // also gets fired. Because we may be dragging around
2275 // a pane, we need to cancel that action here to prevent
2276 // a spurious crash.
2277 if (m_action_window
== p
.frame
)
2279 if (wxWindow
::GetCapture() == m_frame
)
2280 m_frame
->ReleaseMouse();
2281 m_action
= actionNone
;
2282 m_action_window
= NULL
;
2286 if (p
.frame
->IsShown())
2287 p
.frame
->Show(false);
2289 // reparent to m_frame and destroy the pane
2290 if (m_action_window
== p
.frame
)
2292 m_action_window
= NULL
;
2295 p
.window
->Reparent(m_frame
);
2296 p
.frame
->SetSizer(NULL
);
2303 // delete old sizer first
2304 m_frame
->SetSizer(NULL
);
2306 // create a layout for all of the panes
2307 sizer
= LayoutAll(m_panes
, m_docks
, m_uiparts
, false);
2309 // hide or show panes as necessary,
2310 // and float panes as necessary
2311 for (i
= 0; i
< pane_count
; ++i
)
2313 wxAuiPaneInfo
& p
= m_panes
.Item(i
);
2317 if (p
.frame
== NULL
)
2319 // we need to create a frame for this
2320 // pane, which has recently been floated
2321 wxAuiFloatingFrame
* frame
= CreateFloatingFrame(m_frame
, p
);
2323 // on MSW and Mac, if the owner desires transparent dragging, and
2324 // the dragging is happening right now, then the floating
2325 // window should have this style by default
2326 if (m_action
== actionDragFloatingPane
&&
2327 (m_flags
& wxAUI_MGR_TRANSPARENT_DRAG
))
2328 frame
->SetTransparent(150);
2330 frame
->SetPaneWindow(p
);
2333 if (p
.IsShown() && !frame
->IsShown())
2338 // frame already exists, make sure it's position
2339 // and size reflect the information in wxAuiPaneInfo
2340 if (p
.frame
->GetPosition() != p
.floating_pos
)
2342 p
.frame
->SetSize(p
.floating_pos
.x
, p
.floating_pos
.y
,
2343 p
.floating_size
.x
, p
.floating_size
.y
,
2344 wxSIZE_USE_EXISTING
);
2346 p.frame->SetSize(p.floating_pos.x, p.floating_pos.y,
2347 wxDefaultCoord, wxDefaultCoord,
2348 wxSIZE_USE_EXISTING);
2349 //p.frame->Move(p.floating_pos.x, p.floating_pos.y);
2353 if (p
.frame
->IsShown() != p
.IsShown())
2354 p
.frame
->Show(p
.IsShown());
2359 if (p
.window
->IsShown() != p
.IsShown())
2360 p
.window
->Show(p
.IsShown());
2363 // if "active panes" are no longer allowed, clear
2364 // any optionActive values from the pane states
2365 if ((m_flags
& wxAUI_MGR_ALLOW_ACTIVE_PANE
) == 0)
2367 p
.state
&= ~wxAuiPaneInfo
::optionActive
;
2372 // keep track of the old window rectangles so we can
2373 // refresh those windows whose rect has changed
2374 wxAuiRectArray old_pane_rects
;
2375 for (i
= 0; i
< pane_count
; ++i
)
2378 wxAuiPaneInfo
& p
= m_panes
.Item(i
);
2380 if (p
.window
&& p
.IsShown() && p
.IsDocked())
2383 old_pane_rects
.Add(r
);
2389 // apply the new sizer
2390 m_frame
->SetSizer(sizer
);
2391 m_frame
->SetAutoLayout(false);
2396 // now that the frame layout is done, we need to check
2397 // the new pane rectangles against the old rectangles that
2398 // we saved a few lines above here. If the rectangles have
2399 // changed, the corresponding panes must also be updated
2400 for (i
= 0; i
< pane_count
; ++i
)
2402 wxAuiPaneInfo
& p
= m_panes
.Item(i
);
2403 if (p
.window
&& p
.window
->IsShown() && p
.IsDocked())
2405 if (p
.rect
!= old_pane_rects
[i
])
2407 p
.window
->Refresh();
2416 // set frame's minimum size
2419 // N.B. More work needs to be done on frame minimum sizes;
2420 // this is some intresting code that imposes the minimum size,
2421 // but we may want to include a more flexible mechanism or
2422 // options for multiple minimum-size modes, e.g. strict or lax
2423 wxSize min_size = sizer->GetMinSize();
2424 wxSize frame_size = m_frame->GetSize();
2425 wxSize client_size = m_frame->GetClientSize();
2427 wxSize minframe_size(min_size.x+frame_size.x-client_size.x,
2428 min_size.y+frame_size.y-client_size.y );
2430 m_frame->SetMinSize(minframe_size);
2432 if (frame_size.x < minframe_size.x ||
2433 frame_size.y < minframe_size.y)
2434 sizer->Fit(m_frame);
2439 // DoFrameLayout() is an internal function which invokes wxSizer::Layout
2440 // on the frame's main sizer, then measures all the various UI items
2441 // and updates their internal rectangles. This should always be called
2442 // instead of calling m_frame->Layout() directly
2444 void wxAuiManager
::DoFrameLayout()
2449 for (i
= 0, part_count
= m_uiparts
.GetCount(); i
< part_count
; ++i
)
2451 wxAuiDockUIPart
& part
= m_uiparts
.Item(i
);
2453 // get the rectangle of the UI part
2454 // originally, this code looked like this:
2455 // part.rect = wxRect(part.sizer_item->GetPosition(),
2456 // part.sizer_item->GetSize());
2457 // this worked quite well, with one exception: the mdi
2458 // client window had a "deferred" size variable
2459 // that returned the wrong size. It looks like
2460 // a bug in wx, because the former size of the window
2461 // was being returned. So, we will retrieve the part's
2462 // rectangle via other means
2465 part
.rect
= part
.sizer_item
->GetRect();
2466 int flag
= part
.sizer_item
->GetFlag();
2467 int border
= part
.sizer_item
->GetBorder();
2470 part
.rect
.y
-= border
;
2471 part
.rect
.height
+= border
;
2475 part
.rect
.x
-= border
;
2476 part
.rect
.width
+= border
;
2478 if (flag
& wxBOTTOM
)
2479 part
.rect
.height
+= border
;
2481 part
.rect
.width
+= border
;
2484 if (part
.type
== wxAuiDockUIPart
::typeDock
)
2485 part
.dock
->rect
= part
.rect
;
2486 if (part
.type
== wxAuiDockUIPart
::typePane
)
2487 part
.pane
->rect
= part
.rect
;
2491 // GetPanePart() looks up the pane the pane border UI part (or the regular
2492 // pane part if there is no border). This allows the caller to get the exact
2493 // rectangle of the pane in question, including decorations like
2494 // caption and border (if any).
2496 wxAuiDockUIPart
* wxAuiManager
::GetPanePart(wxWindow
* wnd
)
2499 for (i
= 0, part_count
= m_uiparts
.GetCount(); i
< part_count
; ++i
)
2501 wxAuiDockUIPart
& part
= m_uiparts
.Item(i
);
2502 if (part
.type
== wxAuiDockUIPart
::typePaneBorder
&&
2503 part
.pane
&& part
.pane
->window
== wnd
)
2506 for (i
= 0, part_count
= m_uiparts
.GetCount(); i
< part_count
; ++i
)
2508 wxAuiDockUIPart
& part
= m_uiparts
.Item(i
);
2509 if (part
.type
== wxAuiDockUIPart
::typePane
&&
2510 part
.pane
&& part
.pane
->window
== wnd
)
2518 // GetDockPixelOffset() is an internal function which returns
2519 // a dock's offset in pixels from the left side of the window
2520 // (for horizontal docks) or from the top of the window (for
2521 // vertical docks). This value is necessary for calculating
2522 // fixel-pane/toolbar offsets when they are dragged.
2524 int wxAuiManager
::GetDockPixelOffset(wxAuiPaneInfo
& test
)
2526 // the only way to accurately calculate the dock's
2527 // offset is to actually run a theoretical layout
2529 int i
, part_count
, dock_count
;
2530 wxAuiDockInfoArray docks
;
2531 wxAuiPaneInfoArray panes
;
2532 wxAuiDockUIPartArray uiparts
;
2533 CopyDocksAndPanes(docks
, panes
, m_docks
, m_panes
);
2536 wxSizer
* sizer
= LayoutAll(panes
, docks
, uiparts
, true);
2537 wxSize client_size
= m_frame
->GetClientSize();
2538 sizer
->SetDimension(0, 0, client_size
.x
, client_size
.y
);
2541 for (i
= 0, part_count
= uiparts
.GetCount(); i
< part_count
; ++i
)
2543 wxAuiDockUIPart
& part
= uiparts
.Item(i
);
2544 part
.rect
= wxRect(part
.sizer_item
->GetPosition(),
2545 part
.sizer_item
->GetSize());
2546 if (part
.type
== wxAuiDockUIPart
::typeDock
)
2547 part
.dock
->rect
= part
.rect
;
2552 for (i
= 0, dock_count
= docks
.GetCount(); i
< dock_count
; ++i
)
2554 wxAuiDockInfo
& dock
= docks
.Item(i
);
2555 if (test
.dock_direction
== dock
.dock_direction
&&
2556 test
.dock_layer
==dock
.dock_layer
&& test
.dock_row
==dock
.dock_row
)
2558 if (dock
.IsVertical())
2570 // ProcessDockResult() is a utility function used by DoDrop() - it checks
2571 // if a dock operation is allowed, the new dock position is copied into
2572 // the target info. If the operation was allowed, the function returns true.
2574 bool wxAuiManager
::ProcessDockResult(wxAuiPaneInfo
& target
,
2575 const wxAuiPaneInfo
& new_pos
)
2577 bool allowed
= false;
2578 switch (new_pos
.dock_direction
)
2580 case wxAUI_DOCK_TOP
: allowed
= target
.IsTopDockable(); break;
2581 case wxAUI_DOCK_BOTTOM
: allowed
= target
.IsBottomDockable(); break;
2582 case wxAUI_DOCK_LEFT
: allowed
= target
.IsLeftDockable(); break;
2583 case wxAUI_DOCK_RIGHT
: allowed
= target
.IsRightDockable(); break;
2593 // DoDrop() is an important function. It basically takes a mouse position,
2594 // and determines where the pane's new position would be. If the pane is to be
2595 // dropped, it performs the drop operation using the specified dock and pane
2596 // arrays. By specifying copied dock and pane arrays when calling, a "what-if"
2597 // scenario can be performed, giving precise coordinates for drop hints.
2598 // If, however, wxAuiManager:m_docks and wxAuiManager::m_panes are specified
2599 // as parameters, the changes will be made to the main state arrays
2601 const int auiInsertRowPixels
= 10;
2602 const int auiNewRowPixels
= 40;
2603 const int auiLayerInsertPixels
= 40;
2604 const int auiLayerInsertOffset
= 5;
2606 bool wxAuiManager
::DoDrop(wxAuiDockInfoArray
& docks
,
2607 wxAuiPaneInfoArray
& panes
,
2608 wxAuiPaneInfo
& target
,
2610 const wxPoint
& offset
)
2612 wxSize cli_size
= m_frame
->GetClientSize();
2614 wxAuiPaneInfo drop
= target
;
2617 // The result should always be shown
2621 // Check to see if the pane has been dragged outside of the window
2622 // (or near to the outside of the window), if so, dock it along the edge
2625 int layer_insert_offset
= auiLayerInsertOffset
;
2626 if (drop
.IsToolbar())
2627 layer_insert_offset
= 0;
2630 if (pt
.x
< layer_insert_offset
&&
2631 pt
.x
> layer_insert_offset
-auiLayerInsertPixels
)
2633 int new_layer
= wxMax(wxMax(GetMaxLayer(docks
, wxAUI_DOCK_LEFT
),
2634 GetMaxLayer(docks
, wxAUI_DOCK_BOTTOM
)),
2635 GetMaxLayer(docks
, wxAUI_DOCK_TOP
)) + 1;
2637 if (drop
.IsToolbar())
2638 new_layer
= auiToolBarLayer
;
2643 Position(pt
.y
- GetDockPixelOffset(drop
) - offset
.y
);
2644 return ProcessDockResult(target
, drop
);
2646 else if (pt
.y
< layer_insert_offset
&&
2647 pt
.y
> layer_insert_offset
-auiLayerInsertPixels
)
2649 int new_layer
= wxMax(wxMax(GetMaxLayer(docks
, wxAUI_DOCK_TOP
),
2650 GetMaxLayer(docks
, wxAUI_DOCK_LEFT
)),
2651 GetMaxLayer(docks
, wxAUI_DOCK_RIGHT
)) + 1;
2653 if (drop
.IsToolbar())
2654 new_layer
= auiToolBarLayer
;
2659 Position(pt
.x
- GetDockPixelOffset(drop
) - offset
.x
);
2660 return ProcessDockResult(target
, drop
);
2662 else if (pt
.x
>= cli_size
.x
- layer_insert_offset
&&
2663 pt
.x
< cli_size
.x
- layer_insert_offset
+ auiLayerInsertPixels
)
2665 int new_layer
= wxMax(wxMax(GetMaxLayer(docks
, wxAUI_DOCK_RIGHT
),
2666 GetMaxLayer(docks
, wxAUI_DOCK_TOP
)),
2667 GetMaxLayer(docks
, wxAUI_DOCK_BOTTOM
)) + 1;
2669 if (drop
.IsToolbar())
2670 new_layer
= auiToolBarLayer
;
2672 drop
.Dock().Right().
2675 Position(pt
.y
- GetDockPixelOffset(drop
) - offset
.y
);
2676 return ProcessDockResult(target
, drop
);
2678 else if (pt
.y
>= cli_size
.y
- layer_insert_offset
&&
2679 pt
.y
< cli_size
.y
- layer_insert_offset
+ auiLayerInsertPixels
)
2681 int new_layer
= wxMax( wxMax( GetMaxLayer(docks
, wxAUI_DOCK_BOTTOM
),
2682 GetMaxLayer(docks
, wxAUI_DOCK_LEFT
)),
2683 GetMaxLayer(docks
, wxAUI_DOCK_RIGHT
)) + 1;
2685 if (drop
.IsToolbar())
2686 new_layer
= auiToolBarLayer
;
2688 drop
.Dock().Bottom().
2691 Position(pt
.x
- GetDockPixelOffset(drop
) - offset
.x
);
2692 return ProcessDockResult(target
, drop
);
2696 wxAuiDockUIPart
* part
= HitTest(pt
.x
, pt
.y
);
2699 if (drop
.IsToolbar())
2701 if (!part
|| !part
->dock
)
2704 // calculate the offset from where the dock begins
2705 // to the point where the user dropped the pane
2706 int dock_drop_offset
= 0;
2707 if (part
->dock
->IsHorizontal())
2708 dock_drop_offset
= pt
.x
- part
->dock
->rect
.x
- offset
.x
;
2710 dock_drop_offset
= pt
.y
- part
->dock
->rect
.y
- offset
.y
;
2713 // toolbars may only be moved in and to fixed-pane docks,
2714 // otherwise we will try to float the pane. Also, the pane
2715 // should float if being dragged over center pane windows
2716 if (!part
->dock
->fixed
|| part
->dock
->dock_direction
== wxAUI_DOCK_CENTER
)
2718 if (m_last_rect
.IsEmpty() || m_last_rect
.Contains(pt
.x
, pt
.y
))
2724 if ((m_flags
& wxAUI_MGR_ALLOW_FLOATING
) &&
2725 (drop
.IsFloatable() ||
2726 (part
->dock
->dock_direction
!= wxAUI_DOCK_CENTER
&&
2727 part
->dock
->dock_direction
!= wxAUI_DOCK_NONE
)))
2734 return ProcessDockResult(target
, drop
);
2737 drop
.Position(pt
.x
- GetDockPixelOffset(drop
) - offset
.x
);
2739 return ProcessDockResult(target
, drop
);
2748 m_last_rect
= part
->dock
->rect
;
2749 m_last_rect
.Inflate( 15, 15 );
2753 Direction(part
->dock
->dock_direction
).
2754 Layer(part
->dock
->dock_layer
).
2755 Row(part
->dock
->dock_row
).
2756 Position(dock_drop_offset
);
2759 ((pt
.y
< part
->dock
->rect
.y
+ 1) && part
->dock
->IsHorizontal()) ||
2760 ((pt
.x
< part
->dock
->rect
.x
+ 1) && part
->dock
->IsVertical())
2761 ) && part
->dock
->panes
.GetCount() > 1)
2763 if ((part
->dock
->dock_direction
== wxAUI_DOCK_TOP
) ||
2764 (part
->dock
->dock_direction
== wxAUI_DOCK_LEFT
))
2766 int row
= drop
.dock_row
;
2767 DoInsertDockRow(panes
, part
->dock
->dock_direction
,
2768 part
->dock
->dock_layer
,
2769 part
->dock
->dock_row
);
2770 drop
.dock_row
= row
;
2774 DoInsertDockRow(panes
, part
->dock
->dock_direction
,
2775 part
->dock
->dock_layer
,
2776 part
->dock
->dock_row
+1);
2777 drop
.dock_row
= part
->dock
->dock_row
+1;
2782 ((pt
.y
> part
->dock
->rect
.y
+ part
->dock
->rect
.height
- 2 ) && part
->dock
->IsHorizontal()) ||
2783 ((pt
.x
> part
->dock
->rect
.x
+ part
->dock
->rect
.width
- 2 ) && part
->dock
->IsVertical())
2784 ) && part
->dock
->panes
.GetCount() > 1)
2786 if ((part
->dock
->dock_direction
== wxAUI_DOCK_TOP
) ||
2787 (part
->dock
->dock_direction
== wxAUI_DOCK_LEFT
))
2789 DoInsertDockRow(panes
, part
->dock
->dock_direction
,
2790 part
->dock
->dock_layer
,
2791 part
->dock
->dock_row
+1);
2792 drop
.dock_row
= part
->dock
->dock_row
+1;
2796 int row
= drop
.dock_row
;
2797 DoInsertDockRow(panes
, part
->dock
->dock_direction
,
2798 part
->dock
->dock_layer
,
2799 part
->dock
->dock_row
);
2800 drop
.dock_row
= row
;
2804 return ProcessDockResult(target
, drop
);
2813 if (part
->type
== wxAuiDockUIPart
::typePaneBorder
||
2814 part
->type
== wxAuiDockUIPart
::typeCaption
||
2815 part
->type
== wxAuiDockUIPart
::typeGripper
||
2816 part
->type
== wxAuiDockUIPart
::typePaneButton
||
2817 part
->type
== wxAuiDockUIPart
::typePane
||
2818 part
->type
== wxAuiDockUIPart
::typePaneSizer
||
2819 part
->type
== wxAuiDockUIPart
::typeDockSizer
||
2820 part
->type
== wxAuiDockUIPart
::typeBackground
)
2822 if (part
->type
== wxAuiDockUIPart
::typeDockSizer
)
2824 if (part
->dock
->panes
.GetCount() != 1)
2826 part
= GetPanePart(part
->dock
->panes
.Item(0)->window
);
2833 // If a normal frame is being dragged over a toolbar, insert it
2834 // along the edge under the toolbar, but over all other panes.
2835 // (this could be done much better, but somehow factoring this
2836 // calculation with the one at the beginning of this function)
2837 if (part
->dock
&& part
->dock
->toolbar
)
2841 switch (part
->dock
->dock_direction
)
2843 case wxAUI_DOCK_LEFT
:
2844 layer
= wxMax(wxMax(GetMaxLayer(docks
, wxAUI_DOCK_LEFT
),
2845 GetMaxLayer(docks
, wxAUI_DOCK_BOTTOM
)),
2846 GetMaxLayer(docks
, wxAUI_DOCK_TOP
));
2848 case wxAUI_DOCK_TOP
:
2849 layer
= wxMax(wxMax(GetMaxLayer(docks
, wxAUI_DOCK_TOP
),
2850 GetMaxLayer(docks
, wxAUI_DOCK_LEFT
)),
2851 GetMaxLayer(docks
, wxAUI_DOCK_RIGHT
));
2853 case wxAUI_DOCK_RIGHT
:
2854 layer
= wxMax(wxMax(GetMaxLayer(docks
, wxAUI_DOCK_RIGHT
),
2855 GetMaxLayer(docks
, wxAUI_DOCK_TOP
)),
2856 GetMaxLayer(docks
, wxAUI_DOCK_BOTTOM
));
2858 case wxAUI_DOCK_BOTTOM
:
2859 layer
= wxMax(wxMax(GetMaxLayer(docks
, wxAUI_DOCK_BOTTOM
),
2860 GetMaxLayer(docks
, wxAUI_DOCK_LEFT
)),
2861 GetMaxLayer(docks
, wxAUI_DOCK_RIGHT
));
2865 DoInsertDockRow(panes
, part
->dock
->dock_direction
,
2868 Direction(part
->dock
->dock_direction
).
2869 Layer(layer
).Row(0).Position(0);
2870 return ProcessDockResult(target
, drop
);
2877 part
= GetPanePart(part
->pane
->window
);
2881 bool insert_dock_row
= false;
2882 int insert_row
= part
->pane
->dock_row
;
2883 int insert_dir
= part
->pane
->dock_direction
;
2884 int insert_layer
= part
->pane
->dock_layer
;
2886 switch (part
->pane
->dock_direction
)
2888 case wxAUI_DOCK_TOP
:
2889 if (pt
.y
>= part
->rect
.y
&&
2890 pt
.y
< part
->rect
.y
+auiInsertRowPixels
)
2891 insert_dock_row
= true;
2893 case wxAUI_DOCK_BOTTOM
:
2894 if (pt
.y
> part
->rect
.y
+part
->rect
.height
-auiInsertRowPixels
&&
2895 pt
.y
<= part
->rect
.y
+ part
->rect
.height
)
2896 insert_dock_row
= true;
2898 case wxAUI_DOCK_LEFT
:
2899 if (pt
.x
>= part
->rect
.x
&&
2900 pt
.x
< part
->rect
.x
+auiInsertRowPixels
)
2901 insert_dock_row
= true;
2903 case wxAUI_DOCK_RIGHT
:
2904 if (pt
.x
> part
->rect
.x
+part
->rect
.width
-auiInsertRowPixels
&&
2905 pt
.x
<= part
->rect
.x
+part
->rect
.width
)
2906 insert_dock_row
= true;
2908 case wxAUI_DOCK_CENTER
:
2910 // "new row pixels" will be set to the default, but
2911 // must never exceed 20% of the window size
2912 int new_row_pixels_x
= auiNewRowPixels
;
2913 int new_row_pixels_y
= auiNewRowPixels
;
2915 if (new_row_pixels_x
> (part
->rect
.width
*20)/100)
2916 new_row_pixels_x
= (part
->rect
.width
*20)/100;
2918 if (new_row_pixels_y
> (part
->rect
.height
*20)/100)
2919 new_row_pixels_y
= (part
->rect
.height
*20)/100;
2922 // determine if the mouse pointer is in a location that
2923 // will cause a new row to be inserted. The hot spot positions
2924 // are along the borders of the center pane
2927 insert_dock_row
= true;
2928 if (pt
.x
>= part
->rect
.x
&&
2929 pt
.x
< part
->rect
.x
+new_row_pixels_x
)
2930 insert_dir
= wxAUI_DOCK_LEFT
;
2932 if (pt
.y
>= part
->rect
.y
&&
2933 pt
.y
< part
->rect
.y
+new_row_pixels_y
)
2934 insert_dir
= wxAUI_DOCK_TOP
;
2936 if (pt
.x
>= part
->rect
.x
+ part
->rect
.width
-new_row_pixels_x
&&
2937 pt
.x
< part
->rect
.x
+ part
->rect
.width
)
2938 insert_dir
= wxAUI_DOCK_RIGHT
;
2940 if (pt
.y
>= part
->rect
.y
+ part
->rect
.height
-new_row_pixels_y
&&
2941 pt
.y
< part
->rect
.y
+ part
->rect
.height
)
2942 insert_dir
= wxAUI_DOCK_BOTTOM
;
2946 insert_row
= GetMaxRow(panes
, insert_dir
, insert_layer
) + 1;
2950 if (insert_dock_row
)
2952 DoInsertDockRow(panes
, insert_dir
, insert_layer
, insert_row
);
2953 drop
.Dock().Direction(insert_dir
).
2954 Layer(insert_layer
).
2957 return ProcessDockResult(target
, drop
);
2960 // determine the mouse offset and the pane size, both in the
2961 // direction of the dock itself, and perpendicular to the dock
2965 if (part
->orientation
== wxVERTICAL
)
2967 offset
= pt
.y
- part
->rect
.y
;
2968 size
= part
->rect
.GetHeight();
2972 offset
= pt
.x
- part
->rect
.x
;
2973 size
= part
->rect
.GetWidth();
2976 int drop_position
= part
->pane
->dock_pos
;
2978 // if we are in the top/left part of the pane,
2979 // insert the pane before the pane being hovered over
2980 if (offset
<= size
/2)
2982 drop_position
= part
->pane
->dock_pos
;
2984 part
->pane
->dock_direction
,
2985 part
->pane
->dock_layer
,
2986 part
->pane
->dock_row
,
2987 part
->pane
->dock_pos
);
2990 // if we are in the bottom/right part of the pane,
2991 // insert the pane before the pane being hovered over
2992 if (offset
> size
/2)
2994 drop_position
= part
->pane
->dock_pos
+1;
2996 part
->pane
->dock_direction
,
2997 part
->pane
->dock_layer
,
2998 part
->pane
->dock_row
,
2999 part
->pane
->dock_pos
+1);
3003 Direction(part
->dock
->dock_direction
).
3004 Layer(part
->dock
->dock_layer
).
3005 Row(part
->dock
->dock_row
).
3006 Position(drop_position
);
3007 return ProcessDockResult(target
, drop
);
3014 void wxAuiManager
::OnHintFadeTimer(wxTimerEvent
& WXUNUSED(event
))
3016 if (!m_hint_wnd
|| m_hint_fadeamt
>= m_hint_fademax
)
3018 m_hint_fadetimer
.Stop();
3022 m_hint_fadeamt
+= 4;
3023 m_hint_wnd
->SetTransparent(m_hint_fadeamt
);
3026 void wxAuiManager
::ShowHint(const wxRect
& rect
)
3030 // if the hint rect is the same as last time, don't do anything
3031 if (m_last_hint
== rect
)
3035 m_hint_fadeamt
= m_hint_fademax
;
3037 if ((m_flags
& wxAUI_MGR_HINT_FADE
)
3038 && !((m_hint_wnd
->IsKindOf(CLASSINFO(wxPseudoTransparentFrame
))) &&
3039 (m_flags
& wxAUI_MGR_NO_VENETIAN_BLINDS_FADE
))
3043 m_hint_wnd
->SetSize(rect
);
3045 if (!m_hint_wnd
->IsShown())
3048 // if we are dragging a floating pane, set the focus
3049 // back to that floating pane (otherwise it becomes unfocused)
3050 if (m_action
== actionDragFloatingPane
&& m_action_window
)
3051 m_action_window
->SetFocus();
3053 m_hint_wnd
->SetTransparent(m_hint_fadeamt
);
3054 m_hint_wnd
->Raise();
3057 if (m_hint_fadeamt
!= m_hint_fademax
) // Only fade if we need to
3059 // start fade in timer
3060 m_hint_fadetimer
.SetOwner(this, 101);
3061 m_hint_fadetimer
.Start(5);
3064 else // Not using a transparent hint window...
3066 if (!(m_flags
& wxAUI_MGR_RECTANGLE_HINT
))
3069 if (m_last_hint
!= rect
)
3071 // remove the last hint rectangle
3077 wxScreenDC screendc
;
3078 wxRegion
clip(1, 1, 10000, 10000);
3080 // clip all floating windows, so we don't draw over them
3082 for (i
= 0, pane_count
= m_panes
.GetCount(); i
< pane_count
; ++i
)
3084 wxAuiPaneInfo
& pane
= m_panes
.Item(i
);
3086 if (pane
.IsFloating() &&
3087 pane
.frame
->IsShown())
3089 wxRect rect
= pane
.frame
->GetRect();
3091 // wxGTK returns the client size, not the whole frame size
3097 clip
.Subtract(rect
);
3101 // As we can only hide the hint by redrawing the managed window, we
3102 // need to clip the region to the managed window too or we get
3103 // nasty redrawn problems.
3104 clip
.Intersect(m_frame
->GetRect());
3106 screendc
.SetClippingRegion(clip
);
3108 wxBitmap stipple
= wxPaneCreateStippleBitmap();
3109 wxBrush
brush(stipple
);
3110 screendc
.SetBrush(brush
);
3111 screendc
.SetPen(*wxTRANSPARENT_PEN
);
3113 screendc
.DrawRectangle(rect
.x
, rect
.y
, 5, rect
.height
);
3114 screendc
.DrawRectangle(rect
.x
+5, rect
.y
, rect
.width
-10, 5);
3115 screendc
.DrawRectangle(rect
.x
+rect
.width
-5, rect
.y
, 5, rect
.height
);
3116 screendc
.DrawRectangle(rect
.x
+5, rect
.y
+rect
.height
-5, rect
.width
-10, 5);
3120 void wxAuiManager
::HideHint()
3122 // hides a transparent window hint, if there is one
3125 if (m_hint_wnd
->IsShown())
3126 m_hint_wnd
->Show(false);
3127 m_hint_wnd
->SetTransparent(0);
3128 m_hint_fadetimer
.Stop();
3129 m_last_hint
= wxRect();
3133 // hides a painted hint by redrawing the frame window
3134 if (!m_last_hint
.IsEmpty())
3138 m_last_hint
= wxRect();
3144 void wxAuiManager
::StartPaneDrag(wxWindow
* pane_window
,
3145 const wxPoint
& offset
)
3147 wxAuiPaneInfo
& pane
= GetPane(pane_window
);
3151 if (pane
.IsToolbar())
3153 m_action
= actionDragToolbarPane
;
3157 m_action
= actionDragFloatingPane
;
3160 m_action_window
= pane_window
;
3161 m_action_offset
= offset
;
3162 m_frame
->CaptureMouse();
3166 // CalculateHintRect() calculates the drop hint rectangle. The method
3167 // first calls DoDrop() to determine the exact position the pane would
3168 // be at were if dropped. If the pane would indeed become docked at the
3169 // specified drop point, the the rectangle hint will be returned in
3170 // screen coordinates. Otherwise, an empty rectangle is returned.
3171 // |pane_window| is the window pointer of the pane being dragged, |pt| is
3172 // the mouse position, in client coordinates. |offset| describes the offset
3173 // that the mouse is from the upper-left corner of the item being dragged
3175 wxRect wxAuiManager
::CalculateHintRect(wxWindow
* pane_window
,
3177 const wxPoint
& offset
)
3181 // we need to paint a hint rectangle; to find out the exact hint rectangle,
3182 // we will create a new temporary layout and then measure the resulting
3183 // rectangle; we will create a copy of the docking structures (m_dock)
3184 // so that we don't modify the real thing on screen
3186 int i
, pane_count
, part_count
;
3187 wxAuiDockInfoArray docks
;
3188 wxAuiPaneInfoArray panes
;
3189 wxAuiDockUIPartArray uiparts
;
3190 wxAuiPaneInfo hint
= GetPane(pane_window
);
3191 hint
.name
= wxT("__HINT__");
3197 CopyDocksAndPanes(docks
, panes
, m_docks
, m_panes
);
3199 // remove any pane already there which bears the same window;
3200 // this happens when you are moving a pane around in a dock
3201 for (i
= 0, pane_count
= panes
.GetCount(); i
< pane_count
; ++i
)
3203 if (panes
.Item(i
).window
== pane_window
)
3205 RemovePaneFromDocks(docks
, panes
.Item(i
));
3211 // find out where the new pane would be
3212 if (!DoDrop(docks
, panes
, hint
, pt
, offset
))
3219 wxSizer
* sizer
= LayoutAll(panes
, docks
, uiparts
, true);
3220 wxSize client_size
= m_frame
->GetClientSize();
3221 sizer
->SetDimension(0, 0, client_size
.x
, client_size
.y
);
3224 for (i
= 0, part_count
= uiparts
.GetCount();
3225 i
< part_count
; ++i
)
3227 wxAuiDockUIPart
& part
= uiparts
.Item(i
);
3229 if (part
.type
== wxAuiDockUIPart
::typePaneBorder
&&
3230 part
.pane
&& part
.pane
->name
== wxT("__HINT__"))
3232 rect
= wxRect(part
.sizer_item
->GetPosition(),
3233 part
.sizer_item
->GetSize());
3245 // actually show the hint rectangle on the screen
3246 m_frame
->ClientToScreen(&rect
.x
, &rect
.y
);
3251 // DrawHintRect() calculates the hint rectangle by calling
3252 // CalculateHintRect(). If there is a rectangle, it shows it
3253 // by calling ShowHint(), otherwise it hides any hint
3254 // rectangle currently shown
3255 void wxAuiManager
::DrawHintRect(wxWindow
* pane_window
,
3257 const wxPoint
& offset
)
3259 wxRect rect
= CalculateHintRect(pane_window
, pt
, offset
);
3271 void wxAuiManager
::OnFloatingPaneMoveStart(wxWindow
* wnd
)
3273 // try to find the pane
3274 wxAuiPaneInfo
& pane
= GetPane(wnd
);
3275 wxASSERT_MSG(pane
.IsOk(), wxT("Pane window not found"));
3277 if (m_flags
& wxAUI_MGR_TRANSPARENT_DRAG
)
3278 pane
.frame
->SetTransparent(150);
3281 void wxAuiManager
::OnFloatingPaneMoving(wxWindow
* wnd
, wxDirection dir
)
3283 // try to find the pane
3284 wxAuiPaneInfo
& pane
= GetPane(wnd
);
3285 wxASSERT_MSG(pane
.IsOk(), wxT("Pane window not found"));
3287 wxPoint pt
= ::wxGetMousePosition();
3290 // Adapt pt to direction
3293 // move to pane's upper border
3295 pos
= wnd
->ClientToScreen( pos
);
3297 // and some more pixels for the title bar
3302 // move to pane's left border
3304 pos
= wnd
->ClientToScreen( pos
);
3309 // move to pane's right border
3310 wxPoint
pos( wnd
->GetSize().x
, 0 );
3311 pos
= wnd
->ClientToScreen( pos
);
3316 // move to pane's bottom border
3317 wxPoint
pos( 0, wnd
->GetSize().y
);
3318 pos
= wnd
->ClientToScreen( pos
);
3325 wxPoint client_pt
= m_frame
->ScreenToClient(pt
);
3327 // calculate the offset from the upper left-hand corner
3328 // of the frame to the mouse pointer
3329 wxPoint frame_pos
= pane
.frame
->GetPosition();
3330 wxPoint
action_offset(pt
.x
-frame_pos
.x
, pt
.y
-frame_pos
.y
);
3332 // no hint for toolbar floating windows
3333 if (pane
.IsToolbar() && m_action
== actionDragFloatingPane
)
3335 if (m_action
== actionDragFloatingPane
)
3337 wxAuiDockInfoArray docks
;
3338 wxAuiPaneInfoArray panes
;
3339 wxAuiDockUIPartArray uiparts
;
3340 wxAuiPaneInfo hint
= pane
;
3342 CopyDocksAndPanes(docks
, panes
, m_docks
, m_panes
);
3344 // find out where the new pane would be
3345 if (!DoDrop(docks
, panes
, hint
, client_pt
))
3347 if (hint
.IsFloating())
3351 m_action
= actionDragToolbarPane
;
3352 m_action_window
= pane
.window
;
3361 // if a key modifier is pressed while dragging the frame,
3362 // don't dock the window
3363 if (wxGetKeyState(WXK_CONTROL
) || wxGetKeyState(WXK_ALT
))
3370 DrawHintRect(wnd
, client_pt
, action_offset
);
3373 // this cleans up some screen artifacts that are caused on GTK because
3374 // we aren't getting the exact size of the window (see comment
3384 void wxAuiManager
::OnFloatingPaneMoved(wxWindow
* wnd
, wxDirection dir
)
3386 // try to find the pane
3387 wxAuiPaneInfo
& pane
= GetPane(wnd
);
3388 wxASSERT_MSG(pane
.IsOk(), wxT("Pane window not found"));
3390 wxPoint pt
= ::wxGetMousePosition();
3393 // Adapt pt to direction
3396 // move to pane's upper border
3398 pos
= wnd
->ClientToScreen( pos
);
3400 // and some more pixels for the title bar
3405 // move to pane's left border
3407 pos
= wnd
->ClientToScreen( pos
);
3412 // move to pane's right border
3413 wxPoint
pos( wnd
->GetSize().x
, 0 );
3414 pos
= wnd
->ClientToScreen( pos
);
3419 // move to pane's bottom border
3420 wxPoint
pos( 0, wnd
->GetSize().y
);
3421 pos
= wnd
->ClientToScreen( pos
);
3428 wxPoint client_pt
= m_frame
->ScreenToClient(pt
);
3430 // calculate the offset from the upper left-hand corner
3431 // of the frame to the mouse pointer
3432 wxPoint frame_pos
= pane
.frame
->GetPosition();
3433 wxPoint
action_offset(pt
.x
-frame_pos
.x
, pt
.y
-frame_pos
.y
);
3436 // if a key modifier is pressed while dragging the frame,
3437 // don't dock the window
3438 if (!wxGetKeyState(WXK_CONTROL
) && !wxGetKeyState(WXK_ALT
))
3440 // do the drop calculation
3441 DoDrop(m_docks
, m_panes
, pane
, client_pt
, action_offset
);
3444 // if the pane is still floating, update it's floating
3445 // position (that we store)
3446 if (pane
.IsFloating())
3448 pane
.floating_pos
= pane
.frame
->GetPosition();
3450 if (m_flags
& wxAUI_MGR_TRANSPARENT_DRAG
)
3451 pane
.frame
->SetTransparent(255);
3453 else if (m_has_maximized
)
3455 RestoreMaximizedPane();
3463 void wxAuiManager
::OnFloatingPaneResized(wxWindow
* wnd
, const wxSize
& size
)
3465 // try to find the pane
3466 wxAuiPaneInfo
& pane
= GetPane(wnd
);
3467 wxASSERT_MSG(pane
.IsOk(), wxT("Pane window not found"));
3469 pane
.floating_size
= size
;
3473 void wxAuiManager
::OnFloatingPaneClosed(wxWindow
* wnd
, wxCloseEvent
& evt
)
3475 // try to find the pane
3476 wxAuiPaneInfo
& pane
= GetPane(wnd
);
3477 wxASSERT_MSG(pane
.IsOk(), wxT("Pane window not found"));
3480 // fire pane close event
3481 wxAuiManagerEvent
e(wxEVT_AUI_PANE_CLOSE
);
3483 e
.SetCanVeto(evt
.CanVeto());
3499 void wxAuiManager
::OnFloatingPaneActivated(wxWindow
* wnd
)
3501 if (GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE
)
3503 // try to find the pane
3504 wxASSERT_MSG(GetPane(wnd
).IsOk(), wxT("Pane window not found"));
3506 SetActivePane(m_panes
, wnd
);
3511 // OnRender() draws all of the pane captions, sashes,
3512 // backgrounds, captions, grippers, pane borders and buttons.
3513 // It renders the entire user interface.
3515 void wxAuiManager
::OnRender(wxAuiManagerEvent
& evt
)
3517 wxDC
* dc
= evt
.GetDC();
3523 for (i
= 0, part_count
= m_uiparts
.GetCount();
3524 i
< part_count
; ++i
)
3526 wxAuiDockUIPart
& part
= m_uiparts
.Item(i
);
3528 // don't draw hidden pane items
3529 if (part
.sizer_item
&& !part
.sizer_item
->IsShown())
3534 case wxAuiDockUIPart
::typeDockSizer
:
3535 case wxAuiDockUIPart
::typePaneSizer
:
3536 m_art
->DrawSash(*dc
, m_frame
, part
.orientation
, part
.rect
);
3538 case wxAuiDockUIPart
::typeBackground
:
3539 m_art
->DrawBackground(*dc
, m_frame
, part
.orientation
, part
.rect
);
3541 case wxAuiDockUIPart
::typeCaption
:
3542 m_art
->DrawCaption(*dc
, m_frame
, part
.pane
->caption
, part
.rect
, *part
.pane
);
3544 case wxAuiDockUIPart
::typeGripper
:
3545 m_art
->DrawGripper(*dc
, m_frame
, part
.rect
, *part
.pane
);
3547 case wxAuiDockUIPart
::typePaneBorder
:
3548 m_art
->DrawBorder(*dc
, m_frame
, part
.rect
, *part
.pane
);
3550 case wxAuiDockUIPart
::typePaneButton
:
3551 m_art
->DrawPaneButton(*dc
, m_frame
, part
.button
->button_id
,
3552 wxAUI_BUTTON_STATE_NORMAL
, part
.rect
, *part
.pane
);
3559 // Render() fire a render event, which is normally handled by
3560 // wxAuiManager::OnRender(). This allows the render function to
3561 // be overridden via the render event. This can be useful for paintin
3562 // custom graphics in the main window. Default behavior can be
3563 // invoked in the overridden function by calling OnRender()
3565 void wxAuiManager
::Render(wxDC
* dc
)
3567 wxAuiManagerEvent
e(wxEVT_AUI_RENDER
);
3573 void wxAuiManager
::Repaint(wxDC
* dc
)
3578 m_frame
->Refresh() ;
3584 m_frame
->GetClientSize(&w
, &h
);
3586 // figure out which dc to use; if one
3587 // has been specified, use it, otherwise
3589 wxClientDC
* client_dc
= NULL
;
3592 client_dc
= new wxClientDC(m_frame
);
3596 // if the frame has a toolbar, the client area
3597 // origin will not be (0,0).
3598 wxPoint pt
= m_frame
->GetClientAreaOrigin();
3599 if (pt
.x
!= 0 || pt
.y
!= 0)
3600 dc
->SetDeviceOrigin(pt
.x
, pt
.y
);
3602 // render all the items
3605 // if we created a client_dc, delete it
3610 void wxAuiManager
::OnPaint(wxPaintEvent
& WXUNUSED(event
))
3612 wxPaintDC
dc(m_frame
);
3616 void wxAuiManager
::OnEraseBackground(wxEraseEvent
& event
)
3625 void wxAuiManager
::OnSize(wxSizeEvent
& event
)
3633 if (m_frame
->IsKindOf(CLASSINFO(wxMDIParentFrame
)))
3635 // for MDI parent frames, this event must not
3636 // be "skipped". In other words, the parent frame
3637 // must not be allowed to resize the client window
3638 // after we are finished processing sizing changes
3646 void wxAuiManager
::OnFindManager(wxAuiManagerEvent
& evt
)
3648 // get the window we are managing, if none, return NULL
3649 wxWindow
* window
= GetManagedWindow();
3652 evt
.SetManager(NULL
);
3656 // if we are managing a child frame, get the 'real' manager
3657 if (window
->IsKindOf(CLASSINFO(wxAuiFloatingFrame
)))
3659 wxAuiFloatingFrame
* float_frame
= static_cast<wxAuiFloatingFrame
*>(window
);
3660 evt
.SetManager(float_frame
->GetOwnerManager());
3664 // return pointer to ourself
3665 evt
.SetManager(this);
3668 void wxAuiManager
::OnSetCursor(wxSetCursorEvent
& event
)
3671 wxAuiDockUIPart
* part
= HitTest(event
.GetX(), event
.GetY());
3672 wxCursor cursor
= wxNullCursor
;
3676 if (part
->type
== wxAuiDockUIPart
::typeDockSizer
||
3677 part
->type
== wxAuiDockUIPart
::typePaneSizer
)
3679 // a dock may not be resized if it has a single
3680 // pane which is not resizable
3681 if (part
->type
== wxAuiDockUIPart
::typeDockSizer
&& part
->dock
&&
3682 part
->dock
->panes
.GetCount() == 1 &&
3683 part
->dock
->panes
.Item(0)->IsFixed())
3686 // panes that may not be resized do not get a sizing cursor
3687 if (part
->pane
&& part
->pane
->IsFixed())
3690 if (part
->orientation
== wxVERTICAL
)
3691 cursor
= wxCursor(wxCURSOR_SIZEWE
);
3693 cursor
= wxCursor(wxCURSOR_SIZENS
);
3695 else if (part
->type
== wxAuiDockUIPart
::typeGripper
)
3697 cursor
= wxCursor(wxCURSOR_SIZING
);
3701 event
.SetCursor(cursor
);
3706 void wxAuiManager
::UpdateButtonOnScreen(wxAuiDockUIPart
* button_ui_part
,
3707 const wxMouseEvent
& event
)
3709 wxAuiDockUIPart
* hit_test
= HitTest(event
.GetX(), event
.GetY());
3710 if (!hit_test
|| !button_ui_part
)
3713 int state
= wxAUI_BUTTON_STATE_NORMAL
;
3715 if (hit_test
== button_ui_part
)
3717 if (event
.LeftDown())
3718 state
= wxAUI_BUTTON_STATE_PRESSED
;
3720 state
= wxAUI_BUTTON_STATE_HOVER
;
3724 if (event
.LeftDown())
3725 state
= wxAUI_BUTTON_STATE_HOVER
;
3728 // now repaint the button with hover state
3729 wxClientDC
cdc(m_frame
);
3731 // if the frame has a toolbar, the client area
3732 // origin will not be (0,0).
3733 wxPoint pt
= m_frame
->GetClientAreaOrigin();
3734 if (pt
.x
!= 0 || pt
.y
!= 0)
3735 cdc
.SetDeviceOrigin(pt
.x
, pt
.y
);
3739 m_art
->DrawPaneButton(cdc
, m_frame
,
3740 button_ui_part
->button
->button_id
,
3742 button_ui_part
->rect
,
3747 void wxAuiManager
::OnLeftDown(wxMouseEvent
& event
)
3749 wxAuiDockUIPart
* part
= HitTest(event
.GetX(), event
.GetY());
3752 if (part
->type
== wxAuiDockUIPart
::typeDockSizer
||
3753 part
->type
== wxAuiDockUIPart
::typePaneSizer
)
3755 if (part
->dock
&& part
->dock
->dock_direction
== wxAUI_DOCK_CENTER
)
3758 // a dock may not be resized if it has a single
3759 // pane which is not resizable
3760 if (part
->type
== wxAuiDockUIPart
::typeDockSizer
&& part
->dock
&&
3761 part
->dock
->panes
.GetCount() == 1 &&
3762 part
->dock
->panes
.Item(0)->IsFixed())
3765 // panes that may not be resized should be ignored here
3766 if (part
->pane
&& part
->pane
->IsFixed())
3769 m_action
= actionResize
;
3770 m_action_part
= part
;
3771 m_action_hintrect
= wxRect();
3772 m_action_start
= wxPoint(event
.m_x
, event
.m_y
);
3773 m_action_offset
= wxPoint(event
.m_x
- part
->rect
.x
,
3774 event
.m_y
- part
->rect
.y
);
3775 m_frame
->CaptureMouse();
3777 else if (part
->type
== wxAuiDockUIPart
::typePaneButton
)
3779 m_action
= actionClickButton
;
3780 m_action_part
= part
;
3781 m_action_start
= wxPoint(event
.m_x
, event
.m_y
);
3782 m_frame
->CaptureMouse();
3784 UpdateButtonOnScreen(part
, event
);
3786 else if (part
->type
== wxAuiDockUIPart
::typeCaption
||
3787 part
->type
== wxAuiDockUIPart
::typeGripper
)
3789 // if we are managing a wxAuiFloatingFrame window, then
3790 // we are an embedded wxAuiManager inside the wxAuiFloatingFrame.
3791 // We want to initiate a toolbar drag in our owner manager
3792 wxWindow
* managed_wnd
= GetManagedWindow();
3795 part
->pane
->window
&&
3797 managed_wnd
->IsKindOf(CLASSINFO(wxAuiFloatingFrame
)))
3799 wxAuiFloatingFrame
* floating_frame
= (wxAuiFloatingFrame
*)managed_wnd
;
3800 wxAuiManager
* owner_mgr
= floating_frame
->GetOwnerManager();
3801 owner_mgr
->StartPaneDrag(part
->pane
->window
,
3802 wxPoint(event
.m_x
- part
->rect
.x
,
3803 event
.m_y
- part
->rect
.y
));
3809 if (part
->dock
&& part
->dock
->dock_direction
== wxAUI_DOCK_CENTER
)
3812 if (GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE
)
3814 // set the caption as active
3815 SetActivePane(m_panes
, part
->pane
->window
);
3819 m_action
= actionClickCaption
;
3820 m_action_part
= part
;
3821 m_action_start
= wxPoint(event
.m_x
, event
.m_y
);
3822 m_action_offset
= wxPoint(event
.m_x
- part
->rect
.x
,
3823 event
.m_y
- part
->rect
.y
);
3824 m_frame
->CaptureMouse();
3844 void wxAuiManager
::OnLeftUp(wxMouseEvent
& event
)
3846 if (m_action
== actionResize
)
3848 m_frame
->ReleaseMouse();
3850 // get rid of the hint rectangle
3852 DrawResizeHint(dc
, m_action_hintrect
);
3854 // resize the dock or the pane
3855 if (m_action_part
&& m_action_part
->type
==wxAuiDockUIPart
::typeDockSizer
)
3857 wxRect
& rect
= m_action_part
->dock
->rect
;
3859 wxPoint
new_pos(event
.m_x
- m_action_offset
.x
,
3860 event
.m_y
- m_action_offset
.y
);
3862 switch (m_action_part
->dock
->dock_direction
)
3864 case wxAUI_DOCK_LEFT
:
3865 m_action_part
->dock
->size
= new_pos
.x
- rect
.x
;
3867 case wxAUI_DOCK_TOP
:
3868 m_action_part
->dock
->size
= new_pos
.y
- rect
.y
;
3870 case wxAUI_DOCK_RIGHT
:
3871 m_action_part
->dock
->size
= rect
.x
+ rect
.width
-
3872 new_pos
.x
- m_action_part
->rect
.GetWidth();
3874 case wxAUI_DOCK_BOTTOM
:
3875 m_action_part
->dock
->size
= rect
.y
+ rect
.height
-
3876 new_pos
.y
- m_action_part
->rect
.GetHeight();
3883 else if (m_action_part
&&
3884 m_action_part
->type
== wxAuiDockUIPart
::typePaneSizer
)
3886 wxAuiDockInfo
& dock
= *m_action_part
->dock
;
3887 wxAuiPaneInfo
& pane
= *m_action_part
->pane
;
3889 int total_proportion
= 0;
3890 int dock_pixels
= 0;
3891 int new_pixsize
= 0;
3893 int caption_size
= m_art
->GetMetric(wxAUI_DOCKART_CAPTION_SIZE
);
3894 int pane_border_size
= m_art
->GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE
);
3895 int sash_size
= m_art
->GetMetric(wxAUI_DOCKART_SASH_SIZE
);
3897 wxPoint
new_pos(event
.m_x
- m_action_offset
.x
,
3898 event
.m_y
- m_action_offset
.y
);
3900 // determine the pane rectangle by getting the pane part
3901 wxAuiDockUIPart
* pane_part
= GetPanePart(pane
.window
);
3902 wxASSERT_MSG(pane_part
,
3903 wxT("Pane border part not found -- shouldn't happen"));
3905 // determine the new pixel size that the user wants;
3906 // this will help us recalculate the pane's proportion
3907 if (dock
.IsHorizontal())
3908 new_pixsize
= new_pos
.x
- pane_part
->rect
.x
;
3910 new_pixsize
= new_pos
.y
- pane_part
->rect
.y
;
3912 // determine the size of the dock, based on orientation
3913 if (dock
.IsHorizontal())
3914 dock_pixels
= dock
.rect
.GetWidth();
3916 dock_pixels
= dock
.rect
.GetHeight();
3918 // determine the total proportion of all resizable panes,
3919 // and the total size of the dock minus the size of all
3921 int i
, dock_pane_count
= dock
.panes
.GetCount();
3922 int pane_position
= -1;
3923 for (i
= 0; i
< dock_pane_count
; ++i
)
3925 wxAuiPaneInfo
& p
= *dock
.panes
.Item(i
);
3926 if (p
.window
== pane
.window
)
3929 // while we're at it, subtract the pane sash
3930 // width from the dock width, because this would
3931 // skew our proportion calculations
3933 dock_pixels
-= sash_size
;
3935 // also, the whole size (including decorations) of
3936 // all fixed panes must also be subtracted, because they
3937 // are not part of the proportion calculation
3940 if (dock
.IsHorizontal())
3941 dock_pixels
-= p
.best_size
.x
;
3943 dock_pixels
-= p
.best_size
.y
;
3947 total_proportion
+= p
.dock_proportion
;
3951 // find a pane in our dock to 'steal' space from or to 'give'
3952 // space to -- this is essentially what is done when a pane is
3953 // resized; the pane should usually be the first non-fixed pane
3954 // to the right of the action pane
3955 int borrow_pane
= -1;
3956 for (i
= pane_position
+1; i
< dock_pane_count
; ++i
)
3958 wxAuiPaneInfo
& p
= *dock
.panes
.Item(i
);
3967 // demand that the pane being resized is found in this dock
3968 // (this assert really never should be raised)
3969 wxASSERT_MSG(pane_position
!= -1, wxT("Pane not found in dock"));
3971 // prevent division by zero
3972 if (dock_pixels
== 0 || total_proportion
== 0 || borrow_pane
== -1)
3974 m_action
= actionNone
;
3978 // calculate the new proportion of the pane
3979 int new_proportion
= (new_pixsize
*total_proportion
)/dock_pixels
;
3981 // default minimum size
3984 // check against the pane's minimum size, if specified. please note
3985 // that this is not enough to ensure that the minimum size will
3986 // not be violated, because the whole frame might later be shrunk,
3987 // causing the size of the pane to violate it's minimum size
3988 if (pane
.min_size
.IsFullySpecified())
3992 if (pane
.HasBorder())
3993 min_size
+= (pane_border_size
*2);
3995 // calculate minimum size with decorations (border,caption)
3996 if (pane_part
->orientation
== wxVERTICAL
)
3998 min_size
+= pane
.min_size
.y
;
3999 if (pane
.HasCaption())
4000 min_size
+= caption_size
;
4004 min_size
+= pane
.min_size
.x
;
4009 // for some reason, an arithmatic error somewhere is causing
4010 // the proportion calculations to always be off by 1 pixel;
4011 // for now we will add the 1 pixel on, but we really should
4012 // determine what's causing this.
4015 int min_proportion
= (min_size
*total_proportion
)/dock_pixels
;
4017 if (new_proportion
< min_proportion
)
4018 new_proportion
= min_proportion
;
4022 int prop_diff
= new_proportion
- pane
.dock_proportion
;
4024 // borrow the space from our neighbor pane to the
4025 // right or bottom (depending on orientation)
4026 dock
.panes
.Item(borrow_pane
)->dock_proportion
-= prop_diff
;
4027 pane
.dock_proportion
= new_proportion
;
4034 else if (m_action
== actionClickButton
)
4036 m_hover_button
= NULL
;
4037 m_frame
->ReleaseMouse();
4038 UpdateButtonOnScreen(m_action_part
, event
);
4040 // make sure we're still over the item that was originally clicked
4041 if (m_action_part
== HitTest(event
.GetX(), event
.GetY()))
4043 // fire button-click event
4044 wxAuiManagerEvent
e(wxEVT_AUI_PANE_BUTTON
);
4046 e
.SetPane(m_action_part
->pane
);
4047 e
.SetButton(m_action_part
->button
->button_id
);
4051 else if (m_action
== actionClickCaption
)
4053 m_frame
->ReleaseMouse();
4055 else if (m_action
== actionDragFloatingPane
)
4057 m_frame
->ReleaseMouse();
4059 else if (m_action
== actionDragToolbarPane
)
4061 m_frame
->ReleaseMouse();
4063 wxAuiPaneInfo
& pane
= GetPane(m_action_window
);
4064 wxASSERT_MSG(pane
.IsOk(), wxT("Pane window not found"));
4066 // save the new positions
4067 wxAuiDockInfoPtrArray docks
;
4068 FindDocks(m_docks
, pane
.dock_direction
,
4069 pane
.dock_layer
, pane
.dock_row
, docks
);
4070 if (docks
.GetCount() == 1)
4072 wxAuiDockInfo
& dock
= *docks
.Item(0);
4074 wxArrayInt pane_positions
, pane_sizes
;
4075 GetPanePositionsAndSizes(dock
, pane_positions
, pane_sizes
);
4077 int i
, dock_pane_count
= dock
.panes
.GetCount();
4078 for (i
= 0; i
< dock_pane_count
; ++i
)
4079 dock
.panes
.Item(i
)->dock_pos
= pane_positions
[i
];
4082 pane
.state
&= ~wxAuiPaneInfo
::actionPane
;
4090 m_action
= actionNone
;
4091 m_last_mouse_move
= wxPoint(); // see comment in OnMotion()
4095 void wxAuiManager
::OnMotion(wxMouseEvent
& event
)
4097 // sometimes when Update() is called from inside this method,
4098 // a spurious mouse move event is generated; this check will make
4099 // sure that only real mouse moves will get anywhere in this method;
4100 // this appears to be a bug somewhere, and I don't know where the
4101 // mouse move event is being generated. only verified on MSW
4103 wxPoint mouse_pos
= event
.GetPosition();
4104 if (m_last_mouse_move
== mouse_pos
)
4106 m_last_mouse_move
= mouse_pos
;
4109 if (m_action
== actionResize
)
4111 wxPoint pos
= m_action_part
->rect
.GetPosition();
4112 if (m_action_part
->orientation
== wxHORIZONTAL
)
4113 pos
.y
= wxMax(0, event
.m_y
- m_action_offset
.y
);
4115 pos
.x
= wxMax(0, event
.m_x
- m_action_offset
.x
);
4117 wxRect
rect(m_frame
->ClientToScreen(pos
),
4118 m_action_part
->rect
.GetSize());
4121 if (!m_action_hintrect
.IsEmpty())
4122 DrawResizeHint(dc
, m_action_hintrect
);
4123 DrawResizeHint(dc
, rect
);
4124 m_action_hintrect
= rect
;
4126 else if (m_action
== actionClickCaption
)
4128 int drag_x_threshold
= wxSystemSettings
::GetMetric(wxSYS_DRAG_X
);
4129 int drag_y_threshold
= wxSystemSettings
::GetMetric(wxSYS_DRAG_Y
);
4131 // caption has been clicked. we need to check if the mouse
4132 // is now being dragged. if it is, we need to change the
4133 // mouse action to 'drag'
4134 if (abs(event
.m_x
- m_action_start
.x
) > drag_x_threshold
||
4135 abs(event
.m_y
- m_action_start
.y
) > drag_y_threshold
)
4137 wxAuiPaneInfo
* pane_info
= m_action_part
->pane
;
4139 if (!pane_info
->IsToolbar())
4141 if ((m_flags
& wxAUI_MGR_ALLOW_FLOATING
) &&
4142 pane_info
->IsFloatable())
4144 m_action
= actionDragFloatingPane
;
4146 // set initial float position
4147 wxPoint pt
= m_frame
->ClientToScreen(event
.GetPosition());
4148 pane_info
->floating_pos
= wxPoint(pt
.x
- m_action_offset
.x
,
4149 pt
.y
- m_action_offset
.y
);
4152 if (pane_info
->IsMaximized())
4153 RestorePane(*pane_info
);
4157 m_action_window
= pane_info
->frame
;
4159 // action offset is used here to make it feel "natural" to the user
4160 // to drag a docked pane and suddenly have it become a floating frame.
4161 // Sometimes, however, the offset where the user clicked on the docked
4162 // caption is bigger than the width of the floating frame itself, so
4163 // in that case we need to set the action offset to a sensible value
4164 wxSize frame_size
= m_action_window
->GetSize();
4165 if (frame_size
.x
<= m_action_offset
.x
)
4166 m_action_offset
.x
= 30;
4171 m_action
= actionDragToolbarPane
;
4172 m_action_window
= pane_info
->window
;
4176 else if (m_action
== actionDragFloatingPane
)
4178 if (m_action_window
)
4180 wxPoint pt
= m_frame
->ClientToScreen(event
.GetPosition());
4181 m_action_window
->Move(pt
.x
- m_action_offset
.x
,
4182 pt
.y
- m_action_offset
.y
);
4185 else if (m_action
== actionDragToolbarPane
)
4187 wxAuiPaneInfo
& pane
= GetPane(m_action_window
);
4188 wxASSERT_MSG(pane
.IsOk(), wxT("Pane window not found"));
4190 pane
.state
|= wxAuiPaneInfo
::actionPane
;
4192 wxPoint pt
= event
.GetPosition();
4193 DoDrop(m_docks
, m_panes
, pane
, pt
, m_action_offset
);
4195 // if DoDrop() decided to float the pane, set up
4196 // the floating pane's initial position
4197 if (pane
.IsFloating())
4199 wxPoint pt
= m_frame
->ClientToScreen(event
.GetPosition());
4200 pane
.floating_pos
= wxPoint(pt
.x
- m_action_offset
.x
,
4201 pt
.y
- m_action_offset
.y
);
4204 // this will do the actiual move operation;
4205 // in the case that the pane has been floated,
4206 // this call will create the floating pane
4207 // and do the reparenting
4210 // if the pane has been floated, change the mouse
4211 // action actionDragFloatingPane so that subsequent
4212 // EVT_MOTION() events will move the floating pane
4213 if (pane
.IsFloating())
4215 pane
.state
&= ~wxAuiPaneInfo
::actionPane
;
4216 m_action
= actionDragFloatingPane
;
4217 m_action_window
= pane
.frame
;
4222 wxAuiDockUIPart
* part
= HitTest(event
.GetX(), event
.GetY());
4223 if (part
&& part
->type
== wxAuiDockUIPart
::typePaneButton
)
4225 if (part
!= m_hover_button
)
4227 // make the old button normal
4230 UpdateButtonOnScreen(m_hover_button
, event
);
4234 // mouse is over a button, so repaint the
4235 // button in hover mode
4236 UpdateButtonOnScreen(part
, event
);
4237 m_hover_button
= part
;
4245 m_hover_button
= NULL
;
4256 void wxAuiManager
::OnLeaveWindow(wxMouseEvent
& WXUNUSED(event
))
4260 m_hover_button
= NULL
;
4265 void wxAuiManager
::OnChildFocus(wxChildFocusEvent
& event
)
4267 // when a child pane has it's focus set, we should change the
4268 // pane's active state to reflect this. (this is only true if
4269 // active panes are allowed by the owner)
4270 if (GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE
)
4272 if (GetPane(event
.GetWindow()).IsOk())
4274 SetActivePane(m_panes
, event
.GetWindow());
4283 // OnPaneButton() is an event handler that is called
4284 // when a pane button has been pressed.
4285 void wxAuiManager
::OnPaneButton(wxAuiManagerEvent
& evt
)
4287 wxASSERT_MSG(evt
.pane
, wxT("Pane Info passed to wxAuiManager::OnPaneButton must be non-null"));
4289 wxAuiPaneInfo
& pane
= *(evt
.pane
);
4291 if (evt
.button
== wxAUI_BUTTON_CLOSE
)
4293 // fire pane close event
4294 wxAuiManagerEvent
e(wxEVT_AUI_PANE_CLOSE
);
4296 e
.SetPane(evt
.pane
);
4305 else if (evt
.button
== wxAUI_BUTTON_MAXIMIZE_RESTORE
&& !pane
.IsMaximized())
4307 // fire pane close event
4308 wxAuiManagerEvent
e(wxEVT_AUI_PANE_MAXIMIZE
);
4310 e
.SetPane(evt
.pane
);
4319 else if (evt
.button
== wxAUI_BUTTON_MAXIMIZE_RESTORE
&& pane
.IsMaximized())
4321 // fire pane close event
4322 wxAuiManagerEvent
e(wxEVT_AUI_PANE_RESTORE
);
4324 e
.SetPane(evt
.pane
);
4333 else if (evt
.button
== wxAUI_BUTTON_PIN
)
4335 if ((m_flags
& wxAUI_MGR_ALLOW_FLOATING
) &&