#4790 Make sure window maximation state is restored after project load + tiling fixes

ApplicationCode/Commands/SummaryPlotCommands/RicSummaryPlotFeatureImpl.cpp

@@ -680,11 +680,11 @@ void RicSummaryPlotFeatureImpl::createSummaryPlotsFromArgumentLine( const QStrin
 
             RiuPlotMainWindow* mpw = RiaGuiApplication::instance()->mainPlotWindow();
             // Needed to avoid unneccessary activation of sub windows (plots)
-            // which results in population of property editor, and missing deleteLater because we are outside any event loop
+            // which results in population of property editor, and missing deleteLater because we are outside any event
-            // when switching object. Results in stray widgets. 
+            // loop when switching object. Results in stray widgets.
-            mpw->setBlockSlotSubWindowActivated( true ); 
+            mpw->setBlockSubWindowProjectTreeSelection( true );
             RiuPlotMainWindowTools::showPlotMainWindow();
-            mpw->setBlockSlotSubWindowActivated( false );
+            mpw->setBlockSubWindowProjectTreeSelection( false );
             RiuPlotMainWindowTools::setExpanded( lastPlotCreated );
             RiuPlotMainWindowTools::selectAsCurrentItem( lastPlotCreated );
 

ApplicationCode/UserInterface/RiuMainWindow.cpp

@@ -97,6 +97,8 @@
 #include <QTreeView>
 #include <QUndoStack>
 
+#include <QDebug>
+
 #include <algorithm>
 
 //==================================================================================================
@@ -1029,6 +1031,8 @@ QMdiSubWindow* RiuMainWindow::findMdiSubWindow( QWidget* viewer )
 //--------------------------------------------------------------------------------------------------
 RimViewWindow* RiuMainWindow::findViewWindowFromSubWindow( QMdiSubWindow* subWindow )
 {
+    if ( subWindow )
+    {
         std::vector<RimViewWindow*> allViewWindows;
         RiaApplication::instance()->project()->descendantsIncludingThisOfType( allViewWindows );
 
@@ -1039,6 +1043,7 @@ RimViewWindow* RiuMainWindow::findViewWindowFromSubWindow( QMdiSubWindow* subWin
                 return viewWindow;
             }
         }
+    }
     return nullptr;
 }
 
@@ -1225,43 +1230,29 @@ void RiuMainWindow::slotViewFromBelow()
 //--------------------------------------------------------------------------------------------------
 void RiuMainWindow::slotSubWindowActivated( QMdiSubWindow* subWindow )
 {
-    if ( !subWindow ) return;
+    if ( blockSubWindowActivation() ) return;
-    if ( blockSlotSubWindowActivated() ) return;
 
-    RimProject* proj = RiaApplication::instance()->project();
-    if ( !proj ) return;
-
-    // Find the activated 3D view
-
-    Rim3dView* activatedView = nullptr;
-
-    std::vector<RimCase*> allCases;
-    proj->allCases( allCases );
-
-    for ( RimCase* reservoirCase : allCases )
-    {
-        if ( reservoirCase == nullptr ) continue;
-
-        std::vector<Rim3dView*> views = reservoirCase->views();
-
-        size_t viewIdx;
-        for ( viewIdx = 0; viewIdx < views.size(); viewIdx++ )
-        {
-            Rim3dView* riv = views[viewIdx];
-
-            if ( riv && riv->viewer() && riv->viewer()->layoutWidget() &&
-                 riv->viewer()->layoutWidget()->parent() == subWindow )
-            {
-                activatedView = riv;
-                break;
-            }
-        }
-    }
-
-    {
     Rim3dView* previousActiveReservoirView = RiaApplication::instance()->activeReservoirView();
+    Rim3dView* activatedView               = dynamic_cast<Rim3dView*>( findViewWindowFromSubWindow( subWindow ) );
+
+    if ( !activatedView ) return;
     RiaApplication::instance()->setActiveReservoirView( activatedView );
 
+    if ( !blockSubWindowProjectTreeSelection() )
+    {
+        selectViewInProjectTree( previousActiveReservoirView, activatedView );
+    }
+
+    slotRefreshViewActions();
+    refreshAnimationActions();
+    refreshDrawStyleActions();
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RiuMainWindow::selectViewInProjectTree( const Rim3dView* previousActiveReservoirView, Rim3dView* activatedView )
+{
     bool is3dViewCurrentlySelected = false;
     if ( caf::SelectionManager::instance()->selectedItem() )
     {
@@ -1324,11 +1315,6 @@ void RiuMainWindow::slotSubWindowActivated( QMdiSubWindow* subWindow )
             m_projectTreeView->treeView()->setExpanded( newViewModelIndex, true );
         }
     }
-
-        slotRefreshViewActions();
-        refreshAnimationActions();
-        refreshDrawStyleActions();
-    }
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -1456,9 +1442,9 @@ void RiuMainWindow::selectedObjectsChanged()
             // Set focus in MDI area to this window if it exists
             if ( selectedReservoirView->viewer() )
             {
-                setBlockSlotSubWindowActivated(true);
+                setBlockSubWindowProjectTreeSelection( true );
-                setActiveViewer(selectedReservoirView->viewer()->layoutWidget());
+                setActiveViewer( selectedReservoirView->viewer()->layoutWidget() );
-                setBlockSlotSubWindowActivated(false);
+                setBlockSubWindowProjectTreeSelection( false );
 
                 isActiveViewChanged = true;
             }
@@ -1975,7 +1961,7 @@ void RiuMainWindow::tileSubWindows()
     }
 
     // Perform stable sort of list so we first sort by window position but retain activation order
