Support linking of 2D intersection views

* Major refactor from RimGridView to Rim3dView
* Move view linker/controller functions to Rim3dView
* Add bitmask to define the content of a 3D view
* Link views based on matching content
* Enable bit mask operators at global scope
* Make it possible to use 2d intersection views as comparison views
* Fix crash when a view used as comparison view is deleted
* Move unlinking to Rim3dView

* Add options to snapshot only 3D views/plots as part of regression testing
* WBS plot: Improve default name, hide axis for some tracks

ApplicationLibCode/Commands/FlowCommands/RicShowContributingWellsFeature.cpp

@@ -97,7 +97,7 @@ void RicShowContributingWellsFeature::onActionTriggered( bool isChecked )
     {
         modifiedView->createDisplayModelAndRedraw();
 
-        std::vector<RimGridView*> viewsToUpdate;
+        std::vector<Rim3dView*> viewsToUpdate;
         viewsToUpdate.push_back( modifiedView );
 
         RimViewManipulator::applySourceViewCameraOnDestinationViews( eclipseView, viewsToUpdate );

ApplicationLibCode/Commands/RicSelectColorResult.cpp

@@ -49,7 +49,7 @@ RimGridView* gridViewFrom2dIntersectionView( const Rim2dIntersectionView* int2dV
 //--------------------------------------------------------------------------------------------------
 void RicSelectColorResult::setupActionLook( QAction* actionToSetup )
 {
-    actionToSetup->setText( "Select Color Result" );
+    actionToSetup->setText( "Activate Result in Project Tree" );
     actionToSetup->setIcon( QIcon( ":/CellResult.png" ) );
 }
 
@@ -68,8 +68,7 @@ bool RicSelectColorResult::isCommandEnabled()
 //--------------------------------------------------------------------------------------------------
 void RicSelectColorResult::onActionTriggered( bool isChecked )
 {
-    Rim3dView* activeView       = RiaApplication::instance()->activeMainOrComparisonGridView();
-    bool       isComparisonView = ( activeView != RiaApplication::instance()->activeGridView() );
+    Rim3dView* activeView = RiaApplication::instance()->activeReservoirView();
 
     Rim2dIntersectionView* int2dView = dynamic_cast<Rim2dIntersectionView*>( activeView );
     RimGridView*           gridView  = nullptr;
@@ -82,13 +81,13 @@ void RicSelectColorResult::onActionTriggered( bool isChecked )
     RimEclipseView* eclView = dynamic_cast<RimEclipseView*>( gridView );
     if ( eclView )
     {
-        Riu3DMainWindowTools::selectAsCurrentItem( eclView->cellResult(), int2dView == nullptr && !isComparisonView );
+        Riu3DMainWindowTools::selectAsCurrentItem( eclView->cellResult(), int2dView == nullptr );
         return;
     }
 
     RimGeoMechView* geoMechView = dynamic_cast<RimGeoMechView*>( gridView );
     if ( geoMechView )
     {
-        Riu3DMainWindowTools::selectAsCurrentItem( geoMechView->cellResult(), int2dView == nullptr && !isComparisonView );
+        Riu3DMainWindowTools::selectAsCurrentItem( geoMechView->cellResult(), int2dView == nullptr );
     }
 }

ApplicationLibCode/Commands/ViewLink/RicCompareTo3dViewFeature.cpp

@@ -42,7 +42,7 @@ bool RicCompareTo3dViewFeature::isCommandEnabled()
 //--------------------------------------------------------------------------------------------------
 void RicCompareTo3dViewFeature::onActionTriggered( bool isChecked )
 {
-    RimGridView* activeView = RiaApplication::instance()->activeGridView();
+    auto* activeView = RiaApplication::instance()->activeReservoirView();
 
     QVariant userData = this->userData();
     auto     view     = static_cast<Rim3dView*>( userData.value<void*>() );
@@ -51,7 +51,9 @@ void RicCompareTo3dViewFeature::onActionTriggered( bool isChecked )
     {
         activeView->setComparisonView( view );
         activeView->scheduleCreateDisplayModelAndRedraw();
-        activeView->overlayInfoConfig()->updateConnectedEditors();
+
+        auto gridView = dynamic_cast<RimGridView*>( activeView );
+        if ( gridView ) gridView->overlayInfoConfig()->updateConnectedEditors();
     }
 }
 

ApplicationLibCode/Commands/ViewLink/RicLinkViewFeature.cpp

@@ -53,7 +53,7 @@ public:
         if ( contextViewer )
         {
             // Link only the active view to an existing view link collection.
-            RimGridView* activeView = RiaApplication::instance()->activeGridView();
+            auto* activeView = RiaApplication::instance()->activeReservoirView();
             if ( !activeView ) return false;
 
             if ( activeView->assosiatedViewLinker() ) return false;
@@ -62,7 +62,7 @@ public:
             return true;
         }
 
-        std::vector<RimGridView*> selectedGridViews;
+        std::vector<Rim3dView*> selectedGridViews;
 
         caf::SelectionManager::instance()->objectsByTypeStrict( &selectedGridViews );
         for ( auto gridView : selectedGridViews )
@@ -85,10 +85,10 @@ public:
 
     void execute() { RicLinkVisibleViewsFeature::linkViews( m_viewsToLink ); }
 
-    const std::vector<RimGridView*>& viewsToLink() { return m_viewsToLink; }
+    const std::vector<Rim3dView*>& viewsToLink() { return m_viewsToLink; }
 
 private:
-    std::vector<RimGridView*> m_viewsToLink;
+    std::vector<Rim3dView*> m_viewsToLink;
 };
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/Commands/ViewLink/RicLinkVisibleViewsFeature.cpp

@@ -44,29 +44,18 @@ bool RicLinkVisibleViewsFeature::isCommandEnabled()
     RimProject* proj = RimProject::current();
     if ( !proj ) return false;
 
-    std::vector<Rim3dView*>   visibleViews;
-    std::vector<RimGridView*> linkedviews;
-    std::vector<RimGridView*> visibleGridViews;
-
+    std::vector<Rim3dView*> visibleViews;
     proj->allVisibleViews( visibleViews );
-    for ( Rim3dView* view : visibleViews )
-    {
-        RimGridView* gridView = dynamic_cast<RimGridView*>( view );
-        if ( gridView ) visibleGridViews.push_back( gridView );
-    }
 
+    std::vector<Rim3dView*> linkedviews;
     if ( proj->viewLinkerCollection() && proj->viewLinkerCollection()->viewLinker() )
     {
         linkedviews = proj->viewLinkerCollection()->viewLinker()->allViews();
     }
 
-    if ( visibleGridViews.size() >= 2 && ( linkedviews.size() < visibleGridViews.size() ) )
+    if ( visibleViews.size() >= 2 && ( linkedviews.size() < visibleViews.size() ) )
     {
-        std::vector<RimGridView*> views;
-        findLinkableVisibleViews( views );
-        RicLinkVisibleViewsFeatureUi testUi;
-        testUi.setViews( views );
-        return !testUi.masterViewCandidates().empty();
+        return !findLinkableVisibleViews().empty();
     }
 
     return false;
@@ -77,10 +66,8 @@ bool RicLinkVisibleViewsFeature::isCommandEnabled()
 //--------------------------------------------------------------------------------------------------
 void RicLinkVisibleViewsFeature::onActionTriggered( bool isChecked )
 {
-    std::vector<RimGridView*> linkableViews;
-    findLinkableVisibleViews( linkableViews );
-
-    linkViews( linkableViews );
+    auto linkableViews = findLinkableVisibleViews();
+    RicLinkVisibleViewsFeature::linkViews( linkableViews );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -95,53 +82,50 @@ void RicLinkVisibleViewsFeature::setupActionLook( QAction* actionToSetup )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RicLinkVisibleViewsFeature::findLinkableVisibleViews( std::vector<RimGridView*>& views )
+std::vector<Rim3dView*> RicLinkVisibleViewsFeature::findLinkableVisibleViews()
 {
     RimProject* proj = RimProject::current();
 
-    std::vector<RimGridView*> visibleGridViews;
-    proj->allVisibleGridViews( visibleGridViews );
+    std::vector<Rim3dView*> views;
 
-    for ( auto gridView : visibleGridViews )
+    std::vector<Rim3dView*> candidates;
+    proj->allVisibleViews( candidates );
+
+    for ( auto gridView : candidates )
     {
-        if ( !gridView ) continue;
-        if ( gridView->assosiatedViewLinker() ) continue;
-
-        views.push_back( gridView );
+        if ( gridView && !gridView->assosiatedViewLinker() ) views.push_back( gridView );
     }
+
+    return views;
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RicLinkVisibleViewsFeature::linkViews( std::vector<RimGridView*>& linkableViews )
+void RicLinkVisibleViewsFeature::linkViews( std::vector<Rim3dView*>& linkableViews )
 {
+    if ( linkableViews.empty() ) return;
+
     RimProject*    proj       = RimProject::current();
     RimViewLinker* viewLinker = proj->viewLinkerCollection->viewLinker();
 
-    std::vector<RimGridView*> masterCandidates = linkableViews;
-
     if ( !viewLinker )
     {
-        // Create a new view linker
-
-        RimGridView* masterView = masterCandidates.front();
-
         viewLinker = new RimViewLinker;
 
         proj->viewLinkerCollection()->viewLinker = viewLinker;
-        viewLinker->setMasterView( masterView );
+        viewLinker->setMasterView( linkableViews.front() );
     }
 
-    for ( RimGridView* rimView : linkableViews )
-    {
-        if ( rimView == viewLinker->masterView() ) continue;
+    Rim3dView* primaryView = viewLinker->masterView();
 
-        viewLinker->addDependentView( rimView );
+    auto matchingViews = RicLinkVisibleViewsFeature::matchingViews( primaryView, linkableViews );
+    for ( auto v : matchingViews )
+    {
+        viewLinker->addDependentView( v );
     }
 
     viewLinker->updateDependentViews();
-
     viewLinker->updateUiNameAndIcon();
 
     proj->viewLinkerCollection.uiCapability()->updateConnectedEditors();
@@ -149,3 +133,35 @@ void RicLinkVisibleViewsFeature::linkViews( std::vector<RimGridView*>& linkableV
 
     Riu3DMainWindowTools::setExpanded( proj->viewLinkerCollection() );
 }
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+std::vector<Rim3dView*> RicLinkVisibleViewsFeature::matchingViews( Rim3dView*               primaryView,
+                                                                   std::vector<Rim3dView*>& candidates )
+{
+    if ( !primaryView ) return {};
+
+    std::vector<Rim3dView*> matchingViews;
+
+    RiaDefines::View3dContent primaryContent = primaryView->viewContent();
+    if ( primaryContent == RiaDefines::View3dContent::FLAT_INTERSECTION )
+    {
+        for ( auto v : candidates )
+        {
+            if ( v != primaryView && v->viewContent() == RiaDefines::View3dContent::FLAT_INTERSECTION )
+                matchingViews.emplace_back( v );
+        }
+
+        return matchingViews;
+    }
+
+    // We have a 3D view or contour map as primary view, include all views except flat intersection views
+    for ( auto v : candidates )
+    {
+        if ( v != primaryView && v->viewContent() != RiaDefines::View3dContent::FLAT_INTERSECTION )
+            matchingViews.emplace_back( v );
+    }
+
+    return matchingViews;
+}

ApplicationLibCode/Commands/ViewLink/RicLinkVisibleViewsFeature.h

@@ -23,7 +23,7 @@
 
 #include <vector>
 
-class RimGridView;
+class Rim3dView;
 
 //==================================================================================================
 ///
@@ -33,7 +33,9 @@ class RicLinkVisibleViewsFeature : public caf::CmdFeature
     CAF_CMD_HEADER_INIT;
 
 public:
-    static void linkViews( std::vector<RimGridView*>& views );
+    static void linkViews( std::vector<Rim3dView*>& views );
+
+    static std::vector<Rim3dView*> matchingViews( Rim3dView* primaryView, std::vector<Rim3dView*>& candidates );
 
 protected:
     bool isCommandEnabled() override;
@@ -42,5 +44,5 @@ protected:
     void setupActionLook( QAction* actionToSetup ) override;
 
 private:
-    void findLinkableVisibleViews( std::vector<RimGridView*>& views );
+    static std::vector<Rim3dView*> findLinkableVisibleViews();
 };

ApplicationLibCode/Commands/ViewLink/RicLinkVisibleViewsFeatureUi.cpp

@@ -22,8 +22,8 @@
 #include "RiaApplication.h"
 #include "RiaOptionItemFactory.h"
 
+#include "Rim3dView.h"
 #include "RimCase.h"
-#include "RimGridView.h"
 #include "RimViewLinker.h"
 
 CAF_PDM_SOURCE_INIT( RicLinkVisibleViewsFeatureUi, "RicLinkVisibleViewsFeatureUi" );
@@ -31,7 +31,7 @@ CAF_PDM_SOURCE_INIT( RicLinkVisibleViewsFeatureUi, "RicLinkVisibleViewsFeatureUi
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RicLinkVisibleViewsFeatureUi::RicLinkVisibleViewsFeatureUi( void )
+RicLinkVisibleViewsFeatureUi::RicLinkVisibleViewsFeatureUi()
 {
     CAF_PDM_InitObject( "Link Visible Views Feature UI", ":/LinkView.svg" );
 
@@ -41,46 +41,35 @@ RicLinkVisibleViewsFeatureUi::RicLinkVisibleViewsFeatureUi( void )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RicLinkVisibleViewsFeatureUi::setViews( const std::vector<RimGridView*>& allViews )
+void RicLinkVisibleViewsFeatureUi::setViews( const std::vector<Rim3dView*>& allViews )
 {
     m_allViews = allViews;
 
-    RimGridView* activeView = RiaApplication::instance()->activeGridView();
+    auto activeView = RiaApplication::instance()->activeReservoirView();
 
-    std::vector<RimGridView*> masterCandidates = masterViewCandidates();
-
-    // Set Active view as master view if the active view isn't a contour map.
-    for ( size_t i = 0; i < masterCandidates.size(); i++ )
+    for ( size_t i = 0; i < m_allViews.size(); i++ )
     {
-        if ( activeView == masterCandidates[i] )
+        if ( activeView == m_allViews[i] )
         {
             m_masterView = allViews[i];
         }
     }
 
     // Fallback to use first view if no active view is present
-    if ( !m_masterView && masterCandidates.size() > 0 )
+    if ( !m_masterView && !m_allViews.empty() )
     {
-        m_masterView = masterCandidates[0];
+        m_masterView = m_allViews[0];
     }
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimGridView* RicLinkVisibleViewsFeatureUi::masterView()
+Rim3dView* RicLinkVisibleViewsFeatureUi::masterView()
 {
     return m_masterView;
 }
 
-//--------------------------------------------------------------------------------------------------
-///
-//--------------------------------------------------------------------------------------------------
-std::vector<RimGridView*> RicLinkVisibleViewsFeatureUi::masterViewCandidates() const
-{
-    return m_allViews;
-}
-
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
@@ -91,7 +80,7 @@ QList<caf::PdmOptionItemInfo>
 
     if ( fieldNeedingOptions == &m_masterView )
     {
-        for ( RimGridView* v : masterViewCandidates() )
+        for ( auto v : m_allViews )
         {
             RiaOptionItemFactory::appendOptionItemFromViewNameAndCaseName( v, &options );
         }

ApplicationLibCode/Commands/ViewLink/RicLinkVisibleViewsFeatureUi.h

@@ -25,7 +25,7 @@
 
 #include <vector>
 
-class RimGridView;
+class Rim3dView;
 
 //==================================================================================================
 ///
@@ -37,15 +37,14 @@ class RicLinkVisibleViewsFeatureUi : public caf::PdmObject
 public:
     RicLinkVisibleViewsFeatureUi( void );
 
-    void                      setViews( const std::vector<RimGridView*>& allViews );
-    RimGridView*              masterView();
-    std::vector<RimGridView*> masterViewCandidates() const;
+    void       setViews( const std::vector<Rim3dView*>& allViews );
+    Rim3dView* masterView();
 
 protected:
     QList<caf::PdmOptionItemInfo> calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions ) override;
 
 private:
-    caf::PdmPtrField<RimGridView*> m_masterView;
+    caf::PdmPtrField<Rim3dView*> m_masterView;
 
-    std::vector<RimGridView*> m_allViews;
+    std::vector<Rim3dView*> m_allViews;
 };

ApplicationLibCode/Commands/ViewLink/RicSetMasterViewFeature.cpp

@@ -67,7 +67,7 @@ void RicSetMasterViewFeature::onActionTriggered( bool isChecked )
 
     viewLinker->applyCellFilterCollectionByUserChoice();
 
-    RimGridView* previousMasterView = viewLinker->masterView();
+    auto previousMasterView = viewLinker->masterView();
 
     viewLinker->setMasterView( activeView );
     viewLinker->updateDependentViews();

ApplicationLibCode/Commands/ViewLink/RicUnLinkViewFeature.cpp

@@ -41,8 +41,7 @@ CAF_CMD_SOURCE_INIT( RicUnLinkViewFeature, "RicUnLinkViewFeature" );
 //--------------------------------------------------------------------------------------------------
 bool RicUnLinkViewFeature::isCommandEnabled()
 {
-    Rim3dView* activeView = RiaApplication::instance()->activeMainOrComparisonGridView();
-    ;
+    Rim3dView* activeView = RiaApplication::instance()->activeReservoirView();
     if ( !activeView ) return false;
 
     if ( activeView->assosiatedViewLinker() )
@@ -58,8 +57,7 @@ bool RicUnLinkViewFeature::isCommandEnabled()
 //--------------------------------------------------------------------------------------------------
 void RicUnLinkViewFeature::onActionTriggered( bool isChecked )
 {
-    Rim3dView* activeView = RiaApplication::instance()->activeMainOrComparisonGridView();
-    ;
+    Rim3dView* activeView = RiaApplication::instance()->activeReservoirView();
     if ( !activeView ) return;
 
     RimViewController* viewController = activeView->viewController();
@@ -77,7 +75,7 @@ void RicUnLinkViewFeature::onActionTriggered( bool isChecked )
     {
         viewLinker->applyCellFilterCollectionByUserChoice();
 
-        RimGridView* firstControlledView = viewLinker->firstControlledView();
+        Rim3dView* firstControlledView = viewLinker->firstControlledView();
 
         if ( firstControlledView )
         {

ApplicationLibCode/Commands/WellLogCommands/RicNewWellBoreStabilityPlotFeature.cpp

@@ -110,7 +110,7 @@ RimWellBoreStabilityPlot*
     {
         auto task = progInfo.task( "Updating all tracks", 5 );
 
-        QString templateText = QString( "%1, %2, %3, %4, %5" )
+        QString templateText = QString( "Well Bore Stability: %1, %2, %3, %4, %5" )
                                    .arg( RiaDefines::namingVariableCase() )
                                    .arg( RiaDefines::namingVariableWell() )
                                    .arg( RiaDefines::namingVariableTime() )
@@ -228,6 +228,7 @@ void RicNewWellBoreStabilityPlotFeature::createFormationTrack( RimWellBoreStabil
     formationTrack->setFormationCase( geoMechCase );
     formationTrack->setAnnotationType( RiaDefines::RegionAnnotationType::FORMATION_ANNOTATIONS );
     formationTrack->setVisiblePropertyValueRange( 0.0, 0.0 );
+    formationTrack->enablePropertyAxis( false );
     formationTrack->setColSpan( RimPlot::ONE );
 }
 
@@ -250,6 +251,7 @@ void RicNewWellBoreStabilityPlotFeature::createCasingShoeTrack( RimWellBoreStabi
     casingShoeTrack->setAnnotationTransparency( 90 );
     casingShoeTrack->setWellPathAttributesSource( wellPath );
     casingShoeTrack->setVisiblePropertyValueRange( 0.0, 0.0 );
+    casingShoeTrack->enablePropertyAxis( false );
     casingShoeTrack->setAutoScalePropertyValuesEnabled( true );
     casingShoeTrack->loadDataAndUpdate();
 }