Correct weak ref usage which triggered an assert

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

diff --git a/src/common/toplvcmn.cpp b/src/common/toplvcmn.cpp
index 433e3a6aae7b2e7fec5560771a20ac7264b5197c..bcfd5291052b5a4a9c9f030571e0aa8dbf299b5c 100644 (file)
--- a/src/common/toplvcmn.cpp
+++ b/src/common/toplvcmn.cpp
@@ -40,8 +40,11 @@ BEGIN_EVENT_TABLE(wxTopLevelWindowBase, wxWindow)
     EVT_CLOSE(wxTopLevelWindowBase::OnCloseWindow)
     EVT_SIZE(wxTopLevelWindowBase::OnSize)
     EVT_WINDOW_DESTROY(wxTopLevelWindowBase::OnChildDestroy)
     EVT_CLOSE(wxTopLevelWindowBase::OnCloseWindow)
     EVT_SIZE(wxTopLevelWindowBase::OnSize)
     EVT_WINDOW_DESTROY(wxTopLevelWindowBase::OnChildDestroy)

+    WX_EVENT_TABLE_CONTROL_CONTAINER(wxTopLevelWindowBase)

 END_EVENT_TABLE()
 
 END_EVENT_TABLE()
 

+WX_DELEGATE_TO_CONTROL_CONTAINER(wxTopLevelWindowBase, wxWindow)
+

 // ============================================================================
 // implementation
 // ============================================================================
 // ============================================================================
 // implementation
 // ============================================================================


@@ -56,18 +59,51 @@ wxTopLevelWindowBase::wxTopLevelWindowBase()
 {
     // Unlike windows, top level windows are created hidden by default.
     m_isShown = false;
 {
     // Unlike windows, top level windows are created hidden by default.
     m_isShown = false;

-    m_winDefault = NULL;
+    m_winDefault =

     m_winTmpDefault = NULL;
     m_winTmpDefault = NULL;

+
+    WX_INIT_CONTROL_CONTAINER();

 }
 
 wxTopLevelWindowBase::~wxTopLevelWindowBase()
 {
 }
 
 wxTopLevelWindowBase::~wxTopLevelWindowBase()
 {

+    m_winDefault =
+    m_winTmpDefault = NULL;
+

     // don't let wxTheApp keep any stale pointers to us
     if ( wxTheApp && wxTheApp->GetTopWindow() == this )
         wxTheApp->SetTopWindow(NULL);
 
     wxTopLevelWindows.DeleteObject(this);
 
     // don't let wxTheApp keep any stale pointers to us
     if ( wxTheApp && wxTheApp->GetTopWindow() == this )
         wxTheApp->SetTopWindow(NULL);
 
     wxTopLevelWindows.DeleteObject(this);
 

+    // 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() )
     {
         // no other (important) windows left, quit the app
     if ( IsLastBeforeExit() )
     {
         // no other (important) windows left, quit the app


@@ -82,15 +118,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 = wx_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;


@@ -143,29 +190,12 @@ bool wxTopLevelWindowBase::IsLastBeforeExit() const
 
 void wxTopLevelWindowBase::SetMinSize(const wxSize& minSize)
 {
 
 void wxTopLevelWindowBase::SetMinSize(const wxSize& minSize)
 {

-    SetSizeHints( minSize.x, minSize.y, GetMaxWidth(), GetMaxHeight() );    
+    SetSizeHints(minSize, GetMaxSize());

 }
 
 void wxTopLevelWindowBase::SetMaxSize(const wxSize& maxSize)
 {
 }
 
 void wxTopLevelWindowBase::SetMaxSize(const wxSize& maxSize)
 {

-    SetSizeHints( GetMinWidth(), GetMinHeight(), maxSize.x, maxSize.y );
-}
-
-// set the min/max size of the window
-void wxTopLevelWindowBase::DoSetSizeHints(int minW, int minH,
-                                  int maxW, int maxH,
-                                  int WXUNUSED(incW), int WXUNUSED(incH))
-{
-    // setting min width greater than max width leads to infinite loops under
-    // X11 and generally doesn't make any sense, so don't allow it
-    wxCHECK_RET( (minW == wxDefaultCoord || maxW == wxDefaultCoord || minW <= maxW) &&
-                    (minH == wxDefaultCoord || maxH == wxDefaultCoord || minH <= maxH),
-                 _T("min width/height must be less than max width/height!") );
-
-    m_minWidth = minW;
-    m_maxWidth = maxW;
-    m_minHeight = minH;
-    m_maxHeight = maxH;
+    SetSizeHints(GetMinSize(), maxSize);

 }
 
 void wxTopLevelWindowBase::GetRectForTopLevelChildren(int *x, int *y, int *w, int *h)
 }
 
 void wxTopLevelWindowBase::GetRectForTopLevelChildren(int *x, int *y, int *w, int *h)


@@ -205,8 +235,10 @@ void wxTopLevelWindowBase::DoCentre(int dir)
     if(IsAlwaysMaximized())
         return;
 
     if(IsAlwaysMaximized())
         return;
 

-    // we need the display rect anyhow so store it first
-    int nDisplay = wxDisplay::GetFromWindow(this);
+    // 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());
 
     wxDisplay dpy(nDisplay == wxNOT_FOUND ? 0 : nDisplay);
     const wxRect rectDisplay(dpy.GetClientArea());
 


@@ -247,30 +279,27 @@ void wxTopLevelWindowBase::DoCentre(int dir)
     // 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
     // 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()) )
+    if ( !rectDisplay.Contains(rect.GetTopLeft()) )

     {
     {

-        if ( !rectDisplay.Contains(rect.GetBottomRight()) )
-        {
-            // move the window just enough for the bottom right corner to
-            // become visible
-            int dx = rectDisplay.GetRight() - rect.GetRight();
-            int dy = rectDisplay.GetBottom() - rect.GetBottom();
-            rect.Offset(dx < 0 ? dx : 0, dy < 0 ? dy : 0);
-        }
-        //else: the window top left and bottom right corner are both visible,
-        //      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 just leave it as is
+        // 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);

     }
     }

-    else // make top left corner visible
-    {
-        if ( rect.x < rectDisplay.x )
-            rect.x = rectDisplay.x;

 
 

-        if ( rect.y < rectDisplay.y )
-            rect.y = rectDisplay.y;
+    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);
 }
     // -1 could be valid coordinate here if there are several displays
     SetSize(rect, wxSIZE_ALLOW_MINUS_ONE);
 }


@@ -315,6 +344,26 @@ bool wxTopLevelWindowBase::IsAlwaysMaximized() const
 #endif
 }
 
 #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.Ok() )
+        icons.AddIcon(icon);
+
+    SetIcons(icons);
+}
+

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


@@ -410,14 +459,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();
 }

-
-void wxTopLevelWindowBase::RemoveChild(wxWindowBase *child)
-{
-    if ( child == m_winDefault )
-        m_winDefault = NULL;
-
-    if ( child == m_winTmpDefault )
-        m_winTmpDefault = NULL;
-
-    wxWindow::RemoveChild(child);
-}