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/Application/RiaDefines.h

@@ -20,6 +20,8 @@
 
 #pragma once
 
+#include "enum_bitmask.hpp"
+
 #include <QString>
 #include <set>
 #include <vector>
@@ -213,18 +215,20 @@ enum class MultiPlotPageUpdateType : uint32_t
     ALL    = 0b00000111
 };
 
-constexpr enum MultiPlotPageUpdateType operator|( const enum MultiPlotPageUpdateType selfValue,
-                                                  const enum MultiPlotPageUpdateType inValue )
-{
-    return ( enum MultiPlotPageUpdateType )( uint32_t( selfValue ) | uint32_t( inValue ) );
-}
-
-constexpr enum MultiPlotPageUpdateType operator&( const enum MultiPlotPageUpdateType selfValue,
-                                                  const enum MultiPlotPageUpdateType inValue )
-{
-    return ( enum MultiPlotPageUpdateType )( uint32_t( selfValue ) & uint32_t( inValue ) );
-}
-
 std::vector<double> viewScaleOptions();
 
+enum class View3dContent
+{
+    NONE              = 0b00000000,
+    ECLIPSE_DATA      = 0b00000001,
+    GEOMECH_DATA      = 0b00000010,
+    FLAT_INTERSECTION = 0b00000100,
+    CONTOUR           = 0b00001000,
+    ALL               = 0b00001111
+};
+
 }; // namespace RiaDefines
+
+// Activate bit mask operators at global scope
+ENABLE_BITMASK_OPERATORS( RiaDefines::MultiPlotPageUpdateType )
+ENABLE_BITMASK_OPERATORS( RiaDefines::View3dContent )

ApplicationLibCode/Application/Tools/RiaRegressionTest.cpp

@@ -83,6 +83,9 @@ RiaRegressionTest::RiaRegressionTest()
 
     CAF_PDM_InitField( &invalidateExternalFilePaths, "invalidateExternalFilePaths", false, "Invalidate External File Paths" );
     CAF_PDM_InitFieldNoDefault( &overridePlotEngine, "forcePlotEngine", "Force Plot Engine" );
+
+    CAF_PDM_InitField( &exportSnapshots3dViews, "exportSnapshots3dViews", true, "Export Snapshots 3D Views" );
+    CAF_PDM_InitField( &exportSnapshotsPlots, "exportSnapshotsPlots", true, "Export Snapshots Plots" );
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/Application/Tools/RiaRegressionTest.h

@@ -53,6 +53,9 @@ public:
     caf::PdmField<bool>    appendTestsAfterTestFilter;
     caf::PdmField<bool>    invalidateExternalFilePaths;
 
+    caf::PdmField<bool> exportSnapshots3dViews;
+    caf::PdmField<bool> exportSnapshotsPlots;
+
     caf::PdmField<caf::AppEnum<PlotEngine>> overridePlotEngine;
 
 protected:

ApplicationLibCode/Application/Tools/RiaRegressionTestRunner.cpp

@@ -238,15 +238,22 @@ void RiaRegressionTestRunner::runRegressionTest()
                 // Wait until all command objects have completed
                 app->waitUntilCommandObjectsHasBeenProcessed();
 
-                setDefaultSnapshotSizeFor3dViews();
-
                 QString fullPathGeneratedFolder = testCaseFolder.absoluteFilePath( generatedFolderName );
-                RicSnapshotAllViewsToFileFeature::exportSnapshotOfViewsIntoFolder( fullPathGeneratedFolder );
+                if ( regressionTestConfig.exportSnapshots3dViews )
+                {
+                    setDefaultSnapshotSizeFor3dViews();
 
-                QApplication::processEvents();
+                    RicSnapshotAllViewsToFileFeature::exportSnapshotOfViewsIntoFolder( fullPathGeneratedFolder );
-                setDefaultSnapshotSizeForPlotWindows();
 
-                RicSnapshotAllPlotsToFileFeature::exportSnapshotOfPlotsIntoFolder( fullPathGeneratedFolder );
+                    QApplication::processEvents();
+                }
+
+                if ( regressionTestConfig.exportSnapshotsPlots )
+                {
+                    setDefaultSnapshotSizeForPlotWindows();
+
+                    RicSnapshotAllPlotsToFileFeature::exportSnapshotOfPlotsIntoFolder( fullPathGeneratedFolder );
+                }
 
                 uint64_t usedMemoryBeforeClose = caf::MemoryInspector::getApplicationPhysicalMemoryUsageMiB();
 

ApplicationLibCode/Application/Tools/enum_bitmask.hpp