-    // for windows with the same position. Needs to be sorted in decreasing order for the workaround below.
+    // for windows with the same position.
     windowList.sort( [this, viewLinker]( QMdiSubWindow* lhs, QMdiSubWindow* rhs ) {
         RimViewWindow* lhsViewWindow = findViewWindowFromSubWindow( lhs );
         RimViewWindow* rhsViewWindow = findViewWindowFromSubWindow( rhs );
@@ -1993,28 +1979,36 @@ void RiuMainWindow::tileSubWindows()
                 return false;
             }
         }
-        return lhs->frameGeometry().topLeft().rx() > rhs->frameGeometry().topLeft().rx();
+        if ( lhs->frameGeometry().topLeft().ry() == rhs->frameGeometry().topLeft().ry() )
+        {
+            return lhs->frameGeometry().topLeft().rx() < rhs->frameGeometry().topLeft().rx();
+        }
+        return lhs->frameGeometry().topLeft().ry() < rhs->frameGeometry().topLeft().ry();
     } );
 
     // Based on workaround described here
     // https://forum.qt.io/topic/50053/qmdiarea-tilesubwindows-always-places-widgets-in-activationhistoryorder-in-subwindowview-mode
 
-    bool prevActivationBlock = blockSlotSubWindowActivated();
+    bool prevActivationBlock = blockSubWindowActivation();
-    // Force activation order so they end up in the order of the loop.
+
-    m_mdiArea->setActivationOrder( QMdiArea::ActivationHistoryOrder );
     QMdiSubWindow* a = m_mdiArea->activeSubWindow();
 
-    setBlockSlotSubWindowActivated( true );
+    // Force activation order so they end up in the order of the loop.
-    for ( QMdiSubWindow* subWindow : windowList )
+    m_mdiArea->setActivationOrder( QMdiArea::ActivationHistoryOrder );
+
+    setBlockSubWindowActivation( true );
+
+    // Activate in reverse order
+    for ( auto it = windowList.rbegin(); it != windowList.rend(); ++it )
     {
-        m_mdiArea->setActiveSubWindow( subWindow );
+        m_mdiArea->setActiveSubWindow( *it );
     }
 
     m_mdiArea->tileSubWindows();
     // Set back the original activation order to avoid messing with the standard ordering
     m_mdiArea->setActivationOrder( currentActivationOrder );
     m_mdiArea->setActiveSubWindow( a );
