]> git.saurik.com Git - wxWidgets.git/blob - src/generic/laywin.cpp
compilation fix
[wxWidgets.git] / src / generic / laywin.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: laywin.cpp
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
8 // Modified by:
9 // Created: 04/01/98
10 // RCS-ID: $Id$
11 // Copyright: (c) Julian Smart
12 // Licence: wxWindows licence
13 /////////////////////////////////////////////////////////////////////////////
14
15 #ifdef __GNUG__
16 #pragma implementation "laywin.h"
17 #endif
18
19 // For compilers that support precompilation, includes "wx/wx.h".
20 #include "wx/wxprec.h"
21
22 #ifdef __BORLANDC__
23 #pragma hdrstop
24 #endif
25
26 #ifndef WX_PRECOMP
27 #include "wx/frame.h"
28 #include "wx/mdi.h"
29 #endif
30
31 #include "wx/laywin.h"
32
33 IMPLEMENT_DYNAMIC_CLASS(wxQueryLayoutInfoEvent, wxEvent)
34 IMPLEMENT_DYNAMIC_CLASS(wxCalculateLayoutEvent, wxEvent)
35
36 DEFINE_EVENT_TYPE(wxEVT_QUERY_LAYOUT_INFO)
37 DEFINE_EVENT_TYPE(wxEVT_CALCULATE_LAYOUT)
38
39 #if wxUSE_SASH
40 IMPLEMENT_CLASS(wxSashLayoutWindow, wxSashWindow)
41
42 BEGIN_EVENT_TABLE(wxSashLayoutWindow, wxSashWindow)
43 EVT_CALCULATE_LAYOUT(wxSashLayoutWindow::OnCalculateLayout)
44 EVT_QUERY_LAYOUT_INFO(wxSashLayoutWindow::OnQueryLayoutInfo)
45 END_EVENT_TABLE()
46
47 bool wxSashLayoutWindow::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos,
48 const wxSize& size, long style, const wxString& name)
49 {
50 return wxSashWindow::Create(parent, id, pos, size, style, name);
51 }
52
53 void wxSashLayoutWindow::Init()
54 {
55 m_orientation = wxLAYOUT_HORIZONTAL;
56 m_alignment = wxLAYOUT_TOP;
57 }
58
59 // This is the function that wxLayoutAlgorithm calls to ascertain the window
60 // dimensions.
61 void wxSashLayoutWindow::OnQueryLayoutInfo(wxQueryLayoutInfoEvent& event)
62 {
63 // int flags = event.GetFlags();
64 int requestedLength = event.GetRequestedLength();
65
66 event.SetOrientation(m_orientation);
67 event.SetAlignment(m_alignment);
68
69 if (m_orientation == wxLAYOUT_HORIZONTAL)
70 event.SetSize(wxSize(requestedLength, m_defaultSize.y));
71 else
72 event.SetSize(wxSize(m_defaultSize.x, requestedLength));
73 }
74
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.
77
78 void wxSashLayoutWindow::OnCalculateLayout(wxCalculateLayoutEvent& event)
79 {
80 wxRect clientSize(event.GetRect());
81
82 int flags = event.GetFlags();
83
84 if (!IsShown())
85 return;
86
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).
93
94 wxRect thisRect;
95
96 // Try to stretch
97 int length = (GetOrientation() == wxLAYOUT_HORIZONTAL) ? clientSize.width : clientSize.height;
98 wxLayoutOrientation orient = GetOrientation();
99
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;
104
105 wxQueryLayoutInfoEvent infoEvent(GetId());
106 infoEvent.SetEventObject(this);
107 infoEvent.SetRequestedLength(length);
108 infoEvent.SetFlags(orient | whichDimension);
109
110 if (!GetEventHandler()->ProcessEvent(infoEvent))
111 return;
112
113 wxSize sz = infoEvent.GetSize();
114
115 if (sz.x == 0 && sz.y == 0) // Assume it's invisible
116 return;
117
118 // Now we know the size it wants to be. We wish to decide where to place it, i.e.
119 // how it's aligned.
120 switch (GetAlignment())
121 {
122 case wxLAYOUT_TOP:
123 {
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;
128 break;
129 }
130 case wxLAYOUT_LEFT:
131 {
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;
136 break;
137 }
138 case wxLAYOUT_RIGHT:
139 {
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;
143 break;
144 }
145 case wxLAYOUT_BOTTOM:
146 {
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;
150 break;
151 }
152 case wxLAYOUT_NONE:
153 {
154 break;
155 }
156
157 }
158
159 if ((flags & wxLAYOUT_QUERY) == 0)
160 {
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);
166
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)))
170 Refresh(TRUE);
171
172 }
173
174 event.SetRect(clientSize);
175 }
176 #endif // wxUSE_SASH
177
178 /*
179 * wxLayoutAlgorithm
180 */
181
182 #if wxUSE_MDI_ARCHITECTURE
183
184 // Lays out windows for an MDI frame. The MDI client area gets what's left
185 // over.
186 bool wxLayoutAlgorithm::LayoutMDIFrame(wxMDIParentFrame* frame, wxRect* r)
187 {
188 int cw, ch;
189 frame->GetClientSize(& cw, & ch);
190
191 wxRect rect(0, 0, cw, ch);
192 if (r)
193 rect = * r;
194
195 wxCalculateLayoutEvent event;
196 event.SetRect(rect);
197
198 wxNode* node = frame->GetChildren().First();
199 while (node)
200 {
201 wxWindow* win = (wxWindow*) node->Data();
202
203 event.SetId(win->GetId());
204 event.SetEventObject(win);
205 event.SetFlags(0); // ??
206
207 win->GetEventHandler()->ProcessEvent(event);
208
209 node = node->Next();
210 }
211
212 wxWindow* clientWindow = frame->GetClientWindow();
213
214 rect = event.GetRect();
215
216 clientWindow->SetSize(rect.x, rect.y, rect.width, rect.height);
217
218 return TRUE;
219 }
220
221 #endif // wxUSE_MDI_ARCHITECTURE
222
223 bool wxLayoutAlgorithm::LayoutFrame(wxFrame* frame, wxWindow* mainWindow)
224 {
225 return LayoutWindow(frame, mainWindow);
226 }
227
228 // Layout algorithm for any window. mainWindow gets what's left over.
229 bool wxLayoutAlgorithm::LayoutWindow(wxWindow* parent, wxWindow* mainWindow)
230 {
231 // Test if the parent is a sash window, and if so,
232 // reduce the available space to allow space for any active edges.
233
234 int leftMargin = 0, rightMargin = 0, topMargin = 0, bottomMargin = 0;
235 #if wxUSE_SASH
236 if (parent->IsKindOf(CLASSINFO(wxSashWindow)))
237 {
238 wxSashWindow* sashWindow = (wxSashWindow*) parent;
239
240 leftMargin = sashWindow->GetExtraBorderSize();
241 rightMargin = sashWindow->GetExtraBorderSize();
242 topMargin = sashWindow->GetExtraBorderSize();
243 bottomMargin = sashWindow->GetExtraBorderSize();
244
245 if (sashWindow->GetSashVisible(wxSASH_LEFT))
246 leftMargin += sashWindow->GetDefaultBorderSize();
247 if (sashWindow->GetSashVisible(wxSASH_RIGHT))
248 rightMargin += sashWindow->GetDefaultBorderSize();
249 if (sashWindow->GetSashVisible(wxSASH_TOP))
250 topMargin += sashWindow->GetDefaultBorderSize();
251 if (sashWindow->GetSashVisible(wxSASH_BOTTOM))
252 bottomMargin += sashWindow->GetDefaultBorderSize();
253 }
254 #endif // wxUSE_SASH
255
256 int cw, ch;
257 parent->GetClientSize(& cw, & ch);
258
259 wxRect rect(leftMargin, topMargin, cw - leftMargin - rightMargin, ch - topMargin - bottomMargin);
260
261 wxCalculateLayoutEvent event;
262 event.SetRect(rect);
263
264 // Find the last layout-aware window, so we can make it fill all remaining
265 // space.
266 wxWindow* lastAwareWindow = NULL;
267 wxNode* node = parent->GetChildren().First();
268 while (node)
269 {
270 wxWindow* win = (wxWindow*) node->Data();
271
272 if (win->IsShown())
273 {
274 wxCalculateLayoutEvent tempEvent(win->GetId());
275 tempEvent.SetEventObject(win);
276 tempEvent.SetFlags(wxLAYOUT_QUERY);
277 tempEvent.SetRect(event.GetRect());
278 if (win->GetEventHandler()->ProcessEvent(tempEvent))
279 lastAwareWindow = win;
280 }
281
282 node = node->Next();
283 }
284
285 // Now do a dummy run to see if we have any space left for the final window (fail if not)
286 node = parent->GetChildren().First();
287 while (node)
288 {
289 wxWindow* win = (wxWindow*) node->Data();
290
291 // If mainWindow is NULL and we're at the last window,
292 // skip this, because we'll simply make it fit the remaining space.
293 if (win->IsShown() && (win != mainWindow) && (mainWindow != NULL || win != lastAwareWindow))
294 {
295 event.SetId(win->GetId());
296 event.SetEventObject(win);
297 event.SetFlags(wxLAYOUT_QUERY);
298
299 win->GetEventHandler()->ProcessEvent(event);
300 }
301
302 node = node->Next();
303 }
304
305 if (event.GetRect().GetWidth() < 0 || event.GetRect().GetHeight() < 0)
306 return FALSE;
307
308 event.SetRect(rect);
309
310 node = parent->GetChildren().First();
311 while (node)
312 {
313 wxWindow* win = (wxWindow*) node->Data();
314
315 // If mainWindow is NULL and we're at the last window,
316 // skip this, because we'll simply make it fit the remaining space.
317 if (win->IsShown() && (win != mainWindow) && (mainWindow != NULL || win != lastAwareWindow))
318 {
319 event.SetId(win->GetId());
320 event.SetEventObject(win);
321 event.SetFlags(0); // ??
322
323 win->GetEventHandler()->ProcessEvent(event);
324 }
325
326 node = node->Next();
327 }
328
329 rect = event.GetRect();
330
331 if (mainWindow)
332 mainWindow->SetSize(rect.x, rect.y, wxMax(0, rect.width), wxMax(0, rect.height));
333 else if (lastAwareWindow)
334 {
335 // Fit the remaining space
336 lastAwareWindow->SetSize(rect.x, rect.y, wxMax(0, rect.width), wxMax(0, rect.height));
337 }
338
339 return TRUE;
340 }
341