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 }