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