Rename wxWebHistoryItem to wxWebViewHistoryItem.

[wxWidgets.git] / src / common / toplvcmn.cpp

diff --git a/src/common/toplvcmn.cpp b/src/common/toplvcmn.cpp
index 8d262e70b942b64d78dae1dbee4f95ffbae59079..1ce788ef1f3b40907a7240f5e6f33b42f17ec2ba 100644 (file)
--- a/src/common/toplvcmn.cpp
+++ b/src/common/toplvcmn.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        common/toplvcmn.cpp
+// Name:        src/common/toplvcmn.cpp

 // Purpose:     common (for all platforms) wxTopLevelWindow functions
 // Author:      Julian Smart, Vadim Zeitlin
 // Created:     01/02/97
 // Purpose:     common (for all platforms) wxTopLevelWindow functions
 // Author:      Julian Smart, Vadim Zeitlin
 // Created:     01/02/97


@@ -16,10 +16,6 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-    #pragma implementation "toplevelbase.h"
-#endif
-

 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 


@@ -27,12 +23,15 @@
     #pragma hdrstop
 #endif
 
     #pragma hdrstop
 #endif
 

+#include "wx/toplevel.h"
+

 #ifndef WX_PRECOMP
 #ifndef WX_PRECOMP

-    #include "wx/toplevel.h"

     #include "wx/dcclient.h"
     #include "wx/app.h"
 #endif // WX_PRECOMP
 
     #include "wx/dcclient.h"
     #include "wx/app.h"
 #endif // WX_PRECOMP
 

+#include "wx/display.h"
+

 // ----------------------------------------------------------------------------
 // event table
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // event table
 // ----------------------------------------------------------------------------


@@ -46,7 +45,7 @@ END_EVENT_TABLE()
 // implementation
 // ============================================================================
 
 // implementation
 // ============================================================================
 

-IMPLEMENT_DYNAMIC_CLASS(wxTopLevelWindow, wxWindow)
+IMPLEMENT_ABSTRACT_CLASS(wxTopLevelWindow, wxWindow)

 
 // ----------------------------------------------------------------------------
 // construction/destruction
 
 // ----------------------------------------------------------------------------
 // construction/destruction


@@ -64,13 +63,39 @@ wxTopLevelWindowBase::~wxTopLevelWindowBase()
     if ( wxTheApp && wxTheApp->GetTopWindow() == this )
         wxTheApp->SetTopWindow(NULL);
 
     if ( wxTheApp && wxTheApp->GetTopWindow() == this )
         wxTheApp->SetTopWindow(NULL);
 

-    bool shouldExit = IsLastBeforeExit();
-

     wxTopLevelWindows.DeleteObject(this);
 
     wxTopLevelWindows.DeleteObject(this);
 

-    if ( shouldExit )
+    // delete any our top level children which are still pending for deletion
+    // immediately: this could happen if a child (e.g. a temporary dialog
+    // created with this window as parent) was Destroy()'d) while this window
+    // was deleted directly (with delete, or maybe just because it was created
+    // on the stack) immediately afterwards and before the child TLW was really
+    // destroyed -- not destroying it now would leave it alive with a dangling
+    // parent pointer and result in a crash later
+    for ( wxObjectList::iterator i = wxPendingDelete.begin();
+          i != wxPendingDelete.end();
+          )
+    {
+        wxWindow * const win = wxDynamicCast(*i, wxWindow);
+        if ( win && win->GetParent() == this )
+        {
+            wxPendingDelete.erase(i);
+
+            delete win;
+
+            // deleting it invalidated the list (and not only one node because
+            // it could have resulted in deletion of other objects to)
+            i = wxPendingDelete.begin();
+        }
+        else
+        {
+            ++i;
+        }
+    }
+
+    if ( IsLastBeforeExit() )

     {
     {

-        // then do it
+        // no other (important) windows left, quit the app

         wxTheApp->ExitMainLoop();
     }
 }
         wxTheApp->ExitMainLoop();
     }
 }


@@ -82,15 +107,26 @@ bool wxTopLevelWindowBase::Destroy()
     if ( !wxPendingDelete.Member(this) )
         wxPendingDelete.Append(this);
 
     if ( !wxPendingDelete.Member(this) )
         wxPendingDelete.Append(this);
 

