1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: Implements a simple layout algorithm, plus
4 // wxSashLayoutWindow which is an example of a window with
5 // layout-awareness (via event handlers). This is suited to
6 // IDE-style window layout.
7 // Author: Julian Smart
11 // Copyright: (c) Julian Smart
12 // Licence: wxWindows licence
13 /////////////////////////////////////////////////////////////////////////////
16 #pragma implementation "laywin.h"
19 // For compilers that support precompilation, includes "wx/wx.h".
20 #include "wx/wxprec.h"
31 #include "wx/laywin.h"
33 IMPLEMENT_DYNAMIC_CLASS(wxQueryLayoutInfoEvent
, wxEvent
)
34 IMPLEMENT_DYNAMIC_CLASS(wxCalculateLayoutEvent
, wxEvent
)
36 DEFINE_EVENT_TYPE(wxEVT_QUERY_LAYOUT_INFO
)
37 DEFINE_EVENT_TYPE(wxEVT_CALCULATE_LAYOUT
)
40 IMPLEMENT_CLASS(wxSashLayoutWindow
, wxSashWindow
)
42 BEGIN_EVENT_TABLE(wxSashLayoutWindow
, wxSashWindow
)
43 EVT_CALCULATE_LAYOUT(wxSashLayoutWindow::OnCalculateLayout
)
44 EVT_QUERY_LAYOUT_INFO(wxSashLayoutWindow::OnQueryLayoutInfo
)
47 bool wxSashLayoutWindow::Create(wxWindow
*parent
, wxWindowID id
, const wxPoint
& pos
,
48 const wxSize
& size
, long style
, const wxString
& name
)
50 return wxSashWindow::Create(parent
, id
, pos
, size
, style
, name
);
53 void wxSashLayoutWindow::Init()
55 m_orientation
= wxLAYOUT_HORIZONTAL
;
56 m_alignment
= wxLAYOUT_TOP
;
59 // This is the function that wxLayoutAlgorithm calls to ascertain the window
61 void wxSashLayoutWindow::OnQueryLayoutInfo(wxQueryLayoutInfoEvent
& event
)
63 // int flags = event.GetFlags();
64 int requestedLength
= event
.GetRequestedLength();
66 event
.SetOrientation(m_orientation
);
67 event
.SetAlignment(m_alignment
);
69 if (m_orientation
== wxLAYOUT_HORIZONTAL
)
70 event
.SetSize(wxSize(requestedLength
, m_defaultSize
.y
));
72 event
.SetSize(wxSize(m_defaultSize
.x
, requestedLength
));
75 // Called by parent to allow window to take a bit out of the
76 // client rectangle, and size itself if not in wxLAYOUT_QUERY mode.
78 void wxSashLayoutWindow::OnCalculateLayout(wxCalculateLayoutEvent
& event
)
80 wxRect
clientSize(event
.GetRect());
82 int flags
= event
.GetFlags();
87 // Let's assume that all windows stretch the full extent of the window in
88 // the direction of that window orientation. This will work for non-docking toolbars,
89 // and the status bar. Note that the windows have to have been created in a certain
90 // order to work, else you might get a left-aligned window going to the bottom
91 // of the window, and the status bar appearing to the right of it. The
92 // status bar would have to be created after or before the toolbar(s).
97 int length
= (GetOrientation() == wxLAYOUT_HORIZONTAL
) ? clientSize
.width
: clientSize
.height
;
98 wxLayoutOrientation orient
= GetOrientation();
100 // We assume that a window that says it's horizontal, wants to be stretched in that
101 // direction. Is this distinction too fine? Do we assume that any horizontal
102 // window needs to be stretched in that direction? Possibly.
103 int whichDimension
= (GetOrientation() == wxLAYOUT_HORIZONTAL
) ? wxLAYOUT_LENGTH_X
: wxLAYOUT_LENGTH_Y
;
105 wxQueryLayoutInfoEvent
infoEvent(GetId());
106 infoEvent
.SetEventObject(this);
107 infoEvent
.SetRequestedLength(length
);
108 infoEvent
.SetFlags(orient
| whichDimension
);
110 if (!GetEventHandler()->ProcessEvent(infoEvent
))
113 wxSize sz
= infoEvent
.GetSize();
115 if (sz
.x
== 0 && sz
.y
== 0) // Assume it's invisible
118 // Now we know the size it wants to be. We wish to decide where to place it, i.e.
120 switch (GetAlignment())
124 thisRect
.x
= clientSize
.x
; thisRect
.y
= clientSize
.y
;
125 thisRect
.width
= sz
.x
; thisRect
.height
= sz
.y
;
126 clientSize
.y
+= thisRect
.height
;
127 clientSize
.height
-= thisRect
.height
;
132 thisRect
.x
= clientSize
.x
; thisRect
.y
= clientSize
.y
;
133 thisRect
.width
= sz
.x
; thisRect
.height
= sz
.y
;
134 clientSize
.x
+= thisRect
.width
;
135 clientSize
.width
-= thisRect
.width
;
140 thisRect
.x
= clientSize
.x
+ (clientSize
.width
- sz
.x
); thisRect
.y
= clientSize
.y
;
141 thisRect
.width
= sz
.x
; thisRect
.height
= sz
.y
;
142 clientSize
.width
-= thisRect
.width
;
145 case wxLAYOUT_BOTTOM
:
147 thisRect
.x
= clientSize
.x
; thisRect
.y
= clientSize
.y
+ (clientSize
.height
- sz
.y
);
148 thisRect
.width
= sz
.x
; thisRect
.height
= sz
.y
;
149 clientSize
.height
-= thisRect
.height
;
159 if ((flags
& wxLAYOUT_QUERY
) == 0)
161 // If not in query mode, resize the window.
162 // TODO: add wxRect& form to wxWindow::SetSize
163 wxSize sz
= GetSize();
164 wxPoint pos
= GetPosition();
165 SetSize(thisRect
.x
, thisRect
.y
, thisRect
.width
, thisRect
.height
);
167 // Make sure the sash is erased when the window is resized
168 if ((pos
.x
!= thisRect
.x
|| pos
.y
!= thisRect
.y
|| sz
.x
!= thisRect
.width
|| sz
.y
!= thisRect
.height
) &&
169 (GetSashVisible(wxSASH_TOP
) || GetSashVisible(wxSASH_RIGHT
) || GetSashVisible(wxSASH_BOTTOM
) || GetSashVisible(wxSASH_LEFT
)))
174 event
.SetRect(clientSize
);
182 // Lays out windows for an MDI frame. The MDI client area gets what's left
184 bool wxLayoutAlgorithm::LayoutMDIFrame(wxMDIParentFrame
* frame
, wxRect
* r
)
187 frame
->GetClientSize(& cw
, & ch
);
189 wxRect
rect(0, 0, cw
, ch
);
193 wxCalculateLayoutEvent event
;
196 wxNode
* node
= frame
->GetChildren().First();
199 wxWindow
* win
= (wxWindow
*) node
->Data();
201 event
.SetId(win
->GetId());
202 event
.SetEventObject(win
);
203 event
.SetFlags(0); // ??
205 win
->GetEventHandler()->ProcessEvent(event
);
210 wxWindow
* clientWindow
= frame
->GetClientWindow();
212 rect
= event
.GetRect();
214 clientWindow
->SetSize(rect
.x
, rect
.y
, rect
.width
, rect
.height
);
219 // Layout algorithm for any window. mainWindow gets what's left over.
220 bool wxLayoutAlgorithm::LayoutWindow(wxWindow
* parent
, wxWindow
* mainWindow
)
222 // Test if the parent is a sash window, and if so,
223 // reduce the available space to allow space for any active edges.
225 int leftMargin
= 0, rightMargin
= 0, topMargin
= 0, bottomMargin
= 0;
227 if (parent
->IsKindOf(CLASSINFO(wxSashWindow
)))
229 wxSashWindow
* sashWindow
= (wxSashWindow
*) parent
;
231 leftMargin
= sashWindow
->GetExtraBorderSize();
232 rightMargin
= sashWindow
->GetExtraBorderSize();
233 topMargin
= sashWindow
->GetExtraBorderSize();
234 bottomMargin
= sashWindow
->GetExtraBorderSize();
236 if (sashWindow
->GetSashVisible(wxSASH_LEFT
))
237 leftMargin
+= sashWindow
->GetDefaultBorderSize();
238 if (sashWindow
->GetSashVisible(wxSASH_RIGHT
))
239 rightMargin
+= sashWindow
->GetDefaultBorderSize();
240 if (sashWindow
->GetSashVisible(wxSASH_TOP
))
241 topMargin
+= sashWindow
->GetDefaultBorderSize();
242 if (sashWindow
->GetSashVisible(wxSASH_BOTTOM
))
243 bottomMargin
+= sashWindow
->GetDefaultBorderSize();
248 parent
->GetClientSize(& cw
, & ch
);
250 wxRect
rect(leftMargin
, topMargin
, cw
- leftMargin
- rightMargin
, ch
- topMargin
- bottomMargin
);
252 wxCalculateLayoutEvent event
;
255 // Find the last layout-aware window, so we can make it fill all remaining
257 wxWindow
* lastAwareWindow
= NULL
;
258 wxNode
* node
= parent
->GetChildren().First();
261 wxWindow
* win
= (wxWindow
*) node
->Data();
265 wxCalculateLayoutEvent
tempEvent(win
->GetId());
266 tempEvent
.SetEventObject(win
);
267 tempEvent
.SetFlags(wxLAYOUT_QUERY
);
268 tempEvent
.SetRect(event
.GetRect());
269 if (win
->GetEventHandler()->ProcessEvent(tempEvent
))
270 lastAwareWindow
= win
;
276 // Now do a dummy run to see if we have any space left for the final window (fail if not)
277 node
= parent
->GetChildren().First();
280 wxWindow
* win
= (wxWindow
*) node
->Data();
282 // If mainWindow is NULL and we're at the last window,
283 // skip this, because we'll simply make it fit the remaining space.
284 if (win
->IsShown() && (win
!= mainWindow
) && (mainWindow
!= NULL
|| win
!= lastAwareWindow
))
286 event
.SetId(win
->GetId());
287 event
.SetEventObject(win
);
288 event
.SetFlags(wxLAYOUT_QUERY
);
290 win
->GetEventHandler()->ProcessEvent(event
);
296 if (event
.GetRect().GetWidth() < 0 || event
.GetRect().GetHeight() < 0)
301 node
= parent
->GetChildren().First();
304 wxWindow
* win
= (wxWindow
*) node
->Data();
306 // If mainWindow is NULL and we're at the last window,
307 // skip this, because we'll simply make it fit the remaining space.
308 if (win
->IsShown() && (win
!= mainWindow
) && (mainWindow
!= NULL
|| win
!= lastAwareWindow
))
310 event
.SetId(win
->GetId());
311 event
.SetEventObject(win
);
312 event
.SetFlags(0); // ??
314 win
->GetEventHandler()->ProcessEvent(event
);
320 rect
= event
.GetRect();
323 mainWindow
->SetSize(rect
.x
, rect
.y
, wxMax(0, rect
.width
), wxMax(0, rect
.height
));
324 else if (lastAwareWindow
)
326 // Fit the remaining space
327 lastAwareWindow
->SetSize(rect
.x
, rect
.y
, wxMax(0, rect
.width
), wxMax(0, rect
.height
));