OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-25 18:55:39 -06:00
Code Issues Packages Projects Releases Wiki Activity

Support linking of 2D intersection views

Browse Source 
* 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
This commit is contained in:
Magne Sjaastad 2022-11-24 10:46:54 +01:00 committed by GitHub
parent 99e9944e6e
commit 82968ca1a9
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
42 changed files with 609 additions and 418 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
ApplicationLibCode/Application/RiaDefines.h
View File

@ -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 )

3
ApplicationLibCode/Application/Tools/RiaRegressionTest.cpp
View File

@ -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" );
}
//--------------------------------------------------------------------------------------------------

3
ApplicationLibCode/Application/Tools/RiaRegressionTest.h
View File

@ -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:

19
ApplicationLibCode/Application/Tools/RiaRegressionTestRunner.cpp
View File

@ -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();
setDefaultSnapshotSizeForPlotWindows();
RicSnapshotAllViewsToFileFeature::exportSnapshotOfViewsIntoFolder( fullPathGeneratedFolder );
RicSnapshotAllPlotsToFileFeature::exportSnapshotOfPlotsIntoFolder( fullPathGeneratedFolder );
QApplication::processEvents();
}
if ( regressionTestConfig.exportSnapshotsPlots )
{
setDefaultSnapshotSizeForPlotWindows();
RicSnapshotAllPlotsToFileFeature::exportSnapshotOfPlotsIntoFolder( fullPathGeneratedFolder );
}
uint64_t usedMemoryBeforeClose = caf::MemoryInspector::getApplicationPhysicalMemoryUsageMiB();

188
ApplicationLibCode/Application/Tools/enum_bitmask.hpp Normal file
View File

@ -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; }
};

2
ApplicationLibCode/Commands/FlowCommands/RicShowContributingWellsFeature.cpp
View File

@ -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 );

9
ApplicationLibCode/Commands/RicSelectColorResult.cpp
View File

@ -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 );
}
}

6
ApplicationLibCode/Commands/ViewLink/RicCompareTo3dViewFeature.cpp
View File

@ -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();
}
}

8
ApplicationLibCode/Commands/ViewLink/RicLinkViewFeature.cpp
View File

@ -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;
};
//--------------------------------------------------------------------------------------------------

96
ApplicationLibCode/Commands/ViewLink/RicLinkVisibleViewsFeature.cpp
View File

@ -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;
}

8
ApplicationLibCode/Commands/ViewLink/RicLinkVisibleViewsFeature.h
View File

@ -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();
};

31
ApplicationLibCode/Commands/ViewLink/RicLinkVisibleViewsFeatureUi.cpp
View File

@ -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 );
}

11
ApplicationLibCode/Commands/ViewLink/RicLinkVisibleViewsFeatureUi.h
View File

@ -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;
};

2
ApplicationLibCode/Commands/ViewLink/RicSetMasterViewFeature.cpp
View File

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

8
ApplicationLibCode/Commands/ViewLink/RicUnLinkViewFeature.cpp
View File

@ -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 )
{

4
ApplicationLibCode/Commands/WellLogCommands/RicNewWellBoreStabilityPlotFeature.cpp
View File

@ -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();
}

4
ApplicationLibCode/GeoMech/GeoMechVisualization/RivFemElmVisibilityCalculator.cpp
View File

@ -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();

3
ApplicationLibCode/ModelVisualization/RivReservoirViewPartMgr.cpp
View File

@ -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

8
ApplicationLibCode/ProjectDataModel/GeoMech/RimGeoMechContourMapView.cpp
View File

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

2
ApplicationLibCode/ProjectDataModel/GeoMech/RimGeoMechContourMapView.h
View File

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

8
ApplicationLibCode/ProjectDataModel/GeoMech/RimGeoMechView.cpp
View File

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

2
ApplicationLibCode/ProjectDataModel/GeoMech/RimGeoMechView.h
View File

@ -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;

34
ApplicationLibCode/ProjectDataModel/Rim2dIntersectionView.cpp
View File

@ -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 ( this->viewer()->mainCamera()->viewMatrix() == sm_defaultViewMatrix )
if ( viewer() )
{
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(),

6
ApplicationLibCode/ProjectDataModel/Rim2dIntersectionView.h
View File

@ -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();

111
ApplicationLibCode/ProjectDataModel/Rim3dView.cpp
View File

@ -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;
}

7
ApplicationLibCode/ProjectDataModel/Rim3dView.h
View File

@ -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;

8
ApplicationLibCode/ProjectDataModel/RimEclipseContourMapView.cpp
View File

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

2
ApplicationLibCode/ProjectDataModel/RimEclipseContourMapView.h
View File

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

8
ApplicationLibCode/ProjectDataModel/RimEclipseView.cpp
View File

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

2
ApplicationLibCode/ProjectDataModel/RimEclipseView.h
View File

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

97
ApplicationLibCode/ProjectDataModel/RimGridView.cpp
View File

@ -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;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