-    if (wxTopLevelWindows.GetCount() > 1)
+    // normally we want to hide the window immediately so that it doesn't get
+    // stuck on the screen while it's being destroyed, however we shouldn't
+    // hide the last visible window as then we might not get any idle events
+    // any more as no events will be sent to the hidden window and without idle
+    // events we won't prune wxPendingDelete list and the application won't
+    // terminate
+    for ( wxWindowList::const_iterator i = wxTopLevelWindows.begin(),
+                                     end = wxTopLevelWindows.end();
+          i != end;
+          ++i )

     {
     {

-        // Hide it immediately. This should
-        // not be done if this TLW is the
-        // only one left since we then would
-        // risk not to get any idle events
-        // at all anymore during which we
-        // could delete any pending events.
-        Hide();
+        wxTopLevelWindow * const win = static_cast<wxTopLevelWindow *>(*i);
+        if ( win != this && win->IsShown() )
+        {
+            // there remains at least one other visible TLW, we can hide this
+            // one
+            Hide();
+
+            break;
+        }

     }
 
     return true;
     }
 
     return true;


@@ -98,38 +134,70 @@ bool wxTopLevelWindowBase::Destroy()
 
 bool wxTopLevelWindowBase::IsLastBeforeExit() const
 {
 
 bool wxTopLevelWindowBase::IsLastBeforeExit() const
 {

-    // we exit the application if there are no more top level windows left
-    // normally but wxApp can prevent this from happening
-    return wxTopLevelWindows.GetCount() == 1 &&
-            wxTopLevelWindows.GetFirst()->GetData() == (wxWindow *)this &&
-            wxTheApp && wxTheApp->GetExitOnFrameDelete();
+    // first of all, automatically exiting the app on last window close can be
+    // completely disabled at wxTheApp level
+    if ( !wxTheApp || !wxTheApp->GetExitOnFrameDelete() )
+        return false;
+
+    wxWindowList::const_iterator i;
+    const wxWindowList::const_iterator end = wxTopLevelWindows.end();
+
+    // then decide whether we should exit at all
+    for ( i = wxTopLevelWindows.begin(); i != end; ++i )
+    {
+        wxTopLevelWindow * const win = static_cast<wxTopLevelWindow *>(*i);
+        if ( win->ShouldPreventAppExit() )
+        {
+            // there remains at least one important TLW, don't exit
+            return false;
+        }
+    }
+
+    // if yes, close all the other windows: this could still fail
+    for ( i = wxTopLevelWindows.begin(); i != end; ++i )
+    {
+        // don't close twice the windows which are already marked for deletion
+        wxTopLevelWindow * const win = static_cast<wxTopLevelWindow *>(*i);
+        if ( !wxPendingDelete.Member(win) && !win->Close() )
+        {
+            // one of the windows refused to close, don't exit
+            //
+            // NB: of course, by now some other windows could have been already
+            //     closed but there is really nothing we can do about it as we
+            //     have no way just to ask the window if it can close without
+            //     forcing it to do it
+            return false;
+        }
+    }
+
+    return true;

 }
 
 // ----------------------------------------------------------------------------
 // wxTopLevelWindow geometry
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // wxTopLevelWindow geometry
 // ----------------------------------------------------------------------------
 

-wxSize wxTopLevelWindowBase::GetMaxSize() const
+void wxTopLevelWindowBase::SetMinSize(const wxSize& minSize)

 {
 {

-    wxSize  size( GetMaxWidth(), GetMaxHeight() );
-    int     w, h;
-
-    wxClientDisplayRect( 0, 0, &w, &h );
-
-    if( size.GetWidth() == wxDefaultCoord )
-        size.SetWidth( w );
+    SetSizeHints(minSize, GetMaxSize());
+}

 
 

-    if( size.GetHeight() == wxDefaultCoord )
-        size.SetHeight( h );
+void wxTopLevelWindowBase::SetMaxSize(const wxSize& maxSize)
+{
+    SetSizeHints(GetMinSize(), maxSize);
+}

 
 

-    return size;
+void wxTopLevelWindowBase::GetRectForTopLevelChildren(int *x, int *y, int *w, int *h)
+{
+    GetPosition(x,y);
+    GetSize(w,h);

 }
 
 /* static */
 wxSize wxTopLevelWindowBase::GetDefaultSize()
 {
     wxSize size = wxGetClientDisplayRect().GetSize();
 }
 
 /* static */
 wxSize wxTopLevelWindowBase::GetDefaultSize()
 {
     wxSize size = wxGetClientDisplayRect().GetSize();

-
+#ifndef __WXOSX_IPHONE__

     // create proportionally bigger windows on small screens
     if ( size.x >= 1024 )
         size.x = 400;
     // create proportionally bigger windows on small screens
     if ( size.x >= 1024 )
         size.x = 400;


@@ -145,10 +213,86 @@ wxSize wxTopLevelWindowBase::GetDefaultSize()
         size.y *= 2;
         size.y /= 3;
     }
         size.y *= 2;
         size.y /= 3;
     }

-
+#endif

     return size;
 }
 
     return size;
 }
 