-    setBlockSlotSubWindowActivated( prevActivationBlock );
+    setBlockSubWindowActivation( prevActivationBlock );
 
     storeSubWindowTiling( true );
 }
@@ -2033,6 +2027,7 @@ void RiuMainWindow::storeSubWindowTiling( bool tiled )
 //--------------------------------------------------------------------------------------------------
 void RiuMainWindow::clearWindowTiling()
 {
+    setBlockSubWindowActivation( true );
     QMdiArea::WindowOrder currentActivationOrder = m_mdiArea->activationOrder();
 
     for ( QMdiSubWindow* subWindow : m_mdiArea->subWindowList( currentActivationOrder ) )
@@ -2041,6 +2036,7 @@ void RiuMainWindow::clearWindowTiling()
         subWindow->showNormal();
     }
     storeSubWindowTiling( false );
+    setBlockSubWindowActivation( false );
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/UserInterface/RiuMainWindow.h

@@ -40,6 +40,7 @@ class QSpinBox;
 class QTimer;
 class QUndoView;
 
+class Rim3dView;
 class RimCase;
 class RimViewWindow;
 
@@ -230,9 +231,10 @@ private slots:
 
     // Windows slots
     void slotBuildWindowActions();
-
     void slotSubWindowActivated( QMdiSubWindow* subWindow );
 
+    void selectViewInProjectTree( const Rim3dView* previousActiveReservoirView, Rim3dView* activatedView );
+
     void selectedObjectsChanged();
     void customMenuRequested( const QPoint& pos );
 

ApplicationCode/UserInterface/RiuMainWindowBase.cpp

@@ -42,7 +42,8 @@ RiuMainWindowBase::RiuMainWindowBase()
     : m_projectTreeView( nullptr )
     , m_allowActiveViewChangeFromSelection( true )
     , m_showFirstVisibleWindowMaximized( true )
-    , m_blockSlotSubWindowActivated( false )
+    , m_blockSubWindowActivation( false )
+    , m_blockSubWindowProjectTreeSelection( false )
 {
     setDockNestingEnabled( true );
 }
