]> git.saurik.com Git - wxWidgets.git/blob - src/common/toplvcmn.cpp
more efficient implementation of ToAscii/FromAscii in UTF8 build
[wxWidgets.git] / src / common / toplvcmn.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/toplvcmn.cpp
3 // Purpose: common (for all platforms) wxTopLevelWindow functions
4 // Author: Julian Smart, Vadim Zeitlin
5 // Created: 01/02/97
6 // Id: $Id$
7 // Copyright: (c) 1998 Robert Roebling and Julian Smart
8 // Licence: wxWindows licence
9 /////////////////////////////////////////////////////////////////////////////
10
11 // ============================================================================
12 // declarations
13 // ============================================================================
14
15 // ----------------------------------------------------------------------------
16 // headers
17 // ----------------------------------------------------------------------------
18
19 // For compilers that support precompilation, includes "wx.h".
20 #include "wx/wxprec.h"
21
22 #ifdef __BORLANDC__
23 #pragma hdrstop
24 #endif
25
26 #include "wx/toplevel.h"
27
28 #ifndef WX_PRECOMP
29 #include "wx/dcclient.h"
30 #include "wx/app.h"
31 #endif // WX_PRECOMP
32
33 #include "wx/display.h"
34
35 // ----------------------------------------------------------------------------
36 // event table
37 // ----------------------------------------------------------------------------
38
39 BEGIN_EVENT_TABLE(wxTopLevelWindowBase, wxWindow)
40 EVT_CLOSE(wxTopLevelWindowBase::OnCloseWindow)
41 EVT_SIZE(wxTopLevelWindowBase::OnSize)
42 EVT_WINDOW_DESTROY(wxTopLevelWindowBase::OnChildDestroy)
43 END_EVENT_TABLE()
44
45 // ============================================================================
46 // implementation
47 // ============================================================================
48
49 IMPLEMENT_ABSTRACT_CLASS(wxTopLevelWindow, wxWindow)
50
51 // ----------------------------------------------------------------------------
52 // construction/destruction
53 // ----------------------------------------------------------------------------
54
55 wxTopLevelWindowBase::wxTopLevelWindowBase()
56 {
57 // Unlike windows, top level windows are created hidden by default.
58 m_isShown = false;
59 m_winDefault = NULL;
60 m_winTmpDefault = NULL;
61 }
62
63 wxTopLevelWindowBase::~wxTopLevelWindowBase()
64 {
65 // don't let wxTheApp keep any stale pointers to us
66 if ( wxTheApp && wxTheApp->GetTopWindow() == this )
67 wxTheApp->SetTopWindow(NULL);
68
69 wxTopLevelWindows.DeleteObject(this);
70
71 if ( IsLastBeforeExit() )
72 {
73 // no other (important) windows left, quit the app
74 wxTheApp->ExitMainLoop();
75 }
76 }
77
78 bool wxTopLevelWindowBase::Destroy()
79 {
80 // delayed destruction: the frame will be deleted during the next idle
81 // loop iteration
82 if ( !wxPendingDelete.Member(this) )
83 wxPendingDelete.Append(this);
84
85 if (wxTopLevelWindows.GetCount() > 1)
86 {
87 // Hide it immediately. This should
88 // not be done if this TLW is the
89 // only one left since we then would
90 // risk not to get any idle events
91 // at all anymore during which we
92 // could delete any pending events.
93 Hide();
94 }
95
96 return true;
97 }
98
99 bool wxTopLevelWindowBase::IsLastBeforeExit() const
100 {
101 // first of all, automatically exiting the app on last window close can be
102 // completely disabled at wxTheApp level
103 if ( !wxTheApp || !wxTheApp->GetExitOnFrameDelete() )
104 return false;
105
106 wxWindowList::const_iterator i;
107 const wxWindowList::const_iterator end = wxTopLevelWindows.end();
108
109 // then decide whether we should exit at all
110 for ( i = wxTopLevelWindows.begin(); i != end; ++i )
111 {
112 wxTopLevelWindow * const win = wx_static_cast(wxTopLevelWindow *, *i);
113 if ( win->ShouldPreventAppExit() )
114 {
115 // there remains at least one important TLW, don't exit
116 return false;
117 }
118 }
119
120 // if yes, close all the other windows: this could still fail
121 for ( i = wxTopLevelWindows.begin(); i != end; ++i )
122 {
123 // don't close twice the windows which are already marked for deletion
124 wxTopLevelWindow * const win = wx_static_cast(wxTopLevelWindow *, *i);
125 if ( !wxPendingDelete.Member(win) && !win->Close() )
126 {
127 // one of the windows refused to close, don't exit
128 //
129 // NB: of course, by now some other windows could have been already
130 // closed but there is really nothing we can do about it as we
131 // have no way just to ask the window if it can close without
132 // forcing it to do it
133 return false;
134 }
135 }
136
137 return true;
138 }
139
140 // ----------------------------------------------------------------------------
141 // wxTopLevelWindow geometry
142 // ----------------------------------------------------------------------------
143
144 void wxTopLevelWindowBase::SetMinSize(const wxSize& minSize)
145 {
146 SetSizeHints( minSize.x, minSize.y, GetMaxWidth(), GetMaxHeight() );
147 }
148
149 void wxTopLevelWindowBase::SetMaxSize(const wxSize& maxSize)
150 {
151 SetSizeHints( GetMinWidth(), GetMinHeight(), maxSize.x, maxSize.y );
152 }
153
154 // set the min/max size of the window
155 void wxTopLevelWindowBase::DoSetSizeHints(int minW, int minH,
156 int maxW, int maxH,
157 int WXUNUSED(incW), int WXUNUSED(incH))
158 {
159 // setting min width greater than max width leads to infinite loops under
160 // X11 and generally doesn't make any sense, so don't allow it
161 wxCHECK_RET( (minW == wxDefaultCoord || maxW == wxDefaultCoord || minW <= maxW) &&
162 (minH == wxDefaultCoord || maxH == wxDefaultCoord || minH <= maxH),
163 _T("min width/height must be less than max width/height!") );
164
165 m_minWidth = minW;
166 m_maxWidth = maxW;
167 m_minHeight = minH;
168 m_maxHeight = maxH;
169 }
170
171 void wxTopLevelWindowBase::GetRectForTopLevelChildren(int *x, int *y, int *w, int *h)
172 {
173 GetPosition(x,y);
174 GetSize(w,h);
175 }
176
177 /* static */
178 wxSize wxTopLevelWindowBase::GetDefaultSize()
179 {
180 wxSize size = wxGetClientDisplayRect().GetSize();
181
182 // create proportionally bigger windows on small screens
183 if ( size.x >= 1024 )
184 size.x = 400;
185 else if ( size.x >= 800 )
186 size.x = 300;
187 else if ( size.x >= 320 )
188 size.x = 240;
189
190 if ( size.y >= 768 )
191 size.y = 250;
192 else if ( size.y > 200 )
193 {
194 size.y *= 2;
195 size.y /= 3;
196 }
197
198 return size;
199 }
200
201 void wxTopLevelWindowBase::DoCentre(int dir)
202 {
203 // on some platforms centering top level windows is impossible
204 // because they are always maximized by guidelines or limitations
205 if(IsAlwaysMaximized())
206 return;
207
208 // we need the display rect anyhow so store it first: notice that we should
209 // be centered on the same display as our parent window, the display of
210 // this window itself is not really defined yet
211 int nDisplay = wxDisplay::GetFromWindow(GetParent() ? GetParent() : this);
212 wxDisplay dpy(nDisplay == wxNOT_FOUND ? 0 : nDisplay);
213 const wxRect rectDisplay(dpy.GetClientArea());
214
215 // what should we centre this window on?
216 wxRect rectParent;
217 if ( !(dir & wxCENTRE_ON_SCREEN) && GetParent() )
218 {
219 // centre on parent window: notice that we need screen coordinates for
220 // positioning this TLW
221 rectParent = GetParent()->GetScreenRect();
222
223 // if the parent is entirely off screen (happens at least with MDI
224 // parent frame under Mac but could happen elsewhere too if the frame
225 // was hidden/moved away for some reason), don't use it as otherwise
226 // this window wouldn't be visible at all
227 if ( !rectDisplay.Contains(rectParent.GetTopLeft()) &&
228 !rectParent.Contains(rectParent.GetBottomRight()) )
229 {
230 // this is enough to make IsEmpty() test below pass
231 rectParent.width = 0;
232 }
233 }
234
235 if ( rectParent.IsEmpty() )
236 {
237 // we were explicitly asked to centre this window on the entire screen
238 // or if we have no parent anyhow and so can't centre on it
239 rectParent = rectDisplay;
240 }
241
242 // centering maximized window on screen is no-op
243 if((rectParent == rectDisplay) && IsMaximized())
244 return;
245
246 // the new window rect candidate
247 wxRect rect = GetRect().CentreIn(rectParent, dir);
248
249 // we don't want to place the window off screen if Centre() is called as
250 // this is (almost?) never wanted and it would be very difficult to prevent
251 // it from happening from the user code if we didn't check for it here
252 if ( !rectDisplay.Contains(rect.GetTopLeft()) )
253 {
254 // move the window just enough to make the corner visible
255 int dx = rectDisplay.GetLeft() - rect.GetLeft();
256 int dy = rectDisplay.GetTop() - rect.GetTop();
257 rect.Offset(dx > 0 ? dx : 0, dy > 0 ? dy : 0);
258 }
259
260 if ( !rectDisplay.Contains(rect.GetBottomRight()) )
261 {
262 // do the same for this corner too
263 int dx = rectDisplay.GetRight() - rect.GetRight();
264 int dy = rectDisplay.GetBottom() - rect.GetBottom();
265 rect.Offset(dx < 0 ? dx : 0, dy < 0 ? dy : 0);
266 }
267
268 // the window top left and bottom right corner are both visible now and
269 // although the window might still be not entirely on screen (with 2
270 // staggered displays for example) we wouldn't be able to improve the
271 // layout much in such case, so we stop here
272
273 // -1 could be valid coordinate here if there are several displays
274 SetSize(rect, wxSIZE_ALLOW_MINUS_ONE);
275 }
276
277 // ----------------------------------------------------------------------------
278 // wxTopLevelWindow size management: we exclude the areas taken by
279 // menu/status/toolbars from the client area, so the client area is what's
280 // really available for the frame contents
281 // ----------------------------------------------------------------------------
282
283 void wxTopLevelWindowBase::DoScreenToClient(int *x, int *y) const
284 {
285 wxWindow::DoScreenToClient(x, y);
286
287 // translate the wxWindow client coords to our client coords
288 wxPoint pt(GetClientAreaOrigin());
289 if ( x )
290 *x -= pt.x;
291 if ( y )
292 *y -= pt.y;
293 }
294
295 void wxTopLevelWindowBase::DoClientToScreen(int *x, int *y) const
296 {
297 // our client area origin (0, 0) may be really something like (0, 30) for
298 // wxWindow if we have a toolbar, account for it before translating
299 wxPoint pt(GetClientAreaOrigin());
300 if ( x )
301 *x += pt.x;
302 if ( y )
303 *y += pt.y;
304
305 wxWindow::DoClientToScreen(x, y);
306 }
307
308 bool wxTopLevelWindowBase::IsAlwaysMaximized() const
309 {
310 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
311 return true;
312 #else
313 return false;
314 #endif
315 }
316
317 // ----------------------------------------------------------------------------
318 // icons
319 // ----------------------------------------------------------------------------
320
321 wxIcon wxTopLevelWindowBase::GetIcon() const
322 {
323 return m_icons.IsEmpty() ? wxIcon() : m_icons.GetIcon( -1 );
324 }
325
326 void wxTopLevelWindowBase::SetIcon(const wxIcon& icon)
327 {
328 // passing wxNullIcon to SetIcon() is possible (it means that we shouldn't
329 // have any icon), but adding an invalid icon to wxIconBundle is not
330 wxIconBundle icons;
331 if ( icon.Ok() )
332 icons.AddIcon(icon);
333
334 SetIcons(icons);
335 }
336
337 // ----------------------------------------------------------------------------
338 // event handlers
339 // ----------------------------------------------------------------------------
340
341 // default resizing behaviour - if only ONE subwindow, resize to fill the
342 // whole client area
343 void wxTopLevelWindowBase::DoLayout()
344 {
345 // if we're using constraints or sizers - do use them
346 if ( GetAutoLayout() )
347 {
348 Layout();
349 }
350 else
351 {
352 // do we have _exactly_ one child?
353 wxWindow *child = (wxWindow *)NULL;
354 for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
355 node;
356 node = node->GetNext() )
357 {
358 wxWindow *win = node->GetData();
359
360 // exclude top level and managed windows (status bar isn't
361 // currently in the children list except under wxMac anyhow, but
362 // it makes no harm to test for it)
363 if ( !win->IsTopLevel() && !IsOneOfBars(win) )
364 {
365 if ( child )
366 {
367 return; // it's our second subwindow - nothing to do
368 }
369
370 child = win;
371 }
372 }
373
374 // do we have any children at all?
375 if ( child && child->IsShown() )
376 {
377 // exactly one child - set it's size to fill the whole frame
378 int clientW, clientH;
379 DoGetClientSize(&clientW, &clientH);
380
381 child->SetSize(0, 0, clientW, clientH);
382 }
383 }
384 }
385
386 // The default implementation for the close window event.
387 void wxTopLevelWindowBase::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
388 {
389 Destroy();
390 }
391
392 void wxTopLevelWindowBase::OnChildDestroy(wxWindowDestroyEvent& event)
393 {
394 event.Skip();
395
396 wxWindow * const win = event.GetWindow();
397 if ( win == m_winDefault )
398 m_winDefault = NULL;
399 if ( win == m_winTmpDefault )
400 m_winTmpDefault = NULL;
401 }
402
403 bool wxTopLevelWindowBase::SendIconizeEvent(bool iconized)
404 {
405 wxIconizeEvent event(GetId(), iconized);
406 event.SetEventObject(this);
407
408 return GetEventHandler()->ProcessEvent(event);
409 }
410
411 // do the window-specific processing after processing the update event
412 void wxTopLevelWindowBase::DoUpdateWindowUI(wxUpdateUIEvent& event)
413 {
414 // call inherited, but skip the wxControl's version, and call directly the
415 // wxWindow's one instead, because the only reason why we are overriding this
416 // function is that we want to use SetTitle() instead of wxControl::SetLabel()
417 wxWindowBase::DoUpdateWindowUI(event);
418
419 // update title
420 if ( event.GetSetText() )
421 {
422 if ( event.GetText() != GetTitle() )
423 SetTitle(event.GetText());
424 }
425 }
426
427 void wxTopLevelWindowBase::RequestUserAttention(int WXUNUSED(flags))
428 {
429 // it's probably better than do nothing, isn't it?
430 Raise();
431 }
432
433 void wxTopLevelWindowBase::RemoveChild(wxWindowBase *child)
434 {
435 if ( child == m_winDefault )
436 m_winDefault = NULL;
437
438 if ( child == m_winTmpDefault )
439 m_winTmpDefault = NULL;
440
441 wxWindow::RemoveChild(child);
442 }