5
ApplicationLibCode/ProjectDataModel/RimGridView.h
View File

@ -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;
};

4
ApplicationLibCode/ProjectDataModel/RimProject.cpp
View File

@ -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();

2
ApplicationLibCode/ProjectDataModel/RimProject.h
View File

@ -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();

75
ApplicationLibCode/ProjectDataModel/RimViewController.cpp
View File

@ -95,8 +95,8 @@ RimViewController::RimViewController()
RimViewController::~RimViewController()
{
this->removeOverrides();
RimGridView* managedView = m_managedView;
m_managedView = nullptr;
auto managedView = m_managedView();
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();
std::vector<RimGridView*> views;
RimProject* proj = RimProject::current();
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*>( rimView );
return dynamic_cast<RimEclipseView*>( m_managedView() );
}
//--------------------------------------------------------------------------------------------------
@ -249,9 +245,7 @@ RimEclipseView* RimViewController::managedEclipseView() const
//--------------------------------------------------------------------------------------------------
RimGeoMechView* RimViewController::managedGeoView() const
{
RimGridView* rimView = m_managedView;
return dynamic_cast<RimGeoMechView*>( rimView );
return dynamic_cast<RimGeoMechView*>( m_managedView() );
}
//--------------------------------------------------------------------------------------------------
@ -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() ||
masterView->propertyFilterCollection()->hasActiveFilters();
if ( anyActiveFilter )
if ( masterView )
{
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();
}
}

11
ApplicationLibCode/ProjectDataModel/RimViewController.h
View File

@ -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;
void setManagedView( RimGridView* view );
Rim3dView* managedView() const;
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::PdmPtrField<RimGridView*> m_managedView;
caf::PdmField<QString> m_name;
caf::PdmPtrField<Rim3dView*> m_managedView;
caf::PdmField<bool> m_isActive;
caf::PdmField<bool> m_syncCamera;

107
ApplicationLibCode/ProjectDataModel/RimViewLinker.cpp
View File

@ -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;
m_masterView = nullptr;
auto masterView = m_masterView();
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 ( 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 ( !sourceView || !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;

44
ApplicationLibCode/ProjectDataModel/RimViewLinker.h
View File

@ -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 );
RimGridView* masterView() const;
void addDependentView( RimGridView* view );
bool isFirstViewDependentOnSecondView( const RimGridView* firstView, const RimGridView* secondView ) const;
void updateDependentViews();
void removeViewController( RimViewController* viewController );
RimGridView* firstControlledView();
void setMasterView( Rim3dView* view );
Rim3dView* masterView() const;
void addDependentView( Rim3dView* view );
bool isFirstViewDependentOnSecondView( const Rim3dView* firstView, const Rim3dView* secondView ) const;
void updateDependentViews();
void removeViewController( RimViewController* viewController );
Rim3dView* firstControlledView();
void updateOverrides();
void updateWindowTitles();
void updateCamera( RimGridView* sourceView );
void updateTimeStep( RimGridView* sourceView, int timeStep );
void updateScaleZ( RimGridView* sourceView, double scaleZ );
void updateCamera( Rim3dView* sourceView );
void updateTimeStep( Rim3dView* sourceView, int timeStep );
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 notifyManagedViewChange( RimGridView* oldManagedView, RimGridView* newManagedView );
void updateCursorPosition( const Rim3dView* sourceView, const cvf::Vec3d& domainCoord );
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 defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering ) override;
void onChildDeleted( caf::PdmChildArrayFieldHandle* childArray,
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;
};

6
ApplicationLibCode/ProjectDataModel/RimViewManipulator.cpp
View File

@ -34,8 +34,8 @@
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimViewManipulator::applySourceViewCameraOnDestinationViews( RimGridView* sourceView,
const std::vector<RimGridView*>& destinationViews )
void RimViewManipulator::applySourceViewCameraOnDestinationViews( Rim3dView* sourceView,
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;

4
ApplicationLibCode/ProjectDataModel/RimViewManipulator.h
View File

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

28
ApplicationLibCode/UserInterface/RiuViewer.cpp
View File

@ -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() );
if ( view )
{
std::set<Rim3dView*> containingViews = view->viewsUsingThisAsComparisonView();
std::set<Rim3dView*> containingViews = view->viewsUsingThisAsComparisonView();
for ( auto contView : containingViews )
{
contView->updateDisplayModelForCurrentTimeStepAndRedraw();
}
for ( auto contView : containingViews )
{
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 );
}
}

13
ApplicationLibCode/UserInterface/RiuViewerCommands.cpp
View File

@ -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";
}
else if ( int2dView )
{
menuBuilder.addSeparator();
menuBuilder << "RicSelectColorResult";
}
}
@ -637,9 +633,6 @@ void RiuViewerCommands::displayContextMenu( QMouseEvent* event )
menuBuilder << "RicShowGridStatisticsFeature";
menuBuilder << "RicSelectColorResult";
}
else if ( int2dView )
{
}
menuBuilder << "RicExportContourMapToTextFeature";