@@ -0,0 +1,188 @@
+//////////////////////////////////////////////////
+// Taken from
+// https://gist.github.com/StrikerX3/46b9058d6c61387b3f361ef9d7e00cd4
+//////////////////////////////////////////////////
+
+/*
+Type-safe enum class bitmasks.
+Based on work by Andre Haupt from his blog at
+http://blog.bitwigglers.org/using-enum-classes-as-type-safe-bitmasks/
+To enable enum classes to be used as bitmasks, use the ENABLE_BITMASK_OPERATORS
+macro:
+  enum class MyBitmask {
+     None = 0b0000,
+     One = 0b0001,
+     Two = 0b0010,
+     Three = 0b0100,
+  };
+  ENABLE_BITMASK_OPERATORS(MyBitmask)
+From now on, MyBitmask's values can be used with bitwise operators.
+You may find it cumbersome to check for the presence or absence of specific
+values in enum class bitmasks. For example:
+  MyBitmask bm = ...;
+  MyBitmask oneAndThree = (MyBitmask::One | MyBitmask::Three);
+  // Check if either bit one or three is set
+  if (bm & oneAndThree != MyBitmask::None) {
+      ...
+  }
+  // Check if both bits one and three are set
+  if (bm & oneAndThree == oneAndThree) {
+      ...
+  }
+To help with that, you can wrap the bitmask into the BitmaskEnum type, which
+provides a set of bitmask checks and useful conversions:
+  MyBitmask bm = ...;
+  MyBitmask oneAndThree = (MyBitmask::One | MyBitmask::Three);
+  auto wbm = BitmaskEnum(bm);
+  // Check if either bit one or three is set
+  if (bm.AnyOf(oneAndThree)) {
+      ...
+  }
+  // Check if both bits one and three are set
+  if (bm.AllOf(oneAndThree)) {
+      ...
+  }
+  // Check if any bit is set
+  if (bm) {
+      ...
+  }
+  // Convert back to the enum class
+  MyBitmask backToEnum = wbm;
+-------------------------------------------------------------------------------
+MIT License
+Copyright (c) 2019 Ivan Roberto de Oliveira
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+#pragma once
+
+#include <type_traits>
+
+#define ENABLE_BITMASK_OPERATORS( x )    \
+    template <>                          \
+    struct is_bitmask_enum<x>            \
+    {                                    \
+        static const bool enable = true; \
+    };
+
+template <typename Enum>
+struct is_bitmask_enum
+{
+    static const bool enable = false;
+};
+
+template <class Enum>
+inline constexpr bool is_bitmask_enum_v = is_bitmask_enum<Enum>::enable;
+
+// ----- Bitwise operators ----------------------------------------------------
+
+template <typename Enum>
+typename std::enable_if_t<is_bitmask_enum_v<Enum>, Enum> operator|( Enum lhs, Enum rhs )
+{
+    using underlying = typename std::underlying_type_t<Enum>;
+    return static_cast<Enum>( static_cast<underlying>( lhs ) | static_cast<underlying>( rhs ) );
+}
+
+template <typename Enum>
+typename std::enable_if_t<is_bitmask_enum_v<Enum>, Enum> operator&( Enum lhs, Enum rhs )
+{
+    using underlying = typename std::underlying_type_t<Enum>;
+    return static_cast<Enum>( static_cast<underlying>( lhs ) & static_cast<underlying>( rhs ) );
+}
+
+template <typename Enum>
+typename std::enable_if_t<is_bitmask_enum_v<Enum>, Enum> operator^( Enum lhs, Enum rhs )
+{
+    using underlying = typename std::underlying_type_t<Enum>;
+    return static_cast<Enum>( static_cast<underlying>( lhs ) ^ static_cast<underlying>( rhs ) );
+}
+
+template <typename Enum>
+typename std::enable_if_t<is_bitmask_enum_v<Enum>, Enum> operator~( Enum rhs )
+{
+    using underlying = typename std::underlying_type_t<Enum>;
+    return static_cast<Enum>( ~static_cast<underlying>( rhs ) );
+}
+
+// ----- Bitwise assignment operators -----------------------------------------
+
+template <typename Enum>
+typename std::enable_if_t<is_bitmask_enum_v<Enum>, Enum> operator|=( Enum& lhs, Enum rhs )
+{
+    using underlying = typename std::underlying_type_t<Enum>;
+    lhs              = static_cast<Enum>( static_cast<underlying>( lhs ) | static_cast<underlying>( rhs ) );
+    return lhs;
+}
+
+template <typename Enum>
+typename std::enable_if_t<is_bitmask_enum_v<Enum>, Enum> operator&=( Enum& lhs, Enum rhs )
+{
+    using underlying = typename std::underlying_type_t<Enum>;
+    lhs              = static_cast<Enum>( static_cast<underlying>( lhs ) & static_cast<underlying>( rhs ) );
+    return lhs;
+}
+
+template <typename Enum>
+typename std::enable_if_t<is_bitmask_enum_v<Enum>, Enum> operator^=( Enum& lhs, Enum rhs )
+{
+    using underlying = typename std::underlying_type_t<Enum>;
+    lhs              = static_cast<Enum>( static_cast<underlying>( lhs ) ^ static_cast<underlying>( rhs ) );
+    return lhs;
+}
+
+// ----- Bitwise mask checks --------------------------------------------------
+
+template <typename Enum>
+struct BitmaskEnum
+{
+    const Enum        value;
+    static const Enum none = static_cast<Enum>( 0 );
+
+    using underlying = typename std::underlying_type_t<Enum>;
+
+    BitmaskEnum( Enum value )
+        : value( value )
+    {
+        static_assert( is_bitmask_enum_v<Enum> );
+    }
+
+    // Convert back to enum if required
+    inline operator Enum() const { return value; }
+
+    // Convert to true if there is any bit set in the bitmask
+    inline operator bool() const { return Any(); }
+
+    // Returns true if any bit is set
+    inline bool Any() const { return value != none; }
+
+    // Returns true if all bits are clear
+    inline bool None() const { return value == none; }
+
+    // Returns true if any bit in the given mask is set
+    inline bool AnyOf( const Enum& mask ) const { return ( value & mask ) != none; }
+
+    // Returns true if all bits in the given mask are set
+    inline bool AllOf( const Enum& mask ) const { return ( value & mask ) == mask; }
+
+    // Returns true if none of the bits in the given mask are set
+    inline bool NoneOf( const Enum& mask ) const { return ( value & mask ) == none; }
+
+    // Returns true if any bits excluding the mask are set
+    inline bool AnyExcept( const Enum& mask ) const { return ( value & ~mask ) != none; }
+
+    // Returns true if no bits excluding the mask are set
+    inline bool NoneExcept( const Enum& mask ) const { return ( value & ~mask ) == none; }
+};

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();
+    Rim3dView* activeView = RiaApplication::instance()->activeReservoirView();
-    bool       isComparisonView = ( activeView != RiaApplication::instance()->activeGridView() );
 
     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<Rim3dView*> visibleViews;
-    std::vector<RimGridView*> linkedviews;
-    std::vector<RimGridView*> visibleGridViews;
-
     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;
+        return !findLinkableVisibleViews().empty();
-        findLinkableVisibleViews( views );
-        RicLinkVisibleViewsFeatureUi testUi;
-        testUi.setViews( views );
-        return !testUi.masterViewCandidates().empty();
     }
 
     return false;
@@ -77,10 +66,8 @@ bool RicLinkVisibleViewsFeature::isCommandEnabled()
 //--------------------------------------------------------------------------------------------------
 void RicLinkVisibleViewsFeature::onActionTriggered( bool isChecked )
 {
-    std::vector<RimGridView*> linkableViews;
+    auto linkableViews = findLinkableVisibleViews();
-    findLinkableVisibleViews( linkableViews );
+    RicLinkVisibleViewsFeature::linkViews( linkableViews );
-
-    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;
+    std::vector<Rim3dView*> views;
-    proj->allVisibleGridViews( visibleGridViews );
 
-    for ( auto gridView : visibleGridViews )
+    std::vector<Rim3dView*> candidates;
+    proj->allVisibleViews( candidates );
+
+    for ( auto gridView : candidates )
     {
-        if ( !gridView ) continue;
+        if ( gridView && !gridView->assosiatedViewLinker() ) views.push_back( gridView );
-        if ( gridView->assosiatedViewLinker() ) continue;
-
-        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 )
+    Rim3dView* primaryView = viewLinker->masterView();
-    {
-        if ( rimView == viewLinker->masterView() ) continue;
 
-        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();
+    for ( size_t i = 0; i < m_allViews.size(); i++ )
-
-    // Set Active view as master view if the active view isn't a contour map.
-    for ( size_t i = 0; i < masterCandidates.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 );
+    void       setViews( const std::vector<Rim3dView*>& allViews );
-    RimGridView*              masterView();
+    Rim3dView* masterView();
-    std::vector<RimGridView*> masterViewCandidates() const;
 
 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();
 }

ApplicationLibCode/GeoMech/GeoMechVisualization/RivFemElmVisibilityCalculator.cpp

@@ -257,7 +257,9 @@ void RivFemElmVisibilityCalculator::computeOverriddenCellVisibility( cvf::UByteA
     CVF_ASSERT( elmVisibilities != nullptr );
     CVF_ASSERT( femPart != nullptr );
 
-    RimGridView*              masterView        = masterViewLink->ownerViewLinker()->masterView();
+    RimGridView* masterView = dynamic_cast<RimGridView*>( masterViewLink->ownerViewLinker()->masterView() );
+    if ( !masterView ) return;
+
     cvf::ref<cvf::UByteArray> totCellVisibility = masterView->currentTotalCellVisibility();
 
     int elmCount = femPart->elementCount();

ApplicationLibCode/ModelVisualization/RivReservoirViewPartMgr.cpp

@@ -663,7 +663,8 @@ void RivReservoirViewPartMgr::computeOverriddenCellVisibility( cvf::UByteArray*
 
     CVF_ASSERT( masterViewLink );
 
-    RimGridView* masterView = masterViewLink->ownerViewLinker()->masterView();
+    RimGridView* masterView = dynamic_cast<RimGridView*>( masterViewLink->ownerViewLinker()->masterView() );
+    if ( !masterView ) return;
 
 // get cell visibility
 #if 1

ApplicationLibCode/ProjectDataModel/GeoMech/RimGeoMechContourMapView.cpp

@@ -83,6 +83,14 @@ RimGeoMechContourMapProjection* RimGeoMechContourMapView::contourMapProjection()
     return m_contourMapProjection().p();
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RiaDefines::View3dContent RimGeoMechContourMapView::viewContent() const
+{
+    return ( RiaDefines::View3dContent::GEOMECH_DATA & RiaDefines::View3dContent::CONTOUR );
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/GeoMech/RimGeoMechContourMapView.h

@@ -36,6 +36,8 @@ public:
     RimGeoMechContourMapView();
     RimGeoMechContourMapProjection* contourMapProjection() const;
 
+    RiaDefines::View3dContent viewContent() const override;
+
     QString createAutoName() const override;
     void    setDefaultCustomName();
     void    updatePickPointAndRedraw();

ApplicationLibCode/ProjectDataModel/GeoMech/RimGeoMechView.cpp

@@ -130,6 +130,14 @@ RimGeoMechView::~RimGeoMechView( void )
     delete m_propertyFilterCollection;
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RiaDefines::View3dContent RimGeoMechView::viewContent() const
+{
+    return RiaDefines::View3dContent::GEOMECH_DATA;
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/GeoMech/RimGeoMechView.h

@@ -66,6 +66,8 @@ public:
     RimGeoMechView( void );
     ~RimGeoMechView( void ) override;
 
+    RiaDefines::View3dContent viewContent() const override;
+
     void            setGeoMechCase( RimGeoMechCase* gmCase );
     RimGeoMechCase* geoMechCase() const;
     RimCase*        ownerCase() const override;

ApplicationLibCode/ProjectDataModel/Rim2dIntersectionView.cpp

@@ -31,6 +31,8 @@
 #include "RimRegularLegendConfig.h"
 #include "RimSimWellInView.h"
 #include "RimTernaryLegendConfig.h"
+#include "RimViewController.h"
+#include "RimViewLinker.h"
 #include "RimViewNameConfig.h"
 #include "RimWellPath.h"
 
@@ -101,8 +103,6 @@ Rim2dIntersectionView::Rim2dIntersectionView( void )
     nameConfig()->hideAggregationTypeField( true );
     nameConfig()->hidePropertyField( true );
     nameConfig()->hideSampleSpacingField( true );
-
-    hideComparisonViewField();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -112,6 +112,14 @@ Rim2dIntersectionView::~Rim2dIntersectionView( void )
 {
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RiaDefines::View3dContent Rim2dIntersectionView::viewContent() const
+{
+    return RiaDefines::View3dContent::FLAT_INTERSECTION;
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
@@ -427,16 +435,6 @@ bool Rim2dIntersectionView::handleOverlayItemPicked( const cvf::OverlayItem* pic
     return false;
 }
 
-//--------------------------------------------------------------------------------------------------
-///
-//--------------------------------------------------------------------------------------------------
-QList<caf::PdmOptionItemInfo> Rim2dIntersectionView::calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions )
-{
-    QList<caf::PdmOptionItemInfo> options;
-
-    return options;
-}
-
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
@@ -592,11 +590,13 @@ void Rim2dIntersectionView::onCreateDisplayModel()
 
     m_intersectionVizModel->updateBoundingBoxesRecursive();
 
-    if ( viewer() ) viewer()->setCurrentFrame( m_currentTimeStep );
+    if ( viewer() )
-
-    if ( this->viewer()->mainCamera()->viewMatrix() == sm_defaultViewMatrix )
     {
-        this->zoomAll();
+        viewer()->setCurrentFrame( m_currentTimeStep );
+        if ( viewer()->mainCamera() && viewer()->mainCamera()->viewMatrix() == sm_defaultViewMatrix )
+        {
+            this->zoomAll();
+        }
     }
 }
 
@@ -664,7 +664,7 @@ void Rim2dIntersectionView::onUpdateDisplayModelForCurrentTimeStep()
         }
     }
 
-    if ( this->hasResults() )
+    if ( m_flatIntersectionPartMgr.notNull() && this->hasResults() )
     {
         m_flatIntersectionPartMgr->updateCellResultColor( m_currentTimeStep,
                                                           m_legendConfig->scalarMapper(),

ApplicationLibCode/ProjectDataModel/Rim2dIntersectionView.h

@@ -48,6 +48,8 @@ public:
     Rim2dIntersectionView( void );
     ~Rim2dIntersectionView( void ) override;
 
+    RiaDefines::View3dContent viewContent() const override;
+
     void                          setVisible( bool isVisible );
     void                          setIntersection( RimExtrudedCurveIntersection* intersection );
     RimExtrudedCurveIntersection* intersection() const;
@@ -57,9 +59,6 @@ public:
     RimCase* ownerCase() const override;
     void     selectOverlayInfoConfig() override {}
 
-    RimViewLinker*     assosiatedViewLinker() const override { return nullptr; }
-    RimViewController* viewController() const override { return nullptr; }
-
     bool isTimeStepDependentDataVisible() const override;
 
     void update3dInfo();
@@ -94,7 +93,6 @@ protected:
     void fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue ) override;
     void defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering ) override;
     void defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName = "" ) override;
-    QList<caf::PdmOptionItemInfo> calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions ) override;
 
     bool hasResults();
 

ApplicationLibCode/ProjectDataModel/Rim3dView.cpp

@@ -40,6 +40,7 @@
 #include "RimTools.h"
 #include "RimViewController.h"
 #include "RimViewLinker.h"
+#include "RimViewLinkerCollection.h"
 #include "RimViewManipulator.h"
 #include "RimViewNameConfig.h"
 #include "RimWellPathCollection.h"
@@ -184,6 +185,46 @@ Rim3dView::Rim3dView()
 //--------------------------------------------------------------------------------------------------
 Rim3dView::~Rim3dView()
 {
+    // When a 3d view is destructed, make sure that all other views using this as a comparison view is reset and
+    // redrawn. A crash was seen for test case
+    // "\ResInsight-regression-test\ProjectFiles\ProjectFilesSmallTests\TestCase_CoViz-Simple" when a view used as
+    // comparison view was deleted.
+
+    RimProject* proj = RimProject::current();
+
+    std::vector<Rim3dView*> allViews;
+    proj->allViews( allViews );
+
+    for ( auto v : allViews )
+    {
+        if ( v->activeComparisonView() == this )
+        {
+            v->setComparisonView( nullptr );
+            v->scheduleCreateDisplayModelAndRedraw();
+        }
+    }
+
+    if ( proj && this->isMasterView() )
+    {
+        RimViewLinker* viewLinker = this->assosiatedViewLinker();
+        viewLinker->setMasterView( nullptr );
+
+        delete proj->viewLinkerCollection->viewLinker();
+        proj->viewLinkerCollection->viewLinker = nullptr;
+
+        proj->uiCapability()->updateConnectedEditors();
+    }
+
+    RimViewController* vController = this->viewController();
+    if ( proj && vController )
+    {
+        vController->setManagedView( nullptr );
+        vController->ownerViewLinker()->removeViewController( vController );
+        delete vController;
+
+        proj->uiCapability()->updateConnectedEditors();
+    }
+
     if ( RiaApplication::instance()->activeReservoirView() == this )
     {
         RiaApplication::instance()->setActiveReservoirView( nullptr );
@@ -396,6 +437,43 @@ void Rim3dView::updateMdiWindowTitle()
     }
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RimViewLinker* Rim3dView::assosiatedViewLinker() const
+{
+    RimViewLinker* viewLinker = this->viewLinkerIfMasterView();
+    if ( !viewLinker )
+    {
+        RimViewController* viewController = this->viewController();
+        if ( viewController )
+        {
+            viewLinker = viewController->ownerViewLinker();
+        }
+    }
+
+    return viewLinker;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RimViewController* Rim3dView::viewController() const
+{
+    std::vector<RimViewController*> objects;
+    this->objectsWithReferringPtrFieldsOfType( objects );
+
+    for ( auto v : objects )
+    {
+        if ( v )
+        {
+            return v;
+        }
+    }
+
+    return nullptr;
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
@@ -863,6 +941,13 @@ void Rim3dView::fieldChangedByUi( const caf::PdmFieldHandle* changedField, const
         updateScaling();
 
         RiuMainWindow::instance()->updateScaleValue();
+
+        RimViewLinker* viewLinker = this->assosiatedViewLinker();
+        if ( viewLinker )
+        {
+            viewLinker->updateScaleZ( this, scaleZ() );
+            viewLinker->updateCamera( this );
+        }
     }
     else if ( changedField == &surfaceMode )
     {
@@ -1421,16 +1506,13 @@ QList<caf::PdmOptionItemInfo> Rim3dView::calculateValueOptions( const caf::PdmFi
             proj->allViews( views );
             for ( auto view : views )
             {
-                if ( view != this && dynamic_cast<RimGridView*>( view ) )
+                if ( view != this )
                 {
                     RiaOptionItemFactory::appendOptionItemFromViewNameAndCaseName( view, &options );
                 }
             }
 
-            if ( !options.empty() )
+            options.push_front( caf::PdmOptionItemInfo( "None", nullptr ) );
-            {
-                options.push_front( caf::PdmOptionItemInfo( "None", nullptr ) );
-            }
         }
     }
     else if ( fieldNeedingOptions == &m_fontSize )
@@ -1664,3 +1746,22 @@ void Rim3dView::restoreComparisonView()
     depView->setOverrideViewer( nullptr );
     viewer()->setCurrentComparisonFrame( depView->currentTimeStep() );
 }
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RimViewLinker* Rim3dView::viewLinkerIfMasterView() const
+{
+    std::vector<RimViewLinker*> objects;
+    this->objectsWithReferringPtrFieldsOfType( objects );
+
+    for ( auto viewLinker : objects )
+    {
+        if ( viewLinker )
+        {
+            return viewLinker;
+        }
+    }
+
+    return nullptr;
+}

ApplicationLibCode/ProjectDataModel/Rim3dView.h

@@ -115,6 +115,8 @@ public:
     QString name() const;
     QString autoName() const;
 
+    virtual RiaDefines::View3dContent viewContent() const = 0;
+
     void         setMeshOnlyDrawstyle();
     void         setMeshSurfDrawstyle();
     void         setSurfOnlyDrawstyle();
@@ -180,6 +182,9 @@ public:
     std::set<Rim3dView*> viewsUsingThisAsComparisonView();
     void                 updateMdiWindowTitle() override;
 
+    RimViewLinker*     assosiatedViewLinker() const override;
+    RimViewController* viewController() const override;
+
 protected:
     static void removeModelByName( cvf::Scene* scene, const cvf::String& modelName );
 
@@ -292,6 +297,8 @@ private:
     Rim3dView* prepareComparisonView();
     void       restoreComparisonView();
 
+    RimViewLinker* viewLinkerIfMasterView() const;
+
 private:
     QPointer<RiuViewer> m_viewer;
     QPointer<RiuViewer> m_overrideViewer;

ApplicationLibCode/ProjectDataModel/RimEclipseContourMapView.cpp

@@ -87,6 +87,14 @@ RimEclipseContourMapProjection* RimEclipseContourMapView::contourMapProjection()
     return m_contourMapProjection().p();
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RiaDefines::View3dContent RimEclipseContourMapView::viewContent() const
+{
+    return ( RiaDefines::View3dContent::ECLIPSE_DATA & RiaDefines::View3dContent::CONTOUR );
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/RimEclipseContourMapView.h

@@ -36,6 +36,8 @@ public:
     RimEclipseContourMapView();
     RimEclipseContourMapProjection* contourMapProjection() const;
 
+    RiaDefines::View3dContent viewContent() const override;
+
     QString createAutoName() const override;
     void    setDefaultCustomName();
     void    updatePickPointAndRedraw();

ApplicationLibCode/ProjectDataModel/RimEclipseView.cpp

@@ -245,6 +245,14 @@ RimEclipseView::~RimEclipseView()
     m_eclipseCase = nullptr;
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RiaDefines::View3dContent RimEclipseView::viewContent() const
+{
+    return RiaDefines::View3dContent::ECLIPSE_DATA;
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/RimEclipseView.h

@@ -89,6 +89,8 @@ public:
     RimEclipseView();
     ~RimEclipseView() override;
 
+    RiaDefines::View3dContent viewContent() const override;
+
     RimEclipseCellColors*          cellResult() const;
     RimCellEdgeColors*             cellEdgeResult() const;
     RimElementVectorResult*        elementVectorResult() const;

ApplicationLibCode/ProjectDataModel/RimGridView.cpp

@@ -37,8 +37,6 @@
 #include "RimTextAnnotation.h"
 #include "RimTools.h"
 #include "RimViewController.h"
-#include "RimViewLinker.h"
-#include "RimViewLinkerCollection.h"
 #include "RimViewNameConfig.h"
 #include "RimWellMeasurementCollection.h"
 #include "RimWellMeasurementInViewCollection.h"
@@ -110,35 +108,6 @@ RimGridView::RimGridView()
     m_surfaceVizModel->setName( "SurfaceModel" );
 }
 
-//--------------------------------------------------------------------------------------------------
-///
-//--------------------------------------------------------------------------------------------------
-RimGridView::~RimGridView( void )
-{
-    RimProject* proj = RimProject::current();
-
-    if ( proj && this->isMasterView() )
-    {
-        RimViewLinker* viewLinker = this->assosiatedViewLinker();
-        viewLinker->setMasterView( nullptr );
-
-        delete proj->viewLinkerCollection->viewLinker();
-        proj->viewLinkerCollection->viewLinker = nullptr;
-
-        proj->uiCapability()->updateConnectedEditors();
-    }
-
-    RimViewController* vController = this->viewController();
-    if ( proj && vController )
-    {
-        vController->setManagedView( nullptr );
-        vController->ownerViewLinker()->removeViewController( vController );
-        delete vController;
-
-        proj->uiCapability()->updateConnectedEditors();
-    }
-}
-
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
@@ -306,43 +275,6 @@ void RimGridView::replaceCellFilterCollectionWithOverride()
     this->uiCapability()->updateConnectedEditors();
 }
 
-//--------------------------------------------------------------------------------------------------
-///
-//--------------------------------------------------------------------------------------------------
-RimViewController* RimGridView::viewController() const
-{
-    std::vector<RimViewController*> objects;
-    this->objectsWithReferringPtrFieldsOfType( objects );
-
-    for ( auto v : objects )
-    {
-        if ( v )
-        {
-            return v;
-        }
-    }
-
-    return nullptr;
-}
-
-//--------------------------------------------------------------------------------------------------
-///
-//--------------------------------------------------------------------------------------------------
-RimViewLinker* RimGridView::assosiatedViewLinker() const
-{
-    RimViewLinker* viewLinker = this->viewLinkerIfMasterView();
-    if ( !viewLinker )
-    {
-        RimViewController* viewController = this->viewController();
-        if ( viewController )
-        {
-            viewLinker = viewController->ownerViewLinker();
-        }
-    }
-
-    return viewLinker;
-}
-
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
@@ -472,16 +404,6 @@ void RimGridView::fieldChangedByUi( const caf::PdmFieldHandle* changedField, con
     }
 
     Rim3dView::fieldChangedByUi( changedField, oldValue, newValue );
-
-    if ( changedField == &m_scaleZ )
-    {
-        RimViewLinker* viewLinker = this->assosiatedViewLinker();
-        if ( viewLinker )
-        {
-            viewLinker->updateScaleZ( this, scaleZ() );
-            viewLinker->updateCamera( this );
-        }
-    }
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -524,25 +446,6 @@ void RimGridView::selectOverlayInfoConfig()
     Riu3DMainWindowTools::selectAsCurrentItem( m_overlayInfoConfig );
 }
 
-//--------------------------------------------------------------------------------------------------
-///
-//--------------------------------------------------------------------------------------------------
-RimViewLinker* RimGridView::viewLinkerIfMasterView() const
-{
-    std::vector<RimViewLinker*> objects;
-    this->objectsWithReferringPtrFieldsOfType( objects );
-
-    for ( auto viewLinker : objects )
-    {
-        if ( viewLinker )
-        {
-            return viewLinker;
-        }
-    }
-
-    return nullptr;
-}
-
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/RimGridView.h

@@ -39,7 +39,6 @@ class RimGridView : public Rim3dView
 
 public:
     RimGridView();
-    ~RimGridView( void ) override;
 
     void showGridCells( bool enableGridCells );
 
@@ -64,9 +63,6 @@ public:
     void setOverrideCellFilterCollection( RimCellFilterCollection* rfc );
     void replaceCellFilterCollectionWithOverride();
 
-    RimViewController* viewController() const override;
-    RimViewLinker*     assosiatedViewLinker() const override;
-
     bool isGridVisualizationMode() const override;
 
     void updateWellMeasurements();
@@ -105,6 +101,5 @@ private:
     void onCreatePartCollectionFromSelection( cvf::Collection<cvf::Part>* parts ) override;
 
     cvf::ref<cvf::UByteArray> m_currentReservoirCellVisibility;
-    RimViewLinker*            viewLinkerIfMasterView() const;
     bool                      m_previousGridModeMeshLinesWasFaults;
 };

ApplicationLibCode/ProjectDataModel/RimProject.cpp

@@ -747,12 +747,12 @@ RimSummaryCaseMainCollection* RimProject::firstSummaryCaseMainCollection() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimProject::allNotLinkedViews( std::vector<RimGridView*>& views )
+void RimProject::allNotLinkedViews( std::vector<Rim3dView*>& views )
 {
     std::vector<RimCase*> cases;
     allCases( cases );
 
-    std::vector<RimGridView*> alreadyLinkedViews;
+    std::vector<Rim3dView*> alreadyLinkedViews;
     if ( viewLinkerCollection->viewLinker() )
     {
         alreadyLinkedViews = viewLinkerCollection->viewLinker()->allViews();

ApplicationLibCode/ProjectDataModel/RimProject.h

@@ -141,7 +141,7 @@ public:
     void allViews( std::vector<Rim3dView*>& views ) const;
     void allVisibleViews( std::vector<Rim3dView*>& views ) const;
     void allVisibleGridViews( std::vector<RimGridView*>& views ) const;
-    void allNotLinkedViews( std::vector<RimGridView*>& views );
+    void allNotLinkedViews( std::vector<Rim3dView*>& views );
 
     void scheduleCreateDisplayModelAndRedrawAllViews();
 

ApplicationLibCode/ProjectDataModel/RimViewController.cpp

@@ -95,8 +95,8 @@ RimViewController::RimViewController()
 RimViewController::~RimViewController()
 {
     this->removeOverrides();
-    RimGridView* managedView = m_managedView;
+    auto managedView = m_managedView();
-    m_managedView            = nullptr;
+    m_managedView    = nullptr;
 
     if ( managedView ) managedView->updateAutoName();
 }
@@ -110,8 +110,8 @@ QList<caf::PdmOptionItemInfo> RimViewController::calculateValueOptions( const ca
 
     if ( fieldNeedingOptions == &m_managedView )
     {
-        RimProject*               proj = RimProject::current();
+        RimProject*             proj = RimProject::current();
-        std::vector<RimGridView*> views;
+        std::vector<Rim3dView*> views;
         proj->allNotLinkedViews( views );
 
         // Add currently linked view to list
@@ -124,7 +124,7 @@ QList<caf::PdmOptionItemInfo> RimViewController::calculateValueOptions( const ca
         this->firstAncestorOrThisOfType( viewLinker );
         CVF_ASSERT( viewLinker );
 
-        for ( RimGridView* view : views )
+        for ( auto view : views )
         {
             if ( view != viewLinker->masterView() )
             {
@@ -221,8 +221,6 @@ void RimViewController::fieldChangedByUi( const caf::PdmFieldHandle* changedFiel
         auto*            previousManagedView = dynamic_cast<RimGridView*>( prevValue );
         RimViewController::removeOverrides( previousManagedView );
 
-        ownerViewLinker()->notifyManagedViewChange( previousManagedView, m_managedView() );
-
         setManagedView( m_managedView() );
 
         m_name.uiCapability()->updateConnectedEditors();
@@ -239,9 +237,7 @@ void RimViewController::fieldChangedByUi( const caf::PdmFieldHandle* changedFiel
 //--------------------------------------------------------------------------------------------------
 RimEclipseView* RimViewController::managedEclipseView() const
 {
-    RimGridView* rimView = m_managedView;
+    return dynamic_cast<RimEclipseView*>( m_managedView() );
-
-    return dynamic_cast<RimEclipseView*>( rimView );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -249,9 +245,7 @@ RimEclipseView* RimViewController::managedEclipseView() const
 //--------------------------------------------------------------------------------------------------
 RimGeoMechView* RimViewController::managedGeoView() const
 {
-    RimGridView* rimView = m_managedView;
+    return dynamic_cast<RimGeoMechView*>( m_managedView() );
-
-    return dynamic_cast<RimGeoMechView*>( rimView );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -261,7 +255,7 @@ void RimViewController::updateOverrides()
 {
     RimViewLinker* viewLinker = ownerViewLinker();
 
-    RimGridView* masterView = viewLinker->masterView();
+    auto masterView = viewLinker->masterView();
 
     CVF_ASSERT( masterView );
 
@@ -332,7 +326,7 @@ void RimViewController::updateOverrides()
 //--------------------------------------------------------------------------------------------------
 void RimViewController::removeOverrides()
 {
-    removeOverrides( m_managedView );
+    removeOverrides( dynamic_cast<RimGridView*>( m_managedView() ) );
 
     RimEclipseView* manEclView = managedEclipseView();
     RimGeoMechView* manGeoView = managedGeoView();
@@ -369,7 +363,7 @@ void RimViewController::removeOverrides( RimGridView* view )
 //--------------------------------------------------------------------------------------------------
 void RimViewController::updateOptionSensitivity()
 {
-    RimGridView* mainView = nullptr;
+    Rim3dView* mainView = nullptr;
 
     {
         RimViewLinker* linkedViews = nullptr;
@@ -445,7 +439,7 @@ void RimViewController::updateOptionSensitivity()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimGridView* RimViewController::managedView() const
+Rim3dView* RimViewController::managedView() const
 {
     return m_managedView;
 }
@@ -453,13 +447,8 @@ RimGridView* RimViewController::managedView() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimViewController::setManagedView( RimGridView* view )
+void RimViewController::setManagedView( Rim3dView* view )
 {
-    if ( m_managedView != view )
-    {
-        ownerViewLinker()->notifyManagedViewChange( m_managedView(), view );
-    }
-
     m_managedView = view;
 
     updateOptionSensitivity();
@@ -648,7 +637,7 @@ const RigCaseToCaseCellMapper* RimViewController::cellMapper()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimGridView* RimViewController::masterView() const
+Rim3dView* RimViewController::masterView() const
 {
     return ownerViewLinker()->masterView();
 }
@@ -692,7 +681,8 @@ void RimViewController::scheduleCreateDisplayModelAndRedrawForDependentView() co
 
     if ( this->isResultColorControlled() && this->managedView() )
     {
-        this->managedView()->intersectionCollection()->scheduleCreateDisplayModelAndRedraw2dIntersectionViews();
+        auto gridView = dynamic_cast<RimGridView*>( this->managedView() );
+        if ( gridView ) gridView->intersectionCollection()->scheduleCreateDisplayModelAndRedraw2dIntersectionViews();
     }
 }
 
@@ -930,16 +920,19 @@ bool RimViewController::isPropertyFilterOveridden() const
 //--------------------------------------------------------------------------------------------------
 void RimViewController::updateCellFilterOverrides( const RimCellFilter* changedFilter )
 {
-    if ( !m_managedView ) return;
+    auto controlledGridView = dynamic_cast<RimGridView*>( m_managedView() );
+    if ( !controlledGridView ) return;
 
     if ( !isCellFiltersControlled() )
     {
-        m_managedView->setOverrideCellFilterCollection( nullptr );
+        controlledGridView->setOverrideCellFilterCollection( nullptr );
         return;
     }
     // Copy the rangeFilterCollection
+    auto masterGridView = dynamic_cast<RimGridView*>( masterView() );
+    if ( !masterGridView ) return;
 
-    RimCellFilterCollection* sourceFilterCollection = masterView()->cellFilterCollection();
+    RimCellFilterCollection* sourceFilterCollection = masterGridView->cellFilterCollection();
     QString                  xmlFilterCollCopy      = sourceFilterCollection->writeObjectToXmlString();
     PdmObjectHandle*         objectCopy =
         PdmXmlObjectHandle::readUnknownObjectFromXmlString( xmlFilterCollCopy,
@@ -1041,7 +1034,7 @@ void RimViewController::updateCellFilterOverrides( const RimCellFilter* changedF
         }
     }
 
-    m_managedView->setOverrideCellFilterCollection( overrideFilterColl );
+    controlledGridView->setOverrideCellFilterCollection( overrideFilterColl );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -1057,33 +1050,33 @@ void RimViewController::updatePropertyFilterOverrides( RimPropertyFilter* change
 //--------------------------------------------------------------------------------------------------
 void RimViewController::applyCellFilterCollectionByUserChoice()
 {
-    if ( !m_managedView ) return;
+    auto managedGridView = dynamic_cast<RimGridView*>( m_managedView() );
 
-    if ( !m_managedView->hasOverriddenCellFilterCollection() )
+    if ( !managedGridView ) return;
+
+    if ( !managedGridView->hasOverriddenCellFilterCollection() )
     {
         return;
     }
 
     RimViewLinker* viewLinker = ownerViewLinker();
-    RimGridView*   masterView = viewLinker->masterView();
+    auto*          masterView = dynamic_cast<RimGridView*>( viewLinker->masterView() );
 
-    bool restoreOriginal = true;
+    bool anyActiveFilter = false;
 
-    bool anyActiveFilter = !masterView->cellFilterCollection()->filters().empty() ||
+    if ( masterView )
-                           masterView->propertyFilterCollection()->hasActiveFilters();
-
-    if ( anyActiveFilter )
     {
-        restoreOriginal = askUserToRestoreOriginalCellFilterCollection( m_managedView->name() );
+        anyActiveFilter = !masterView->cellFilterCollection()->filters().empty() ||
+                          masterView->propertyFilterCollection()->hasActiveFilters();
     }
 
-    if ( restoreOriginal )
+    if ( anyActiveFilter && askUserToRestoreOriginalCellFilterCollection( m_managedView->name() ) )
     {
-        m_managedView->setOverrideCellFilterCollection( nullptr );
+        managedGridView->setOverrideCellFilterCollection( nullptr );
     }
     else
     {
-        m_managedView->replaceCellFilterCollectionWithOverride();
+        managedGridView->replaceCellFilterCollectionWithOverride();
     }
 }
 

ApplicationLibCode/ProjectDataModel/RimViewController.h

@@ -29,6 +29,7 @@
 #include "RivCellSetEnum.h"
 
 class RimGridView;
+class Rim3dView;
 class RimEclipseView;
 class RimGeoMechView;
 class RimViewLinker;
@@ -50,10 +51,10 @@ public:
 
     bool isActive() const;
 
-    RimGridView* managedView() const;
+    Rim3dView* managedView() const;
-    void         setManagedView( RimGridView* view );
+    void       setManagedView( Rim3dView* view );
 
-    RimGridView*   masterView() const;
+    Rim3dView*     masterView() const;
     RimViewLinker* ownerViewLinker() const;
 
     const RigCaseToCaseCellMapper* cellMapper();
@@ -109,8 +110,8 @@ private:
     static bool askUserToRestoreOriginalCellFilterCollection( const QString& viewName );
 
 private:
-    caf::PdmField<QString>         m_name;
+    caf::PdmField<QString>       m_name;
-    caf::PdmPtrField<RimGridView*> m_managedView;
+    caf::PdmPtrField<Rim3dView*> m_managedView;
 
     caf::PdmField<bool> m_isActive;
     caf::PdmField<bool> m_syncCamera;

ApplicationLibCode/ProjectDataModel/RimViewLinker.cpp

@@ -19,6 +19,8 @@
 
 #include "RimViewLinker.h"
 
+#include "RiaOptionItemFactory.h"
+
 #include "RigFemResultAddress.h"
 #include "RigMainGrid.h"
 
@@ -43,7 +45,6 @@
 
 #include "RiuViewer.h"
 
-#include "RiaOptionItemFactory.h"
 #include "cafIconProvider.h"
 #include "cafPdmUiTreeOrdering.h"
 #include "cvfCamera.h"
@@ -70,9 +71,6 @@ RimViewLinker::RimViewLinker()
     m_viewControllers.uiCapability()->setUiTreeHidden( true );
     m_viewControllers.uiCapability()->setUiTreeChildrenHidden( true );
 
-    CAF_PDM_InitFieldNoDefault( &m_comparisonView, "LinkedComparisonView", "Comparison View" );
-    m_comparisonView.xmlCapability()->disableIO();
-
     setDeletable( true );
 }
 
@@ -84,15 +82,15 @@ RimViewLinker::~RimViewLinker()
     removeOverrides();
 
     m_viewControllers.deleteChildren();
-    RimGridView* masterView = m_masterView;
+    auto masterView = m_masterView();
-    m_masterView            = nullptr;
+    m_masterView    = nullptr;
     if ( masterView ) masterView->updateAutoName();
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimViewLinker::updateTimeStep( RimGridView* sourceView, int timeStep )
+void RimViewLinker::updateTimeStep( Rim3dView* sourceView, int timeStep )
 {
     CVF_ASSERT( sourceView );
 
@@ -285,7 +283,7 @@ void RimViewLinker::updateScaleWidgetVisibility()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimViewLinker::allViewsForCameraSync( const RimGridView* source, std::vector<RimGridView*>& views ) const
+void RimViewLinker::allViewsForCameraSync( const Rim3dView* source, std::vector<Rim3dView*>& views ) const
 {
     if ( !isActive() ) return;
 
@@ -323,7 +321,7 @@ void RimViewLinker::updateDependentViews()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-QString RimViewLinker::displayNameForView( RimGridView* view )
+QString RimViewLinker::displayNameForView( Rim3dView* view )
 {
     QString displayName = "None";
 
@@ -338,7 +336,7 @@ QString RimViewLinker::displayNameForView( RimGridView* view )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimViewLinker::setMasterView( RimGridView* view )
+void RimViewLinker::setMasterView( Rim3dView* view )
 {
     RimViewController* previousViewController = nullptr;
     if ( view ) previousViewController = view->viewController();
@@ -360,7 +358,7 @@ void RimViewLinker::setMasterView( RimGridView* view )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimGridView* RimViewLinker::masterView() const
+Rim3dView* RimViewLinker::masterView() const
 {
     return m_masterView;
 }
@@ -368,9 +366,9 @@ RimGridView* RimViewLinker::masterView() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<RimGridView*> RimViewLinker::allViews() const
+std::vector<Rim3dView*> RimViewLinker::allViews() const
 {
-    std::vector<RimGridView*> views;
+    std::vector<Rim3dView*> views;
 
     views.push_back( m_masterView() );
 
@@ -391,16 +389,12 @@ std::vector<RimGridView*> RimViewLinker::allViews() const
 void RimViewLinker::initAfterRead()
 {
     updateUiNameAndIcon();
-    if ( m_masterView() )
-    {
-        m_comparisonView = dynamic_cast<RimGridView*>( m_masterView->activeComparisonView() );
-    }
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimViewLinker::updateScaleZ( RimGridView* sourceView, double scaleZ )
+void RimViewLinker::updateScaleZ( Rim3dView* sourceView, double scaleZ )
 {
     if ( !isActive() ) return;
 
@@ -415,7 +409,7 @@ void RimViewLinker::updateScaleZ( RimGridView* sourceView, double scaleZ )
         }
     }
 
-    std::vector<RimGridView*> views;
+    std::vector<Rim3dView*> views;
     allViewsForCameraSync( sourceView, views );
 
     // Make sure scale factors are identical
@@ -450,7 +444,11 @@ bool RimViewLinker::isActive() const
 void RimViewLinker::updateUiNameAndIcon()
 {
     caf::IconProvider iconProvider;
-    RimViewLinker::findNameAndIconFromView( &m_name.v(), &iconProvider, m_masterView );
+
+    QString name;
+    RimViewLinker::findNameAndIconFromView( &name, &iconProvider, m_masterView );
+    name += " (Primary)";
+    m_name.v() = name;
 
     if ( m_masterView ) m_masterView->updateAutoName();
 
@@ -482,7 +480,7 @@ void RimViewLinker::scheduleCreateDisplayModelAndRedrawForDependentViews()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimViewLinker::findNameAndIconFromView( QString* name, caf::IconProvider* icon, RimGridView* view )
+void RimViewLinker::findNameAndIconFromView( QString* name, caf::IconProvider* icon, Rim3dView* view )
 {
     CVF_ASSERT( name && icon );
 
@@ -500,7 +498,7 @@ void RimViewLinker::findNameAndIconFromView( QString* name, caf::IconProvider* i
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimViewLinker::updateCursorPosition( const RimGridView* sourceView, const cvf::Vec3d& domainCoord )
+void RimViewLinker::updateCursorPosition( const Rim3dView* sourceView, const cvf::Vec3d& domainCoord )
 {
     RimViewController* sourceViewLink = sourceView->viewController();
     if ( sourceViewLink && !sourceViewLink->showCursor() )
@@ -508,7 +506,7 @@ void RimViewLinker::updateCursorPosition( const RimGridView* sourceView, const c
         return;
     }
 
-    std::vector<RimGridView*> viewsToUpdate;
+    std::vector<Rim3dView*> viewsToUpdate;
     allViewsForCameraSync( sourceView, viewsToUpdate );
 
     for ( Rim3dView* destinationView : viewsToUpdate )
@@ -531,24 +529,6 @@ void RimViewLinker::updateCursorPosition( const RimGridView* sourceView, const c
     }
 }
 
-//--------------------------------------------------------------------------------------------------
-///
-//--------------------------------------------------------------------------------------------------
-void RimViewLinker::notifyManagedViewChange( RimGridView* oldManagedView, RimGridView* newManagedView )
-{
-    if ( oldManagedView && ( oldManagedView == m_comparisonView ) )
-    {
-        m_comparisonView = newManagedView;
-        m_comparisonView.uiCapability()->updateConnectedEditors();
-
-        if ( masterView() )
-        {
-            masterView()->setComparisonView( m_comparisonView() );
-            masterView()->scheduleCreateDisplayModelAndRedraw();
-        }
-    }
-}
-
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
@@ -569,10 +549,10 @@ QList<caf::PdmOptionItemInfo> RimViewLinker::calculateValueOptions( const caf::P
 {
     QList<caf::PdmOptionItemInfo> options;
 
-    RimGridView* actualComparisonView = nullptr;
+    Rim3dView* actualComparisonView = nullptr;
     if ( m_masterView() )
     {
-        actualComparisonView = dynamic_cast<RimGridView*>( m_masterView->activeComparisonView() );
+        actualComparisonView = m_masterView->activeComparisonView();
     }
 
     bool isActiveCompViewInList = false;
@@ -605,38 +585,9 @@ QList<caf::PdmOptionItemInfo> RimViewLinker::calculateValueOptions( const caf::P
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimViewLinker::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
+void RimViewLinker::updateCamera( Rim3dView* sourceView )
 {
-    // Update the comparison view from the master view
+    if ( !sourceView || !sourceView->viewer() ) return;
-    if ( m_masterView() )
-    {
-        m_comparisonView = dynamic_cast<RimGridView*>( m_masterView->activeComparisonView() );
-    }
-}
-
-//--------------------------------------------------------------------------------------------------
-///
-//--------------------------------------------------------------------------------------------------
-void RimViewLinker::fieldChangedByUi( const caf::PdmFieldHandle* changedField,
-                                      const QVariant&            oldValue,
-                                      const QVariant&            newValue )
-{
-    if ( changedField == &m_comparisonView )
-    {
-        if ( masterView() )
-        {
-            masterView()->setComparisonView( m_comparisonView() );
-            masterView()->scheduleCreateDisplayModelAndRedraw();
-        }
-    }
-}
-
-//--------------------------------------------------------------------------------------------------
-///
-//--------------------------------------------------------------------------------------------------
-void RimViewLinker::updateCamera( RimGridView* sourceView )
-{
-    if ( !sourceView->viewer() ) return;
 
     if ( !isActive() ) return;
 
@@ -649,7 +600,7 @@ void RimViewLinker::updateCamera( RimGridView* sourceView )
         }
     }
 
-    std::vector<RimGridView*> viewsToUpdate;
+    std::vector<Rim3dView*> viewsToUpdate;
     allViewsForCameraSync( sourceView, viewsToUpdate );
 
     RimViewManipulator::applySourceViewCameraOnDestinationViews( sourceView, viewsToUpdate );
@@ -658,7 +609,7 @@ void RimViewLinker::updateCamera( RimGridView* sourceView )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimViewLinker::addDependentView( RimGridView* view )
+void RimViewLinker::addDependentView( Rim3dView* view )
 {
     CVF_ASSERT( view && view != m_masterView );
 
@@ -676,7 +627,7 @@ void RimViewLinker::addDependentView( RimGridView* view )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RimViewLinker::isFirstViewDependentOnSecondView( const RimGridView* firstView, const RimGridView* secondView ) const
+bool RimViewLinker::isFirstViewDependentOnSecondView( const Rim3dView* firstView, const Rim3dView* secondView ) const
 {
     for ( const RimViewController* controller : m_viewControllers() )
     {
@@ -732,7 +683,7 @@ void RimViewLinker::removeViewController( RimViewController* viewController )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimGridView* RimViewLinker::firstControlledView()
+Rim3dView* RimViewLinker::firstControlledView()
 {
     if ( m_viewControllers.empty() ) return nullptr;
 

ApplicationLibCode/ProjectDataModel/RimViewLinker.h

@@ -40,7 +40,7 @@ class BoundingBox;
 
 class RimViewController;
 class RiuViewer;
-class RimGridView;
+class Rim3dView;
 class RimCellFilter;
 class RimPropertyFilter;
 
@@ -58,20 +58,20 @@ public:
 
     bool isActive() const;
 
-    void         setMasterView( RimGridView* view );
+    void       setMasterView( Rim3dView* view );
-    RimGridView* masterView() const;
+    Rim3dView* masterView() const;
-    void         addDependentView( RimGridView* view );
+    void       addDependentView( Rim3dView* view );
-    bool         isFirstViewDependentOnSecondView( const RimGridView* firstView, const RimGridView* secondView ) const;
+    bool       isFirstViewDependentOnSecondView( const Rim3dView* firstView, const Rim3dView* secondView ) const;
-    void         updateDependentViews();
+    void       updateDependentViews();
-    void         removeViewController( RimViewController* viewController );
+    void       removeViewController( RimViewController* viewController );
-    RimGridView* firstControlledView();
+    Rim3dView* firstControlledView();
 
     void updateOverrides();
     void updateWindowTitles();
 
-    void updateCamera( RimGridView* sourceView );
+    void updateCamera( Rim3dView* sourceView );
-    void updateTimeStep( RimGridView* sourceView, int timeStep );
+    void updateTimeStep( Rim3dView* sourceView, int timeStep );
-    void updateScaleZ( RimGridView* sourceView, double scaleZ );
+    void updateScaleZ( Rim3dView* sourceView, double scaleZ );
 
     void updateCellResult();
 
@@ -83,41 +83,35 @@ public:
     void scheduleGeometryRegenForDepViews( RivCellSetEnum geometryType );
     void scheduleCreateDisplayModelAndRedrawForDependentViews();
 
-    std::vector<RimGridView*> allViews() const;
+    std::vector<Rim3dView*> allViews() const;
 
     void updateUiNameAndIcon();
 
     void addViewControllers( caf::PdmUiTreeOrdering& uiTreeOrdering ) const;
 
-    static void findNameAndIconFromView( QString* name, caf::IconProvider* icon, RimGridView* view );
+    static void findNameAndIconFromView( QString* name, caf::IconProvider* icon, Rim3dView* view );
 
-    void updateCursorPosition( const RimGridView* sourceView, const cvf::Vec3d& domainCoord );
+    void updateCursorPosition( const Rim3dView* sourceView, const cvf::Vec3d& domainCoord );
-
-    void notifyManagedViewChange( RimGridView* oldManagedView, RimGridView* newManagedView );
 
 protected:
     caf::PdmFieldHandle* userDescriptionField() override { return &m_name; }
 
     void initAfterRead() override;
-    void fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue ) override;
 
     QList<caf::PdmOptionItemInfo> calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions ) override;
-
+    void                          onChildDeleted( caf::PdmChildArrayFieldHandle*      childArray,
-    void defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering ) override;
+                                                  std::vector<caf::PdmObjectHandle*>& referringObjects ) override;
-    void onChildDeleted( caf::PdmChildArrayFieldHandle*      childArray,
-                         std::vector<caf::PdmObjectHandle*>& referringObjects ) override;
 
 private:
-    static QString displayNameForView( RimGridView* view );
+    static QString displayNameForView( Rim3dView* view );
 
-    void allViewsForCameraSync( const RimGridView* source, std::vector<RimGridView*>& views ) const;
+    void allViewsForCameraSync( const Rim3dView* source, std::vector<Rim3dView*>& views ) const;
 
     void removeOverrides();
     void updateScaleWidgetVisibility();
 
 private:
     caf::PdmChildArrayField<RimViewController*> m_viewControllers;
-    caf::PdmPtrField<RimGridView*>              m_masterView;
+    caf::PdmPtrField<Rim3dView*>                m_masterView;
     caf::PdmField<QString>                      m_name;
-    caf::PdmPtrField<RimGridView*>              m_comparisonView;
 };

ApplicationLibCode/ProjectDataModel/RimViewManipulator.cpp

@@ -34,8 +34,8 @@
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimViewManipulator::applySourceViewCameraOnDestinationViews( RimGridView*                     sourceView,
+void RimViewManipulator::applySourceViewCameraOnDestinationViews( Rim3dView*                     sourceView,
-                                                                  const std::vector<RimGridView*>& destinationViews )
+                                                                  const std::vector<Rim3dView*>& destinationViews )
 {
     bool       setPointOfInterest = false;
     cvf::Vec3d sourceCamUp;
@@ -77,7 +77,7 @@ void RimViewManipulator::applySourceViewCameraOnDestinationViews( RimGridView*
         sourceSceneBB.transform( trans );
     }
 
-    for ( RimGridView* destinationView : destinationViews )
+    for ( auto destinationView : destinationViews )
     {
         if ( !destinationView ) continue;
 

ApplicationLibCode/ProjectDataModel/RimViewManipulator.h

@@ -32,8 +32,8 @@ class Rim3dView;
 class RimViewManipulator
 {
 public:
-    static void       applySourceViewCameraOnDestinationViews( RimGridView*                     sourceView,
+    static void       applySourceViewCameraOnDestinationViews( Rim3dView*                     sourceView,
-                                                               const std::vector<RimGridView*>& destinationViews );
+                                                               const std::vector<Rim3dView*>& destinationViews );
     static cvf::Vec3d calculateEquivalentCamPosOffset( Rim3dView* sourceView, Rim3dView* destView );
 
 private:

ApplicationLibCode/UserInterface/RiuViewer.cpp

@@ -354,24 +354,21 @@ void RiuViewer::slotSetCurrentFrame( int frameIndex )
 {
     setCurrentFrame( frameIndex );
 
-    if ( m_rimView )
+    auto* view = dynamic_cast<Rim3dView*>( m_rimView.p() );
+    if ( view )
     {
-        RimViewLinker* viewLinker = m_rimView->assosiatedViewLinker();
+        RimViewLinker* viewLinker = view->assosiatedViewLinker();
         if ( viewLinker )
         {
-            viewLinker->updateTimeStep( dynamic_cast<RimGridView*>( m_rimView.p() ), frameIndex );
+            viewLinker->updateTimeStep( view, frameIndex );
         }
 
         // Update  views using this as comparison
-        Rim3dView* view = dynamic_cast<Rim3dView*>( m_rimView.p() );
+        std::set<Rim3dView*> containingViews = view->viewsUsingThisAsComparisonView();
-        if ( view )
-        {
-            std::set<Rim3dView*> containingViews = view->viewsUsingThisAsComparisonView();
 
-            for ( auto contView : containingViews )
+        for ( auto contView : containingViews )
-            {
+        {
-                contView->updateDisplayModelForCurrentTimeStepAndRedraw();
+            contView->updateDisplayModelForCurrentTimeStepAndRedraw();
-            }
         }
     }
 }
@@ -982,7 +979,7 @@ void RiuViewer::navigationPolicyUpdate()
         RimViewLinker* viewLinker = m_rimView->assosiatedViewLinker();
         if ( viewLinker )
         {
-            viewLinker->updateCamera( dynamic_cast<RimGridView*>( m_rimView.p() ) );
+            viewLinker->updateCamera( dynamic_cast<Rim3dView*>( m_rimView.p() ) );
         }
     }
 }
@@ -1090,7 +1087,8 @@ void RiuViewer::mouseMoveEvent( QMouseEvent* mouseEvent )
                 cvf::ref<caf::DisplayCoordTransform> trans       = m_rimView->displayCoordTransform();
                 cvf::Vec3d                           domainCoord = trans->transformToDomainCoord( displayCoord );
 
-                viewLinker->updateCursorPosition( dynamic_cast<RimGridView*>( m_rimView.p() ), domainCoord );
+                auto view = dynamic_cast<Rim3dView*>( m_rimView.p() );
+                if ( view ) viewLinker->updateCursorPosition( view, domainCoord );
             }
         }
     }
@@ -1120,7 +1118,9 @@ void RiuViewer::leaveEvent( QEvent* )
     if ( m_rimView && m_rimView->assosiatedViewLinker() )
     {
         RimViewLinker* viewLinker = m_rimView->assosiatedViewLinker();
-        viewLinker->updateCursorPosition( dynamic_cast<RimGridView*>( m_rimView.p() ), cvf::Vec3d::UNDEFINED );
+
+        auto view = dynamic_cast<Rim3dView*>( m_rimView.p() );
+        if ( view ) viewLinker->updateCursorPosition( view, cvf::Vec3d::UNDEFINED );
     }
 }
 

ApplicationLibCode/UserInterface/RiuViewerCommands.cpp

@@ -160,7 +160,7 @@ void RiuViewerCommands::setOwnerView( Rim3dView* owner )
 
 void RiuViewerCommands::addCompareToViewMenu( caf::CmdFeatureMenuBuilder* menuBuilder )
 {
-    RimGridView* mainGridView = dynamic_cast<RimGridView*>( m_reservoirView.p() );
+    auto* mainGridView = m_reservoirView.p();
     if ( mainGridView && !mainGridView->activeComparisonView() )
     {
         std::vector<Rim3dView*> validComparisonViews;
@@ -169,8 +169,6 @@ void RiuViewerCommands::addCompareToViewMenu( caf::CmdFeatureMenuBuilder* menuBu
         RimProject::current()->allViews( views );
         for ( auto view : views )
         {
-            if ( !dynamic_cast<RimGridView*>( view ) ) continue;
-
             if ( view != mainGridView )
             {
                 validComparisonViews.push_back( view );
@@ -596,7 +594,7 @@ void RiuViewerCommands::displayContextMenu( QMouseEvent* event )
     // View Link commands
     if ( !firstHitPart )
     {
-        if ( gridView )
+        if ( gridView || int2dView )
         {
             menuBuilder << "RicLinkViewFeature";
             menuBuilder << "RicShowLinkOptionsFeature";
@@ -605,9 +603,7 @@ void RiuViewerCommands::displayContextMenu( QMouseEvent* event )
             menuBuilder.addSeparator();
             menuBuilder << "RicUnLinkViewFeature";
             menuBuilder << "RicRemoveComparison3dViewFeature";
-        }
+            menuBuilder.addSeparator();
-        else if ( int2dView )
-        {
             menuBuilder << "RicSelectColorResult";
         }
     }
@@ -637,9 +633,6 @@ void RiuViewerCommands::displayContextMenu( QMouseEvent* event )
         menuBuilder << "RicShowGridStatisticsFeature";
         menuBuilder << "RicSelectColorResult";
     }
-    else if ( int2dView )
-    {
-    }
 
     menuBuilder << "RicExportContourMapToTextFeature";