+void wxTopLevelWindowBase::DoCentre(int dir)
+{
+    // on some platforms centering top level windows is impossible
+    // because they are always maximized by guidelines or limitations
+    //
+    // and centering a maximized window doesn't make sense as its position
+    // can't change
+    if ( IsAlwaysMaximized() || IsMaximized() )
+        return;
+
+    // we need the display rect anyhow so store it first: notice that we should
+    // be centered on the same display as our parent window, the display of
+    // this window itself is not really defined yet
+    int nDisplay = wxDisplay::GetFromWindow(GetParent() ? GetParent() : this);
+    wxDisplay dpy(nDisplay == wxNOT_FOUND ? 0 : nDisplay);
+    const wxRect rectDisplay(dpy.GetClientArea());
+
+    // what should we centre this window on?
+    wxRect rectParent;
+    if ( !(dir & wxCENTRE_ON_SCREEN) && GetParent() )
+    {
+        // centre on parent window: notice that we need screen coordinates for
+        // positioning this TLW
+        rectParent = GetParent()->GetScreenRect();
+
+        // if the parent is entirely off screen (happens at least with MDI
+        // parent frame under Mac but could happen elsewhere too if the frame
+        // was hidden/moved away for some reason), don't use it as otherwise
+        // this window wouldn't be visible at all
+        if ( !rectParent.Intersects(rectDisplay) )
+        {
+            // just centre on screen then
+            rectParent = rectDisplay;
+        }
+    }
+    else
+    {
+        // we were explicitly asked to centre this window on the entire screen
+        // or if we have no parent anyhow and so can't centre on it
+        rectParent = rectDisplay;
+    }
+
+    if ( !(dir & wxBOTH) )
+        dir |= wxBOTH; // if neither is specified, center in both directions
+
+    // the new window rect candidate
+    wxRect rect = GetRect().CentreIn(rectParent, dir & ~wxCENTRE_ON_SCREEN);
+
+    // we don't want to place the window off screen if Centre() is called as
+    // this is (almost?) never wanted and it would be very difficult to prevent
+    // it from happening from the user code if we didn't check for it here
+    if ( !rectDisplay.Contains(rect.GetTopLeft()) )
+    {
+        // move the window just enough to make the corner visible
+        int dx = rectDisplay.GetLeft() - rect.GetLeft();
+        int dy = rectDisplay.GetTop() - rect.GetTop();
+        rect.Offset(dx > 0 ? dx : 0, dy > 0 ? dy : 0);
+    }
+
+    if ( !rectDisplay.Contains(rect.GetBottomRight()) )
+    {
+        // do the same for this corner too
+        int dx = rectDisplay.GetRight() - rect.GetRight();
+        int dy = rectDisplay.GetBottom() - rect.GetBottom();
+        rect.Offset(dx < 0 ? dx : 0, dy < 0 ? dy : 0);
+    }
+
+    // the window top left and bottom right corner are both visible now and
+    // although the window might still be not entirely on screen (with 2
+    // staggered displays for example) we wouldn't be able to improve the
+    // layout much in such case, so we stop here
+
+    // -1 could be valid coordinate here if there are several displays
+    SetSize(rect, wxSIZE_ALLOW_MINUS_ONE);
+}
+

 // ----------------------------------------------------------------------------
 // wxTopLevelWindow size management: we exclude the areas taken by
 // menu/status/toolbars from the client area, so the client area is what's
 // ----------------------------------------------------------------------------
 // wxTopLevelWindow size management: we exclude the areas taken by
 // menu/status/toolbars from the client area, so the client area is what's


@@ -180,6 +324,34 @@ void wxTopLevelWindowBase::DoClientToScreen(int *x, int *y) const
     wxWindow::DoClientToScreen(x, y);
 }
 
     wxWindow::DoClientToScreen(x, y);
 }
 