@@ -216,17 +217,33 @@ void RiuMainWindowBase::enableShowFirstVisibleMdiWindowMaximized( bool enable )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RiuMainWindowBase::setBlockSlotSubWindowActivated( bool block )
+void RiuMainWindowBase::setBlockSubWindowActivation( bool block )
 {
-    m_blockSlotSubWindowActivated = block;
+    m_blockSubWindowActivation = block;
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RiuMainWindowBase::blockSlotSubWindowActivated() const
+bool RiuMainWindowBase::blockSubWindowActivation() const
 {
-    return m_blockSlotSubWindowActivated;
+    return m_blockSubWindowActivation;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RiuMainWindowBase::setBlockSubWindowProjectTreeSelection( bool block )
+{
+    m_blockSubWindowProjectTreeSelection = block;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+bool RiuMainWindowBase::blockSubWindowProjectTreeSelection() const
+{
+    return m_blockSubWindowProjectTreeSelection;
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/UserInterface/RiuMainWindowBase.h

@@ -75,8 +75,11 @@ public:
     virtual void clearWindowTiling()                = 0;
     virtual bool subWindowsAreTiled() const         = 0;
 
-    void setBlockSlotSubWindowActivated( bool block );
+    void setBlockSubWindowActivation( bool block );
-    bool blockSlotSubWindowActivated() const;
+    bool blockSubWindowActivation() const;
+
+    void setBlockSubWindowProjectTreeSelection( bool block );
+    bool blockSubWindowProjectTreeSelection() const;
 
 protected:
     void removeViewerFromMdiArea( QMdiArea* mdiArea, QWidget* viewer );
@@ -94,5 +97,6 @@ private:
 
 private:
     bool m_showFirstVisibleWindowMaximized;
-    bool m_blockSlotSubWindowActivated;
+    bool m_blockSubWindowActivation;
+    bool m_blockSubWindowProjectTreeSelection;
 };

ApplicationCode/UserInterface/RiuMdiArea.cpp

@@ -58,7 +58,7 @@ void RiuMdiArea::resizeEvent( QResizeEvent* resizeEvent )
         }
 
         RiuMainWindowBase* mainWindow = dynamic_cast<RiuMainWindowBase*>( window() );
-        mainWindow->setBlockSlotSubWindowActivated( true );
+        mainWindow->setBlockSubWindowActivation( true );
 
         // Workaround for Qt bug #51761: https://bugreports.qt.io/browse/QTBUG-51761
         // Set the first window to be the active window then perform resize event and set back.
@@ -70,7 +70,7 @@ void RiuMdiArea::resizeEvent( QResizeEvent* resizeEvent )
 
         setActiveSubWindow( a );
 
-        mainWindow->setBlockSlotSubWindowActivated( false );
+        mainWindow->setBlockSubWindowActivation( false );
 
         for ( auto subWindow : subWindowList() )
         {

ApplicationCode/UserInterface/RiuPlotMainWindow.cpp

@@ -445,7 +445,6 @@ void RiuPlotMainWindow::createDockPanels()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-
 QMdiSubWindow* RiuPlotMainWindow::findMdiSubWindow( QWidget* viewer )
 {
     QList<QMdiSubWindow*> subws = m_mdiArea->subWindowList();
@@ -461,6 +460,19 @@ QMdiSubWindow* RiuPlotMainWindow::findMdiSubWindow( QWidget* viewer )
     return nullptr;
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RimViewWindow* RiuPlotMainWindow::findViewWindowFromSubWindow( QMdiSubWindow* subWindow )
+{
+    RimProject* proj = RiaApplication::instance()->project();
+    if ( subWindow && proj )
+    {
+        return RiuInterfaceToViewWindow::viewWindowFromWidget( subWindow->widget() );
+    }
+    return nullptr;
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
@@ -642,20 +654,16 @@ void RiuPlotMainWindow::setPdmRoot( caf::PdmObject* pdmRoot )
 //--------------------------------------------------------------------------------------------------
 void RiuPlotMainWindow::slotSubWindowActivated( QMdiSubWindow* subWindow )
 {
-    if ( !subWindow ) return;
+    if ( blockSubWindowActivation() ) return;
-    if ( blockSlotSubWindowActivated() ) return;
 
-    RimProject* proj = RiaApplication::instance()->project();
+    RimViewWindow* activatedView = findViewWindowFromSubWindow( subWindow );
-    if ( !proj ) return;
 
-    // Select in Project Tree
+    if ( !activatedView ) return;
+    m_activePlotViewWindow = activatedView;
 
-    RimViewWindow* viewWindow = RiuInterfaceToViewWindow::viewWindowFromWidget( subWindow->widget() );
+    if ( !blockSubWindowProjectTreeSelection() )
-
-    if ( viewWindow && viewWindow != m_activePlotViewWindow )
     {
-        selectAsCurrentItem( viewWindow );
+        selectAsCurrentItem( activatedView );
-        m_activePlotViewWindow = viewWindow;
     }
 
     updateWellLogPlotToolBar();
@@ -761,9 +769,9 @@ void RiuPlotMainWindow::selectedObjectsChanged()
         {
             if ( selectedWindow->viewWidget() )
             {
-                setBlockSlotSubWindowActivated( true );
+                setBlockSubWindowProjectTreeSelection( true );
                 setActiveViewer( selectedWindow->viewWidget() );
-                setBlockSlotSubWindowActivated( false );
+                setBlockSubWindowProjectTreeSelection( false );
             }
             // The only way to get to this code is by selection change initiated from the project tree view
             // As we are activating an MDI-window, the focus is given to this MDI-window
@@ -840,26 +848,35 @@ void RiuPlotMainWindow::tileSubWindows()
     }
 
     // Perform stable sort of list so we first sort by window position but retain activation order
-    // for windows with the same position. Needs to be sorted in decreasing order for workaround below.
+    // for windows with the same position.
     windowList.sort( []( const QMdiSubWindow* lhs, const QMdiSubWindow* rhs ) {
-        return lhs->frameGeometry().topLeft().rx() > rhs->frameGeometry().topLeft().rx();
+        if ( lhs->frameGeometry().topLeft().ry() == rhs->frameGeometry().topLeft().ry() )
+        {
+            return lhs->frameGeometry().topLeft().rx() < rhs->frameGeometry().topLeft().rx();
+        }
+        return lhs->frameGeometry().topLeft().ry() < rhs->frameGeometry().topLeft().ry();
     } );
 
     // Based on workaround described here
     // https://forum.qt.io/topic/50053/qmdiarea-tilesubwindows-always-places-widgets-in-activationhistoryorder-in-subwindowview-mode
 
-    QMdiSubWindow* a = m_mdiArea->activeSubWindow();
+    bool prevActivationBlock = blockSubWindowActivation();
     // Force activation order so they end up in the order of the loop.
     m_mdiArea->setActivationOrder( QMdiArea::ActivationHistoryOrder );
-    for ( QMdiSubWindow* subWindow : windowList )
+    QMdiSubWindow* a = m_mdiArea->activeSubWindow();
+
+    setBlockSubWindowActivation( true );
+    // Activate in reverse order
+    for ( auto it = windowList.rbegin(); it != windowList.rend(); ++it )
     {
-        m_mdiArea->setActiveSubWindow( subWindow );
+        m_mdiArea->setActiveSubWindow( *it );
     }
 
     m_mdiArea->tileSubWindows();
     // Set back the original activation order to avoid messing with the standard ordering
     m_mdiArea->setActivationOrder( currentActivationOrder );
     m_mdiArea->setActiveSubWindow( a );
+    setBlockSubWindowActivation( prevActivationBlock );
 
     storeSubWindowTiling( true );
 }
@@ -878,6 +895,7 @@ void RiuPlotMainWindow::storeSubWindowTiling( bool tiled )
 //--------------------------------------------------------------------------------------------------
 void RiuPlotMainWindow::clearWindowTiling()
 {
+    setBlockSubWindowActivation( true );
     QMdiArea::WindowOrder currentActivationOrder = m_mdiArea->activationOrder();
 
     for ( QMdiSubWindow* subWindow : m_mdiArea->subWindowList( currentActivationOrder ) )
@@ -886,6 +904,7 @@ void RiuPlotMainWindow::clearWindowTiling()
         subWindow->showNormal();
     }
     storeSubWindowTiling( false );
+    setBlockSubWindowActivation( false );
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/UserInterface/RiuPlotMainWindow.h

@@ -73,6 +73,7 @@ public:
 
     bool                  isAnyMdiSubWindowVisible();
     QMdiSubWindow*        findMdiSubWindow( QWidget* viewer ) override;
+    RimViewWindow*        findViewWindowFromSubWindow( QMdiSubWindow* subWindow );
     QList<QMdiSubWindow*> subWindowList( QMdiArea::WindowOrder order );
 
     void setWidthOfMdiWindow( QWidget* mdiWindowWidget, int newWidth );

ApplicationCode/UserInterface/RiuWellLogPlot.cpp

@@ -315,6 +315,14 @@ void RiuWellLogPlot::keyPressEvent( QKeyEvent* keyEvent )
     m_plotDefinition->handleKeyPressEvent( keyEvent );
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RiuWellLogPlot::resizeEvent( QResizeEvent* event )
+{
+    QWidget::resizeEvent( event );
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------

ApplicationCode/UserInterface/RiuWellLogPlot.h

@@ -75,6 +75,7 @@ protected:
     void changeEvent( QEvent* event ) override;
     void contextMenuEvent( QContextMenuEvent* ) override;
     void keyPressEvent( QKeyEvent* keyEvent ) override;
+    void resizeEvent( QResizeEvent* event ) override;
 
     QSize sizeHint() const override;