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