+bool wxTopLevelWindowBase::IsAlwaysMaximized() const
+{
+#if defined(__SMARTPHONE__) || defined(__POCKETPC__)
+    return true;
+#else
+    return false;
+#endif
+}
+
+// ----------------------------------------------------------------------------
+// icons
+// ----------------------------------------------------------------------------
+
+wxIcon wxTopLevelWindowBase::GetIcon() const
+{
+    return m_icons.IsEmpty() ? wxIcon() : m_icons.GetIcon( -1 );
+}
+
+void wxTopLevelWindowBase::SetIcon(const wxIcon& icon)
+{
+    // passing wxNullIcon to SetIcon() is possible (it means that we shouldn't
+    // have any icon), but adding an invalid icon to wxIconBundle is not
+    wxIconBundle icons;
+    if ( icon.IsOk() )
+        icons.AddIcon(icon);
+
+    SetIcons(icons);
+}

 
 // ----------------------------------------------------------------------------
 // event handlers
 
 // ----------------------------------------------------------------------------
 // event handlers


@@ -187,7 +359,7 @@ void wxTopLevelWindowBase::DoClientToScreen(int *x, int *y) const
 
 // default resizing behaviour - if only ONE subwindow, resize to fill the
 // whole client area
 
 // default resizing behaviour - if only ONE subwindow, resize to fill the
 // whole client area

-void wxTopLevelWindowBase::OnSize(wxSizeEvent& WXUNUSED(event))
+void wxTopLevelWindowBase::DoLayout()

 {
     // if we're using constraints or sizers - do use them
     if ( GetAutoLayout() )
 {
     // if we're using constraints or sizers - do use them
     if ( GetAutoLayout() )


@@ -197,7 +369,7 @@ void wxTopLevelWindowBase::OnSize(wxSizeEvent& WXUNUSED(event))
     else
     {
         // do we have _exactly_ one child?
     else
     {
         // do we have _exactly_ one child?

-        wxWindow *child = (wxWindow *)NULL;
+        wxWindow *child = NULL;

         for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
               node;
               node = node->GetNext() )
         for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
               node;
               node = node->GetNext() )


@@ -219,21 +391,13 @@ void wxTopLevelWindowBase::OnSize(wxSizeEvent& WXUNUSED(event))
         }
 
         // do we have any children at all?
         }
 
         // do we have any children at all?

-        if ( child )
+        if ( child && child->IsShown() )

         {
             // exactly one child - set it's size to fill the whole frame
             int clientW, clientH;
             DoGetClientSize(&clientW, &clientH);
 
         {
             // exactly one child - set it's size to fill the whole frame
             int clientW, clientH;
             DoGetClientSize(&clientW, &clientH);
 

-            // for whatever reasons, wxGTK wants to have a small offset - it
-            // probably looks better with it?
-#ifdef __WXGTK__
-            static const int ofs = 1;
-#else
-            static const int ofs = 0;
-#endif
-
-            child->SetSize(ofs, ofs, clientW - 2*ofs, clientH - 2*ofs);
+            child->SetSize(0, 0, clientW, clientH);

         }
     }
 }
         }
     }
 }


@@ -255,9 +419,12 @@ bool wxTopLevelWindowBase::SendIconizeEvent(bool iconized)
 // do the window-specific processing after processing the update event
 void wxTopLevelWindowBase::DoUpdateWindowUI(wxUpdateUIEvent& event)
 {
 // do the window-specific processing after processing the update event
 void wxTopLevelWindowBase::DoUpdateWindowUI(wxUpdateUIEvent& event)
 {

-    if ( event.GetSetEnabled() )
-        Enable(event.GetEnabled());
+    // call inherited, but skip the wxControl's version, and call directly the
+    // wxWindow's one instead, because the only reason why we are overriding this
+    // function is that we want to use SetTitle() instead of wxControl::SetLabel()
+    wxWindowBase::DoUpdateWindowUI(event);

 
 

+    // update title

     if ( event.GetSetText() )
     {
         if ( event.GetText() != GetTitle() )
     if ( event.GetSetText() )
     {
         if ( event.GetText() != GetTitle() )


@@ -270,4 +437,3 @@ void wxTopLevelWindowBase::RequestUserAttention(int WXUNUSED(flags))
     // it's probably better than do nothing, isn't it?
     Raise();
 }
     // it's probably better than do nothing, isn't it?
     Raise();
 }

-