#10367 Janitor: Remove unneccessary 'this' pointers

ApplicationLibCode/ProjectDataModel/AnalysisPlots/RimAnalysisPlot.cpp

@@ -188,7 +188,7 @@ RimAnalysisPlot::~RimAnalysisPlot()
 //--------------------------------------------------------------------------------------------------
 void RimAnalysisPlot::updateCaseNameHasChanged()
 {
-    this->onLoadDataAndUpdate();
+    onLoadDataAndUpdate();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -421,7 +421,7 @@ void RimAnalysisPlot::maxMinValueFromAddress( const RifEclipseSummaryAddress&
 //--------------------------------------------------------------------------------------------------
 void RimAnalysisPlot::onFiltersChanged( const caf::SignalEmitter* emitter )
 {
-    this->loadDataAndUpdate();
+    loadDataAndUpdate();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -453,7 +453,7 @@ void RimAnalysisPlot::fieldChangedByUi( const caf::PdmFieldHandle* changedField,
         dlg.enableMultiSelect( true );
         dlg.enableIndividualEnsembleCaseSelection( true );
         dlg.hideEnsembles();
-        dlg.setCurveSelection( this->curveDefinitions() );
+        dlg.setCurveSelection( curveDefinitions() );
 
         if ( dlg.exec() == QDialog::Accepted )
         {
@@ -475,10 +475,10 @@ void RimAnalysisPlot::fieldChangedByUi( const caf::PdmFieldHandle* changedField,
     {
         m_selectedTimeSteps.v().clear();
 
-        this->updateConnectedEditors();
+        updateConnectedEditors();
     }
 
-    this->loadDataAndUpdate();
+    loadDataAndUpdate();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -792,8 +792,8 @@ void RimAnalysisPlot::onLoadDataAndUpdate()
         m_plotWidget->updateLegend();
     }
 
-    this->updateAxes();
-    this->updatePlotTitle();
+    updateAxes();
+    updatePlotTitle();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -1089,7 +1089,7 @@ void RimAnalysisPlot::applyFilter( const RimPlotDataFilterItem*        filter,
         {
             sumItemsToKeep = ( *filteredSummaryItems ); // Not filtering items
 
-            RigEnsembleParameter eParam = this->ensembleParameter( filter->ensembleParameterName() );
+            RigEnsembleParameter eParam = ensembleParameter( filter->ensembleParameterName() );
 
             for ( auto sumCase : ( *filteredSumCases ) )
             {
@@ -1154,7 +1154,7 @@ void RimAnalysisPlot::applyFilter( const RimPlotDataFilterItem*        filter,
         }
         else if ( filter->consideredTimeStepsType() == RimPlotDataFilterItem::PLOT_SOURCE_TIMESTEPS )
         {
-            selectedTimesteps = this->selectedTimeSteps();
+            selectedTimesteps = selectedTimeSteps();
         }
 
         std::function<void( double )> storeResultCoreLambda;
@@ -1626,7 +1626,7 @@ RiaSummaryCurveDefinitionAnalyser* RimAnalysisPlot::getOrCreateSelectedCurveDefA
     {
         m_analyserOfSelectedCurveDefs = std::unique_ptr<RiaSummaryCurveDefinitionAnalyser>( new RiaSummaryCurveDefinitionAnalyser );
     }
-    m_analyserOfSelectedCurveDefs->setCurveDefinitions( this->curveDefinitions() );
+    m_analyserOfSelectedCurveDefs->setCurveDefinitions( curveDefinitions() );
     return m_analyserOfSelectedCurveDefs.get();
 }
 

ApplicationLibCode/ProjectDataModel/AnalysisPlots/RimPlotDataFilterItem.cpp

@@ -243,24 +243,24 @@ void RimPlotDataFilterItem::fieldChangedByUi( const caf::PdmFieldHandle* changed
 {
     if ( changedField == &m_filterTarget )
     {
-        this->updateMaxMinAndDefaultValues( true );
+        updateMaxMinAndDefaultValues( true );
     }
     else if ( changedField == &m_filterQuantityUiField )
     {
         m_filterAddress->setAddress( m_filterQuantityUiField );
-        this->updateMaxMinAndDefaultValues( true );
+        updateMaxMinAndDefaultValues( true );
     }
     else if ( changedField == &m_filterEnsembleParameter )
     {
-        this->updateMaxMinAndDefaultValues( true );
+        updateMaxMinAndDefaultValues( true );
     }
     else if ( changedField == &m_filterOperation )
     {
-        this->updateMaxMinAndDefaultValues( false );
+        updateMaxMinAndDefaultValues( false );
     }
     else if ( changedField == &m_consideredTimestepsType || changedField == &m_explicitlySelectedTimeSteps )
     {
-        this->updateMaxMinAndDefaultValues( false );
+        updateMaxMinAndDefaultValues( false );
     }
     filterChanged.send();
 }

ApplicationLibCode/ProjectDataModel/Annotations/RimPolylinesFromFileAnnotation.cpp

@@ -203,10 +203,10 @@ void RimPolylinesFromFileAnnotation::fieldChangedByUi( const caf::PdmFieldHandle
     if ( changedField == &m_polyLinesFileName )
     {
         QString errorMessage;
-        this->readPolyLinesFile( &errorMessage );
+        readPolyLinesFile( &errorMessage );
         if ( !errorMessage.isEmpty() )
         {
-            QString totalError = "\nError in: " + this->fileName() + "\n\t" + errorMessage;
+            QString totalError = "\nError in: " + fileName() + "\n\t" + errorMessage;
             RiaLogging::errorInMessageBox( nullptr, "Import Polylines", totalError );
         }
     }

ApplicationLibCode/ProjectDataModel/Annotations/RimReachCircleAnnotation.cpp

@@ -145,11 +145,11 @@ void RimReachCircleAnnotation::fieldChangedByUi( const caf::PdmFieldHandle* chan
     if ( changedField == &m_centerPointXyd )
     {
         m_centerPointPickEnabled = false;
-        this->updateConnectedEditors();
+        updateConnectedEditors();
     }
     if ( changedField == &m_centerPointPickEnabled )
     {
-        this->updateConnectedEditors();
+        updateConnectedEditors();
     }
     auto annColl = firstAncestorOrThisOfTypeAsserted<RimAnnotationCollection>();
 

ApplicationLibCode/ProjectDataModel/Annotations/RimTextAnnotation.cpp

@@ -45,7 +45,7 @@ CAF_PDM_SOURCE_INIT( RimTextAnnotation, "RimTextAnnotation" );
 RimTextAnnotation::RimTextAnnotation()
 {
     CAF_PDM_InitObject( "TextAnnotation", ":/TextAnnotation16x16.png" );
-    this->setUi3dEditorTypeName( RicTextAnnotation3dEditor::uiEditorTypeName() );
+    setUi3dEditorTypeName( RicTextAnnotation3dEditor::uiEditorTypeName() );
 
     CAF_PDM_InitField( &m_anchorPointXyd, "AnchorPointXyd", Vec3d::ZERO, "Anchor Point" );
     m_anchorPointXyd.uiCapability()->setUiEditorTypeName( caf::PdmUiPickableLineEditor::uiEditorTypeName() );
@@ -172,16 +172,16 @@ void RimTextAnnotation::fieldChangedByUi( const caf::PdmFieldHandle* changedFiel
         {
             m_labelPointXyd = m_anchorPointXyd;
         }
-        this->updateConnectedEditors();
+        updateConnectedEditors();
     }
     if ( changedField == &m_labelPointXyd )
     {
         m_labelPointPickEnabledButtonField = false;
-        this->updateConnectedEditors();
+        updateConnectedEditors();
     }
     if ( changedField == &m_anchorPointPickEnabledButtonField || changedField == &m_labelPointPickEnabledButtonField )
     {
-        this->updateConnectedEditors();
+        updateConnectedEditors();
     }
 
     auto annColl = firstAncestorOrThisOfTypeAsserted<RimAnnotationCollectionBase>();

ApplicationLibCode/ProjectDataModel/Annotations/RimUserDefinedPolylinesAnnotation.cpp

@@ -59,7 +59,7 @@ RimUserDefinedPolylinesAnnotation::RimUserDefinedPolylinesAnnotation()
     m_targets.uiCapability()->setUiLabelPosition( caf::PdmUiItemInfo::TOP );
     m_targets.uiCapability()->setCustomContextMenuEnabled( true );
 
-    this->setUi3dEditorTypeName( RicPolyline3dEditor::uiEditorTypeName() );
+    setUi3dEditorTypeName( RicPolyline3dEditor::uiEditorTypeName() );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -259,7 +259,7 @@ void RimUserDefinedPolylinesAnnotation::fieldChangedByUi( const caf::PdmFieldHan
 {
     if ( changedField == &m_enablePicking )
     {
-        this->updateConnectedEditors();
+        updateConnectedEditors();
     }
     else if ( changedField == &m_showLines )
     {

ApplicationLibCode/ProjectDataModel/CellFilters/RimCellFilter.cpp

@@ -175,7 +175,7 @@ bool RimCellFilter::propagateToSubGrids() const
 //--------------------------------------------------------------------------------------------------
 void RimCellFilter::updateIconState()
 {
-    caf::IconProvider iconProvider = this->uiIconProvider();
+    caf::IconProvider iconProvider = uiIconProvider();
 
     if ( !iconProvider.valid() ) return;
 
@@ -190,7 +190,7 @@ void RimCellFilter::updateIconState()
 
     iconProvider.setActive( m_isActive && !m_isActive.uiCapability()->isUiReadOnly() );
 
-    this->setUiIcon( iconProvider );
+    setUiIcon( iconProvider );
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/CellFilters/RimCellFilterCollection.cpp

@@ -277,7 +277,7 @@ void RimCellFilterCollection::addFilter( RimCellFilter* pFilter )
     setAutoName( pFilter );
     m_cellFilters.push_back( pFilter );
     connectToFilterUpdates( pFilter );
-    this->updateConnectedEditors();
+    updateConnectedEditors();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/CellFilters/RimCellRangeFilter.cpp

@@ -163,7 +163,7 @@ void RimCellRangeFilter::computeAndSetValidValues()
         cellCountK  = std::clamp( cellCountK.v(), 1, static_cast<int>( grid->cellCountK() ) );
         startIndexK = std::clamp( startIndexK.v(), 1, static_cast<int>( grid->cellCountK() ) );
     }
-    this->updateIconState();
+    updateIconState();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/CellFilters/RimEclipsePropertyFilter.cpp

@@ -125,8 +125,8 @@ RimEclipseResultDefinition* RimEclipsePropertyFilter::resultDefinition() const
 //--------------------------------------------------------------------------------------------------
 void RimEclipsePropertyFilter::rangeValues( double* lower, double* upper ) const
 {
-    *lower = this->m_lowerBound;
-    *upper = this->m_upperBound;
+    *lower = m_lowerBound;
+    *upper = m_upperBound;
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -166,11 +166,11 @@ void RimEclipsePropertyFilter::fieldChangedByUi( const caf::PdmFieldHandle* chan
     {
         m_isDuplicatedFromLinkedView = false;
 
-        this->m_resultDefinition->loadResult();
-        this->computeResultValueRange();
+        m_resultDefinition->loadResult();
+        computeResultValueRange();
         updateFilterName();
-        this->updateIconState();
-        this->uiCapability()->updateConnectedEditors();
+        updateIconState();
+        uiCapability()->updateConnectedEditors();
 
         parentContainer()->updateDisplayModelNotifyManagedViews( this );
     }

ApplicationLibCode/ProjectDataModel/CellFilters/RimGeoMechPropertyFilter.cpp

@@ -80,9 +80,9 @@ void RimGeoMechPropertyFilter::fieldChangedByUi( const caf::PdmFieldHandle* chan
     if ( &lowerBound == changedField || &upperBound == changedField || &m_isActive == changedField || &m_filterMode == changedField ||
          &m_selectedCategoryValues == changedField )
     {
-        this->updateIconState();
-        this->updateFilterName();
-        this->uiCapability()->updateConnectedEditors();
+        updateIconState();
+        updateFilterName();
+        uiCapability()->updateConnectedEditors();
 
         parentContainer()->updateDisplayModelNotifyManagedViews( this );
     }
@@ -118,7 +118,7 @@ void RimGeoMechPropertyFilter::setToDefaultValues()
 
     m_selectedCategoryValues = m_categoryValues;
 
-    this->updateFilterName();
+    updateFilterName();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -213,7 +213,7 @@ void RimGeoMechPropertyFilter::updateActiveState()
 //--------------------------------------------------------------------------------------------------
 bool RimGeoMechPropertyFilter::isActiveAndHasResult()
 {
-    return this->isActive() && this->resultDefinition->hasResult();
+    return isActive() && resultDefinition->hasResult();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/CellFilters/RimPolygonFilter.cpp

@@ -161,8 +161,8 @@ RimPolygonFilter::RimPolygonFilter()
     m_polygonPlaneDepth.uiCapability()->setUiEditorTypeName( caf::PdmUiDoubleSliderEditor::uiEditorTypeName() );
     m_polygonPlaneDepth.uiCapability()->setUiLabelPosition( caf::PdmUiItemInfo::LabelPosType::TOP );
 
-    this->setUi3dEditorTypeName( RicPolyline3dEditor::uiEditorTypeName() );
-    this->uiCapability()->setUiTreeChildrenHidden( true );
+    setUi3dEditorTypeName( RicPolyline3dEditor::uiEditorTypeName() );
+    uiCapability()->setUiTreeChildrenHidden( true );
 
     m_propagateToSubGrids = false;
 
@@ -412,7 +412,7 @@ void RimPolygonFilter::defineUiOrdering( QString uiConfigName, caf::PdmUiOrderin
 
     bool readOnlyState = isFilterControlled();
 
-    std::vector<caf::PdmFieldHandle*> objFields = this->fields();
+    std::vector<caf::PdmFieldHandle*> objFields = fields();
     for ( auto& objField : objFields )
     {
         objField->uiCapability()->setUiReadOnly( readOnlyState );
@@ -426,7 +426,7 @@ void RimPolygonFilter::fieldChangedByUi( const caf::PdmFieldHandle* changedField
 {
     if ( changedField == &m_enablePicking )
     {
-        this->updateConnectedEditors();
+        updateConnectedEditors();
 
         enableFilter( !m_enablePicking() );
         filterChanged.send();
@@ -435,7 +435,7 @@ void RimPolygonFilter::fieldChangedByUi( const caf::PdmFieldHandle* changedField
     {
         updateCells();
         filterChanged.send();
-        this->updateIconState();
+        updateIconState();
     }
 }
 
@@ -487,7 +487,7 @@ void RimPolygonFilter::updateCompundFilter( cvf::CellRangeFilter* cellRangeFilte
     for ( size_t cellidx : m_cells[gridIndex] )
     {
         grid->ijkFromCellIndex( cellidx, &i, &j, &k );
-        if ( this->filterMode() == RimCellFilter::INCLUDE )
+        if ( filterMode() == RimCellFilter::INCLUDE )
         {
             cellRangeFilter->addCellInclude( i, j, k, propagateToSubGrids() );
         }

ApplicationLibCode/ProjectDataModel/CellFilters/RimUserDefinedFilter.cpp

@@ -85,7 +85,7 @@ void RimUserDefinedFilter::updateCompundFilter( cvf::CellRangeFilter* cellRangeF
 
     if ( gridIndex != m_gridIndex ) return;
 
-    if ( this->filterMode() == RimCellFilter::INCLUDE )
+    if ( filterMode() == RimCellFilter::INCLUDE )
     {
         for ( const auto& cellIndex : m_individualCellIndices() )
         {

ApplicationLibCode/ProjectDataModel/Completions/RimEllipseFractureTemplate.cpp

@@ -154,7 +154,7 @@ void RimEllipseFractureTemplate::changeUnits()
         convertToUnitSystem( RiaDefines::EclipseUnitSystem::UNITS_METRIC );
     }
 
-    this->updateConnectedEditors();
+    updateConnectedEditors();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -303,7 +303,7 @@ void RimEllipseFractureTemplate::setDefaultValuesFromUnit()
     // Default to 1/3 of height
     m_wellPathDepthAtFracture = m_height / 3.0;
 
-    this->setDefaultWellDiameterFromUnit();
+    setDefaultWellDiameterFromUnit();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/Completions/RimEnsembleFractureStatistics.cpp

@@ -290,7 +290,7 @@ void RimEnsembleFractureStatistics::fieldChangedByUi( const caf::PdmFieldHandle*
 
 #ifdef USE_QTCHARTS
         // Update referring plots
-        std::vector<caf::PdmObjectHandle*> referringObjects = this->objectsWithReferringPtrFields();
+        std::vector<caf::PdmObjectHandle*> referringObjects = objectsWithReferringPtrFields();
         for ( caf::PdmObjectHandle* obj : referringObjects )
         {
             auto plot = dynamic_cast<RimEnsembleFractureStatisticsPlot*>( obj );

ApplicationLibCode/ProjectDataModel/Completions/RimFishbones.cpp

@@ -152,7 +152,7 @@ bool RimFishbones::isActive() const
 //--------------------------------------------------------------------------------------------------
 QString RimFishbones::generatedName() const
 {
-    caf::PdmChildArrayField<RimFishbones*>* container = dynamic_cast<caf::PdmChildArrayField<RimFishbones*>*>( this->parentField() );
+    caf::PdmChildArrayField<RimFishbones*>* container = dynamic_cast<caf::PdmChildArrayField<RimFishbones*>*>( parentField() );
     CVF_ASSERT( container );
 
     size_t index = container->indexOf( this ) + 1;

ApplicationLibCode/ProjectDataModel/Completions/RimFishbonesCollection.cpp

@@ -43,7 +43,7 @@ RimFishbonesCollection::RimFishbonesCollection()
     CAF_PDM_InitObject( "Fishbones", ":/FishBones16x16.png" );
 
     nameField()->uiCapability()->setUiHidden( true );
-    this->setName( "Fishbones" );
+    setName( "Fishbones" );
 
     CAF_PDM_InitFieldNoDefault( &m_fishbones, "FishbonesSubs", "fishbonesSubs" );
     m_fishbones.uiCapability()->setUiTreeHidden( true );

ApplicationLibCode/ProjectDataModel/Completions/RimFracture.cpp

@@ -206,7 +206,7 @@ std::vector<size_t> RimFracture::getPotentiallyFracturedCells( const RigMainGrid
     std::vector<size_t> cellindecies;
     if ( !mainGrid ) return cellindecies;
 
-    cvf::BoundingBox fractureBBox = this->boundingBoxInDomainCoords();
+    cvf::BoundingBox fractureBBox = boundingBoxInDomainCoords();
 
     mainGrid->findIntersectingCells( fractureBBox, &cellindecies );
 
@@ -279,7 +279,7 @@ void RimFracture::fieldChangedByUi( const caf::PdmFieldHandle* changedField, con
     }
 
     if ( changedField == &m_azimuth || changedField == &m_fractureTemplate || changedField == &m_stimPlanTimeIndexToPlot ||
-         changedField == this->objectToggleField() || changedField == &m_dip || changedField == &m_tilt || changedField == &m_perforationLength )
+         changedField == objectToggleField() || changedField == &m_dip || changedField == &m_tilt || changedField == &m_perforationLength )
     {
         clearCachedNonDarcyProperties();
 
@@ -461,7 +461,7 @@ cvf::BoundingBox RimFracture::boundingBoxInDomainCoords() const
     std::vector<cvf::Vec3f> nodeCoordVec;
     std::vector<cvf::uint>  triangleIndices;
 
-    this->triangleGeometryTransformed( &triangleIndices, &nodeCoordVec, true );
+    triangleGeometryTransformed( &triangleIndices, &nodeCoordVec, true );
 
     cvf::BoundingBox fractureBBox;
     for ( const auto& nodeCoord : nodeCoordVec )
@@ -902,10 +902,10 @@ void RimFracture::setFractureTemplate( RimFractureTemplate* fractureTemplate )
     }
     else
     {
-        this->updateAzimuthBasedOnWellAzimuthAngle();
+        updateAzimuthBasedOnWellAzimuthAngle();
     }
-    this->m_wellDiameter      = fractureTemplate->wellDiameter();
-    this->m_perforationLength = fractureTemplate->perforationLength();
+    m_wellDiameter      = fractureTemplate->wellDiameter();
+    m_perforationLength = fractureTemplate->perforationLength();
 
     clearCachedNonDarcyProperties();
 

ApplicationLibCode/ProjectDataModel/Completions/RimFractureTemplate.cpp

@@ -877,7 +877,7 @@ void RimFractureTemplate::loadDataAndUpdateGeometryHasChanged()
 //--------------------------------------------------------------------------------------------------
 std::vector<RimFracture*> RimFractureTemplate::fracturesUsingThisTemplate() const
 {
-    return this->objectsWithReferringPtrFieldsOfType<RimFracture>();
+    return objectsWithReferringPtrFieldsOfType<RimFracture>();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/Completions/RimMswCompletionParameters.cpp

@@ -290,7 +290,7 @@ void RimMswCompletionParameters::fieldChangedByUi( const caf::PdmFieldHandle* ch
     if ( changedField == &m_refMDType )
     {
         m_refMD.uiCapability()->setUiHidden( m_refMDType == ReferenceMDType::AUTO_REFERENCE_MD );
-        this->updateAllRequiredEditors();
+        updateAllRequiredEditors();
     }
 
     if ( changedField == &m_enforceMaxSegmentLength )

ApplicationLibCode/ProjectDataModel/Completions/RimPerforationCollection.cpp

@@ -43,7 +43,7 @@ RimPerforationCollection::RimPerforationCollection()
     CAF_PDM_InitObject( "Perforations", ":/PerforationIntervals16x16.png" );
 
     nameField()->uiCapability()->setUiHidden( true );
-    this->setName( "Perforations" );
+    setName( "Perforations" );
 
     CAF_PDM_InitFieldNoDefault( &m_perforations, "Perforations", "Perforations" );
     m_perforations.uiCapability()->setUiTreeHidden( true );

ApplicationLibCode/ProjectDataModel/Completions/RimPerforationInterval.cpp

@@ -238,7 +238,7 @@ void RimPerforationInterval::updateAllReferringTracks()
     {
         track->loadDataAndUpdate();
     }
-    this->updateConnectedEditors();
+    updateConnectedEditors();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -320,7 +320,7 @@ void RimPerforationInterval::fieldChangedByUi( const caf::PdmFieldHandle* change
         }
     }
 
-    this->updateAllReferringTracks();
+    updateAllReferringTracks();
 
     RimProject* proj = RimProject::current();
     proj->reloadCompletionTypeResultsInAllViews();
@@ -331,7 +331,7 @@ void RimPerforationInterval::fieldChangedByUi( const caf::PdmFieldHandle* change
 //--------------------------------------------------------------------------------------------------
 void RimPerforationInterval::defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName /*= ""*/ )
 {
-    this->setName( QString( "%1 - %2" ).arg( m_startMD ).arg( m_endMD ) );
+    setName( QString( "%1 - %2" ).arg( m_startMD ).arg( m_endMD ) );
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/Completions/RimSimWellFracture.cpp

@@ -212,7 +212,7 @@ void RimSimWellFracture::updateFracturePositionFromLocation()
     {
         cvf::Vec3d interpolated = m_branchCenterLines[m_branchIndex()].interpolatedPointAlongWellPath( m_location() );
 
-        this->setAnchorPosition( interpolated );
+        setAnchorPosition( interpolated );
 
         RimProject* proj = RimProject::current();
         if ( proj ) proj->scheduleCreateDisplayModelAndRedrawAllViews();

ApplicationLibCode/ProjectDataModel/Completions/RimValveTemplate.cpp

@@ -42,7 +42,7 @@ RimValveTemplate::RimValveTemplate()
     m_type = RiaDefines::WellPathComponentType::ICD;
     CAF_PDM_InitField( &m_userLabel, "UserLabel", QString( "Template" ), "Name" );
 
-    this->setName( fullLabel() );
+    setName( fullLabel() );
 
     CAF_PDM_InitField( &m_orificeDiameter, "OrificeDiameter", 8.0, "Orifice Diameter [mm]" );
     CAF_PDM_InitField( &m_flowCoefficient, "FlowCoefficient", 0.7, "Flow Coefficient" );
@@ -234,7 +234,7 @@ void RimValveTemplate::fieldChangedByUi( const caf::PdmFieldHandle* changedField
 {
     if ( changedField == &m_type || changedField == &m_userLabel )
     {
-        this->setName( fullLabel() );
+        setName( fullLabel() );
     }
     if ( changedField == &m_type )
     {
@@ -252,17 +252,17 @@ void RimValveTemplate::fieldChangedByUi( const caf::PdmFieldHandle* changedField
 //--------------------------------------------------------------------------------------------------
 void RimValveTemplate::defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName /*= ""*/ )
 {
-    this->setName( fullLabel() );
+    setName( fullLabel() );
     if ( m_type() == RiaDefines::WellPathComponentType::ICV )
     {
-        this->setUiIconFromResourceString( ":/ICVValve16x16.png" );
+        setUiIconFromResourceString( ":/ICVValve16x16.png" );
     }
     else if ( m_type() == RiaDefines::WellPathComponentType::ICD )
     {
-        this->setUiIconFromResourceString( ":/ICDValve16x16.png" );
+        setUiIconFromResourceString( ":/ICDValve16x16.png" );
     }
     else if ( m_type() == RiaDefines::WellPathComponentType::AICD )
     {
-        this->setUiIconFromResourceString( ":/AICDValve16x16.png" );
+        setUiIconFromResourceString( ":/AICDValve16x16.png" );
     }
 }

ApplicationLibCode/ProjectDataModel/Completions/RimWellPathFracture.cpp

@@ -246,7 +246,7 @@ void RimWellPathFracture::updatePositionFromMeasuredDepth()
         positionAlongWellpath = wellPathGeometry->interpolatedPointAlongWellPath( m_measuredDepth() );
     }
 
-    this->setAnchorPosition( positionAlongWellpath );
+    setAnchorPosition( positionAlongWellpath );
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/Completions/RimWellPathValve.cpp

@@ -181,33 +181,33 @@ void RimWellPathValve::applyValveLabelAndIcon()
 {
     if ( componentType() == RiaDefines::WellPathComponentType::ICV )
     {
-        this->setUiIconFromResourceString( ":/ICVValve16x16.png" );
+        setUiIconFromResourceString( ":/ICVValve16x16.png" );
         QString fullName = QString( "%1: %2" ).arg( componentLabel() ).arg( m_measuredDepth() );
-        this->setName( fullName );
+        setName( fullName );
     }
     else if ( componentType() == RiaDefines::WellPathComponentType::ICD )
     {
-        this->setUiIconFromResourceString( ":/ICDValve16x16.png" );
+        setUiIconFromResourceString( ":/ICDValve16x16.png" );
         QString fullName = QString( "%1 %2: %3 - %4" )
                                .arg( m_multipleValveLocations->valveLocations().size() )
                                .arg( componentLabel() )
                                .arg( m_multipleValveLocations->rangeStart() )
                                .arg( m_multipleValveLocations->rangeEnd() );
-        this->setName( fullName );
+        setName( fullName );
     }
     else if ( componentType() == RiaDefines::WellPathComponentType::AICD )
     {
-        this->setUiIconFromResourceString( ":/AICDValve16x16.png" );
+        setUiIconFromResourceString( ":/AICDValve16x16.png" );
         QString fullName = QString( "%1 %2: %3 - %4" )
                                .arg( m_multipleValveLocations->valveLocations().size() )
                                .arg( componentLabel() )
                                .arg( m_multipleValveLocations->rangeStart() )
                                .arg( m_multipleValveLocations->rangeEnd() );
-        this->setName( fullName );
+        setName( fullName );
     }
     else
     {
-        this->setName( "Unspecified Valve" );
+        setName( "Unspecified Valve" );
     }
 }
 
@@ -481,7 +481,7 @@ void RimWellPathValve::fieldChangedByUi( const caf::PdmFieldHandle* changedField
     if ( changedField == &m_valveTemplate )
     {
         applyValveLabelAndIcon();
-        this->updateConnectedEditors();
+        updateConnectedEditors();
     }
     else if ( changedField == &m_createValveTemplate )
     {

ApplicationLibCode/ProjectDataModel/CorrelationPlots/RimAbstractCorrelationPlot.cpp

@@ -53,7 +53,7 @@ RimAbstractCorrelationPlot::RimAbstractCorrelationPlot()
     : m_selectMultipleVectors( false )
 {
     CAF_PDM_InitObject( "Abstract Correlation Plot", ":/CorrelationPlot16x16.png" );
-    this->setDeletable( true );
+    setDeletable( true );
 
     CAF_PDM_InitFieldNoDefault( &m_selectedVarsUiField, "SelectedVariableDisplayVar", "Vector" );
     m_selectedVarsUiField.xmlCapability()->disableIO();
@@ -161,8 +161,8 @@ void RimAbstractCorrelationPlot::fieldChangedByUi( const caf::PdmFieldHandle* ch
                     m_dataSources.push_back( plotEntry );
                 }
                 connectAllCaseSignals();
-                this->loadDataAndUpdate();
-                this->updateConnectedEditors();
+                loadDataAndUpdate();
+                updateConnectedEditors();
             }
         }
 
@@ -170,17 +170,17 @@ void RimAbstractCorrelationPlot::fieldChangedByUi( const caf::PdmFieldHandle* ch
     }
     else if ( changedField == &m_timeStep )
     {
-        this->loadDataAndUpdate();
-        this->updateConnectedEditors();
+        loadDataAndUpdate();
+        updateConnectedEditors();
     }
     else if ( changedField == &m_showPlotTitle || changedField == &m_useAutoPlotTitle || changedField == &m_description )
     {
-        this->updatePlotTitle();
+        updatePlotTitle();
     }
     else if ( changedField == &m_labelFontSize || changedField == &m_axisTitleFontSize || changedField == &m_axisValueFontSize ||
               changedField == &m_legendFontSize || changedField == &m_titleFontSize )
     {
-        this->loadDataAndUpdate();
+        loadDataAndUpdate();
     }
     else if ( changedField == &m_timeStepFilter )
     {
@@ -196,17 +196,17 @@ void RimAbstractCorrelationPlot::fieldChangedByUi( const caf::PdmFieldHandle* ch
 
         m_timeStep = allDateTimes[filteredTimeStepIndices.back()];
 
-        this->updateConnectedEditors();
+        updateConnectedEditors();
     }
     else if ( changedField == &m_curveSetForFiltering )
     {
         connectCurveFilterSignals();
 
-        this->loadDataAndUpdate();
+        loadDataAndUpdate();
     }
     else if ( changedField == &m_useCaseFilter )
     {
-        this->loadDataAndUpdate();
+        loadDataAndUpdate();
     }
     else if ( changedField == &m_editCaseFilter )
     {
@@ -370,7 +370,7 @@ RiaSummaryCurveDefinitionAnalyser* RimAbstractCorrelationPlot::getOrCreateSelect
         m_analyserOfSelectedCurveDefs = std::unique_ptr<RiaSummaryCurveDefinitionAnalyser>( new RiaSummaryCurveDefinitionAnalyser );
     }
 
-    m_analyserOfSelectedCurveDefs->setCurveDefinitions( this->curveDefinitions() );
+    m_analyserOfSelectedCurveDefs->setCurveDefinitions( curveDefinitions() );
     return m_analyserOfSelectedCurveDefs.get();
 }
 

ApplicationLibCode/ProjectDataModel/CorrelationPlots/RimCorrelationMatrixPlot.cpp

@@ -171,7 +171,7 @@ RimCorrelationMatrixPlot::RimCorrelationMatrixPlot()
 
     setLegendsVisible( false );
 
-    this->uiCapability()->setUiTreeChildrenHidden( true );
+    uiCapability()->setUiTreeChildrenHidden( true );
     m_selectMultipleVectors = true;
 }
 
@@ -376,8 +376,8 @@ void RimCorrelationMatrixPlot::onLoadDataAndUpdate()
 
         m_plotWidget->qwtPlot()->insertLegend( nullptr );
 
-        this->updateAxes();
-        this->updatePlotTitle();
+        updateAxes();
+        updatePlotTitle();
         m_plotWidget->scheduleReplot();
     }
 }
@@ -387,7 +387,7 @@ void RimCorrelationMatrixPlot::onLoadDataAndUpdate()
 //--------------------------------------------------------------------------------------------------
 void RimCorrelationMatrixPlot::childFieldChangedByUi( const caf::PdmFieldHandle* changedChildField )
 {
-    this->loadDataAndUpdate();
+    loadDataAndUpdate();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/CorrelationPlots/RimCorrelationPlot.cpp

@@ -195,8 +195,8 @@ void RimCorrelationPlot::onLoadDataAndUpdate()
         m_plotWidget->qwtPlot()->insertLegend( nullptr );
         m_plotWidget->updateLegend();
 
-        this->updateAxes();
-        this->updatePlotTitle();
+        updateAxes();
+        updatePlotTitle();
         m_plotWidget->scheduleReplot();
     }
 }

ApplicationLibCode/ProjectDataModel/CorrelationPlots/RimCorrelationReportPlot.cpp

@@ -54,7 +54,7 @@ CAF_PDM_SOURCE_INIT( RimCorrelationReportPlot, "CorrelationReportPlot" );
 RimCorrelationReportPlot::RimCorrelationReportPlot()
 {
     CAF_PDM_InitObject( "Correlation Report Plot", ":/CorrelationReportPlot16x16.png" );
-    this->setDeletable( true );
+    setDeletable( true );
 
     CAF_PDM_InitFieldNoDefault( &m_plotWindowTitle, "PlotWindowTitle", "Title" );
     m_plotWindowTitle.registerGetMethod( this, &RimCorrelationReportPlot::createPlotWindowTitle );
@@ -91,7 +91,7 @@ RimCorrelationReportPlot::RimCorrelationReportPlot()
     m_parameterResultCrossPlot = new RimParameterResultCrossPlot;
     m_parameterResultCrossPlot->setLegendsVisible( true );
 
-    this->uiCapability()->setUiTreeChildrenHidden( true );
+    uiCapability()->setUiTreeChildrenHidden( true );
 
     m_correlationMatrixPlot->matrixCellSelected.connect( this, &RimCorrelationReportPlot::onDataSelection );
     m_correlationPlot->tornadoItemSelected.connect( this, &RimCorrelationReportPlot::onDataSelection );
@@ -367,7 +367,7 @@ void RimCorrelationReportPlot::defineUiOrdering( QString uiConfigName, caf::PdmU
 //--------------------------------------------------------------------------------------------------
 void RimCorrelationReportPlot::fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue )
 {
-    this->loadDataAndUpdate();
+    loadDataAndUpdate();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -375,7 +375,7 @@ void RimCorrelationReportPlot::fieldChangedByUi( const caf::PdmFieldHandle* chan
 //--------------------------------------------------------------------------------------------------
 void RimCorrelationReportPlot::childFieldChangedByUi( const caf::PdmFieldHandle* changedChildField )
 {
-    this->loadDataAndUpdate();
+    loadDataAndUpdate();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/CorrelationPlots/RimParameterResultCrossPlot.cpp

@@ -106,8 +106,8 @@ void RimParameterResultCrossPlot::fieldChangedByUi( const caf::PdmFieldHandle* c
     RimAbstractCorrelationPlot::fieldChangedByUi( changedField, oldValue, newValue );
     if ( changedField == &m_ensembleParameter )
     {
-        this->loadDataAndUpdate();
-        this->updateConnectedEditors();
+        loadDataAndUpdate();
+        updateConnectedEditors();
     }
 }
 
@@ -171,8 +171,8 @@ void RimParameterResultCrossPlot::onLoadDataAndUpdate()
             m_plotWidget->updateLegend();
         }
 
-        this->updateAxes();
-        this->updatePlotTitle();
+        updateAxes();
+        updatePlotTitle();
         m_plotWidget->scheduleReplot();
     }
 }

ApplicationLibCode/ProjectDataModel/Faults/RimFaultInView.cpp

@@ -65,7 +65,7 @@ caf::PdmFieldHandle* RimFaultInView::userDescriptionField()
 //--------------------------------------------------------------------------------------------------
 void RimFaultInView::fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue )
 {
-    this->updateUiIconFromToggleField();
+    updateUiIconFromToggleField();
 
     if ( &faultColor == changedField || &showFault == changedField )
     {
@@ -83,7 +83,7 @@ void RimFaultInView::fieldChangedByUi( const caf::PdmFieldHandle* changedField,
 //--------------------------------------------------------------------------------------------------
 void RimFaultInView::initAfterRead()
 {
-    this->updateUiIconFromToggleField();
+    updateUiIconFromToggleField();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -101,7 +101,7 @@ void RimFaultInView::setFaultGeometry( const RigFault* faultGeometry )
 {
     m_rigFault = faultGeometry;
 
-    this->name = faultGeometry->name();
+    name = faultGeometry->name();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/Faults/RimFaultInViewCollection.cpp

@@ -190,7 +190,7 @@ bool RimFaultInViewCollection::hideNNCsWhenNoResultIsAvailable() const
 //--------------------------------------------------------------------------------------------------
 void RimFaultInViewCollection::fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue )
 {
-    this->updateUiIconFromToggleField();
+    updateUiIconFromToggleField();
 
     if ( &m_faultLabelColor == changedField )
     {
@@ -307,7 +307,7 @@ void RimFaultInViewCollection::syncronizeFaults()
     // Find corresponding fault from data model, or create a new
     for ( size_t fIdx = 0; fIdx < rigFaults.size(); ++fIdx )
     {
-        RimFaultInView* rimFault = this->findFaultByName( rigFaults[fIdx]->name() );
+        RimFaultInView* rimFault = findFaultByName( rigFaults[fIdx]->name() );
 
         if ( !rimFault )
         {

ApplicationLibCode/ProjectDataModel/Flow/RimFlowCharacteristicsPlot.cpp

@@ -102,7 +102,7 @@ RimFlowCharacteristicsPlot::RimFlowCharacteristicsPlot()
     CAF_PDM_InitField( &m_minCommunication, "MinCommunication", 0.0, "Min Communication" );
     CAF_PDM_InitField( &m_maxTof, "MaxTof", 146000, "Max Time of Flight [days]" );
 
-    this->m_showWindow = false;
+    m_showWindow = false;
     setAsPlotMdiWindow();
     setDeletable( true );
 }
@@ -186,7 +186,7 @@ void RimFlowCharacteristicsPlot::updateCurrentTimeStep()
 
     if ( m_currentlyPlottedTimeSteps == calculatedTimesteps ) return;
 
-    this->onLoadDataAndUpdate();
+    onLoadDataAndUpdate();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -599,7 +599,7 @@ void RimFlowCharacteristicsPlot::fieldChangedByUi( const caf::PdmFieldHandle* ch
 
     // All fields update plot
 
-    this->onLoadDataAndUpdate();
+    onLoadDataAndUpdate();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/Flow/RimFlowPlotCollection.cpp

@@ -164,7 +164,7 @@ RimWellConnectivityTable* RimFlowPlotCollection::defaultWellConnectivityTable()
         m_defaultWellConnectivityTable = new RimWellConnectivityTable;
     }
 
-    this->updateConnectedEditors();
+    updateConnectedEditors();
 
     return m_defaultWellConnectivityTable;
 }
@@ -180,7 +180,7 @@ RimWellAllocationOverTimePlot* RimFlowPlotCollection::defaultWellAllocOverTimePl
         m_defaultWellAllocOverTimePlot->setDescription( "Default Well Allocation Over Time Plot" );
     }
 
-    this->updateConnectedEditors();
+    updateConnectedEditors();
 
     return m_defaultWellAllocOverTimePlot();
 }
@@ -196,7 +196,7 @@ RimWellAllocationPlot* RimFlowPlotCollection::defaultWellAllocPlot()
         m_defaultWellAllocPlot->setDescription( "Default Flow Diagnostics Plot" );
     }
 
-    this->updateConnectedEditors();
+    updateConnectedEditors();
 
     return m_defaultWellAllocPlot();
 }
@@ -211,7 +211,7 @@ RimFlowCharacteristicsPlot* RimFlowPlotCollection::defaultFlowCharacteristicsPlo
         m_flowCharacteristicsPlot = new RimFlowCharacteristicsPlot;
     }
 
-    this->updateConnectedEditors();
+    updateConnectedEditors();
 
     return m_flowCharacteristicsPlot();
 }

ApplicationLibCode/ProjectDataModel/Flow/RimTofAccumulatedPhaseFractionsPlot.cpp

@@ -199,7 +199,7 @@ QImage RimTofAccumulatedPhaseFractionsPlot::snapshotWindowContent()
 void RimTofAccumulatedPhaseFractionsPlot::setDescription( const QString& description )
 {
     m_userName = description;
-    this->updateMdiWindowTitle();
+    updateMdiWindowTitle();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/Flow/RimTotalWellAllocationPlot.cpp

@@ -156,7 +156,7 @@ QImage RimTotalWellAllocationPlot::snapshotWindowContent()
 void RimTotalWellAllocationPlot::setDescription( const QString& description )
 {
     m_userName = description;
-    this->updateMdiWindowTitle();
+    updateMdiWindowTitle();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/Flow/RimWellAllocationPlot.cpp

@@ -120,7 +120,7 @@ RimWellAllocationPlot::RimWellAllocationPlot()
     m_tofAccumulatedPhaseFractionsPlot.uiCapability()->setUiTreeHidden( true );
     m_tofAccumulatedPhaseFractionsPlot = new RimTofAccumulatedPhaseFractionsPlot;
 
-    this->setAsPlotMdiWindow();
+    setAsPlotMdiWindow();
 
     m_accumulatedWellFlowPlot->setAvailableDepthUnits( {} );
     m_accumulatedWellFlowPlot->setAvailableDepthTypes( { RiaDefines::DepthTypeEnum::CONNECTION_NUMBER,
@@ -631,7 +631,7 @@ QList<caf::PdmOptionItemInfo> RimWellAllocationPlot::calculateValueOptions( cons
 
     if ( fieldNeedingOptions == &m_wellName )
     {
-        std::set<QString> sortedWellNames = this->findSortedWellNames();
+        std::set<QString> sortedWellNames = findSortedWellNames();
 
         caf::IconProvider simWellIcon( ":/Well.svg" );
         for ( const QString& wname : sortedWellNames )

ApplicationLibCode/ProjectDataModel/Flow/RimWellFlowRateCurve.cpp

@@ -159,7 +159,7 @@ QString RimWellFlowRateCurve::createCurveAutoName()
 //--------------------------------------------------------------------------------------------------
 void RimWellFlowRateCurve::onLoadDataAndUpdate( bool updateParentPlot )
 {
-    this->RimPlotCurve::updateCurvePresentation( updateParentPlot );
+    RimPlotCurve::updateCurvePresentation( updateParentPlot );
 
     m_plotCurve->setTitle( createCurveAutoName() );
 
@@ -185,7 +185,7 @@ void RimWellFlowRateCurve::updateCurveAppearance()
     {
         auto                                         wellLogTrack       = firstAncestorOrThisOfTypeAsserted<RimWellLogTrack>();
         std::map<int, std::vector<RimWellLogCurve*>> stackedCurveGroups = wellLogTrack->visibleStackedCurves();
-        const std::vector<RimWellLogCurve*>&         curveGroup         = stackedCurveGroups[this->m_groupId];
+        const std::vector<RimWellLogCurve*>&         curveGroup         = stackedCurveGroups[m_groupId];
 
         if ( !curveGroup.empty() )
         {
@@ -288,7 +288,7 @@ void RimWellFlowRateCurve::setFlowValuesPrDepthValue( const QString&
                                                       const std::vector<double>& flowRates )
 {
     bool useLogarithmicScale = false;
-    this->setPropertyValuesAndDepths( flowRates, depthValues, depthType, 0.0, RiaDefines::DepthUnitType::UNIT_NONE, false, useLogarithmicScale );
+    setPropertyValuesAndDepths( flowRates, depthValues, depthType, 0.0, RiaDefines::DepthUnitType::UNIT_NONE, false, useLogarithmicScale );
 
     m_curveAutoName = curveName;
 }

ApplicationLibCode/ProjectDataModel/Flow/RimWellPltPlot.cpp

@@ -134,7 +134,7 @@ RimWellPltPlot::RimWellPltPlot()
     m_nameConfig->setCustomName( "PLT Plot" );
     setNamingMethod( RiaDefines::ObjectNamingMethod::CUSTOM );
 
-    this->setAsPlotMdiWindow();
+    setAsPlotMdiWindow();
     m_doInitAfterLoad       = false;
     m_isOnLoad              = true;
     m_plotLegendsHorizontal = false;

ApplicationLibCode/ProjectDataModel/Flow/RimWellRftPlot.cpp

@@ -133,7 +133,7 @@ RimWellRftPlot::RimWellRftPlot()
 
     setPlotTitleVisible( true );
 
-    this->setAsPlotMdiWindow();
+    setAsPlotMdiWindow();
     m_isOnLoad = true;
 }
 
@@ -534,7 +534,7 @@ void RimWellRftPlot::updateCurvesInPlot( const std::set<RiaRftPltCurveDefinition
             auto rftCase = curveDefToAdd.address().summaryCase();
             curve->setSummaryCase( rftCase );
             curve->setEnsemble( curveDefToAdd.address().ensemble() );
-            curve->setObservedFmuRftData( this->findObservedFmuData( m_wellPathNameOrSimWellName, curveDefToAdd.timeStep() ) );
+            curve->setObservedFmuRftData( findObservedFmuData( m_wellPathNameOrSimWellName, curveDefToAdd.timeStep() ) );
             RifEclipseRftAddress address = RifEclipseRftAddress::createAddress( m_wellPathNameOrSimWellName,
                                                                                 curveDefToAdd.timeStep(),
                                                                                 RifEclipseRftAddress::RftWellLogChannelType::PRESSURE );
@@ -578,7 +578,7 @@ void RimWellRftPlot::updateCurvesInPlot( const std::set<RiaRftPltCurveDefinition
                     plotTrack->addCurve( curve );
                     curve->setEnsemble( ensemble );
                     curve->setRftAddress( rftAddress );
-                    curve->setObservedFmuRftData( this->findObservedFmuData( m_wellPathNameOrSimWellName, curveDefToAdd.timeStep() ) );
+                    curve->setObservedFmuRftData( findObservedFmuData( m_wellPathNameOrSimWellName, curveDefToAdd.timeStep() ) );
                     curve->setZOrder( RiuQwtPlotCurveDefines::zDepthForIndex( RiuQwtPlotCurveDefines::ZIndex::Z_ENSEMBLE_STAT_CURVE ) );
                     applyCurveAppearance( curve );
                     auto                              symbol   = statisticsCurveSymbolFromAddress( rftAddress );
@@ -953,7 +953,7 @@ void RimWellRftPlot::fieldChangedByUi( const caf::PdmFieldHandle* changedField,
     {
         updateFormationsOnPlot();
         syncCurvesFromUiSelection();
-        this->updateConnectedEditors();
+        updateConnectedEditors();
     }
     else if ( changedField == &m_showStatisticsCurves || changedField == &m_showEnsembleCurves || changedField == &m_showErrorInObservedData )
     {

ApplicationLibCode/ProjectDataModel/GeoMech/RimGeoMechCase.cpp

@@ -170,15 +170,15 @@ RimGeoMechCase::~RimGeoMechCase()
             RimWellLogPlotCollection* plotCollection = project->mainPlotCollection()->wellLogPlotCollection();
             if ( plotCollection )
             {
-                plotCollection->removeExtractors( this->geoMechData() );
+                plotCollection->removeExtractors( geoMechData() );
             }
         }
     }
 
-    if ( this->geoMechData() )
+    if ( geoMechData() )
     {
         // At this point, we assume that memory should be released
-        CVF_ASSERT( this->geoMechData()->refCount() == 1 );
+        CVF_ASSERT( geoMechData()->refCount() == 1 );
     }
 }
 
@@ -203,11 +203,11 @@ const RigGeoMechCaseData* RimGeoMechCase::geoMechData() const
 //--------------------------------------------------------------------------------------------------
 void RimGeoMechCase::reloadDataAndUpdate()
 {
-    if ( this->geoMechData() )
+    if ( geoMechData() )
     {
         m_geoMechCaseData = nullptr;
         std::string errMsg;
-        if ( this->openGeoMechCase( &errMsg ) == CASE_OPEN_ERROR )
+        if ( openGeoMechCase( &errMsg ) == CASE_OPEN_ERROR )
         {
             RiaLogging::error( QString::fromStdString( errMsg ) );
         }
@@ -268,7 +268,7 @@ RimGeoMechCase* RimGeoMechCase::createCopy( const QString& newInputFileName )
     RimProject* project = RimProject::current();
 
     RimGeoMechCase* copycase =
-        dynamic_cast<RimGeoMechCase*>( this->xmlCapability()->copyByXmlSerialization( caf::PdmDefaultObjectFactory::instance() ) );
+        dynamic_cast<RimGeoMechCase*>( xmlCapability()->copyByXmlSerialization( caf::PdmDefaultObjectFactory::instance() ) );
     CVF_ASSERT( copycase );
 
     QFileInfo filenameInfo( newInputFileName );
@@ -288,7 +288,7 @@ RimGeoMechCase* RimGeoMechCase::createCopy( const QString& newInputFileName )
 RimGeoMechCase::CaseOpenStatus RimGeoMechCase::openGeoMechCase( std::string* errorMessage )
 {
     // If read already, return
-    if ( this->m_geoMechCaseData.notNull() ) return CASE_OPEN_OK;
+    if ( m_geoMechCaseData.notNull() ) return CASE_OPEN_OK;
 
     if ( !caf::Utils::fileExists( m_caseFileName().path() ) )
     {
@@ -495,7 +495,7 @@ cvf::BoundingBox RimGeoMechCase::reservoirBoundingBox()
 {
     cvf::BoundingBox boundingBox;
 
-    RigGeoMechCaseData* rigCaseData = this->geoMechData();
+    RigGeoMechCaseData* rigCaseData = geoMechData();
     if ( rigCaseData && rigCaseData->femPartResults() && rigCaseData->femParts() )
     {
         for ( int p = 0; p < rigCaseData->femParts()->partCount(); p++ )
@@ -592,7 +592,7 @@ void RimGeoMechCase::addElementPropertyFiles( const std::vector<caf::FilePath>&
         }
     }
 
-    this->updateConnectedEditors();
+    updateConnectedEditors();
 
     if ( m_geoMechCaseData.notNull() )
     {
@@ -686,10 +686,10 @@ void RimGeoMechCase::setApplyTimeFilter( bool applyTimeFilter )
 //--------------------------------------------------------------------------------------------------
 cvf::Vec3d RimGeoMechCase::displayModelOffset() const
 {
-    auto bb = this->allCellsBoundingBox();
+    auto bb = allCellsBoundingBox();
     if ( bb.isValid() )
     {
-        return this->allCellsBoundingBox().min();
+        return allCellsBoundingBox().min();
     }
 
     return cvf::Vec3d::ZERO;

ApplicationLibCode/ProjectDataModel/GeoMech/RimGeoMechCellColors.cpp

@@ -33,7 +33,7 @@ RimGeoMechCellColors::RimGeoMechCellColors()
     : legendConfigChanged( this )
 {
     CAF_PDM_InitFieldNoDefault( &legendConfig, "LegendDefinition", "Color Legend" );
-    this->legendConfig = new RimRegularLegendConfig();
+    legendConfig = new RimRegularLegendConfig();
     legendConfig.uiCapability()->setUiTreeHidden( true );
     legendConfig->changed.connect( this, &RimGeoMechCellColors::onLegendConfigChanged );
 }
@@ -82,7 +82,7 @@ void RimGeoMechCellColors::initAfterRead()
 //--------------------------------------------------------------------------------------------------
 void RimGeoMechCellColors::updateLegendCategorySettings()
 {
-    if ( this->hasCategoryResult() )
+    if ( hasCategoryResult() )
     {
         legendConfig->setMappingMode( RimRegularLegendConfig::MappingType::CATEGORY_INTEGER );
         legendConfig->setColorLegend( RimRegularLegendConfig::mapToColorLegend( RimRegularLegendConfig::ColorRangesType::CATEGORY ) );

ApplicationLibCode/ProjectDataModel/GeoMech/RimGeoMechContourMapView.cpp

@@ -195,15 +195,15 @@ void RimGeoMechContourMapView::onCreateDisplayModel()
 {
     RimGeoMechView::onCreateDisplayModel();
 
-    if ( !this->isTimeStepDependentDataVisible() )
+    if ( !isTimeStepDependentDataVisible() )
     {
         // Need to add geometry even if it hasn't happened during dynamic time step update.
         updateGeometry();
     }
 
-    if ( this->viewer()->mainCamera()->viewMatrix() == sm_defaultViewMatrix )
+    if ( viewer()->mainCamera()->viewMatrix() == sm_defaultViewMatrix )
     {
-        this->zoomAll();
+        zoomAll();
     }
 }
 
@@ -213,8 +213,8 @@ void RimGeoMechContourMapView::onCreateDisplayModel()
 void RimGeoMechContourMapView::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
 {
     caf::PdmUiGroup* viewGroup = uiOrdering.addNewGroup( "Viewer" );
-    viewGroup->add( this->userDescriptionField() );
-    viewGroup->add( this->backgroundColorField() );
+    viewGroup->add( userDescriptionField() );
+    viewGroup->add( backgroundColorField() );
     viewGroup->add( &m_showAxisLines );
     viewGroup->add( &m_showScaleLegend );
 
@@ -305,7 +305,7 @@ void RimGeoMechContourMapView::appendContourMapProjectionToModel()
             cvf::ref<cvf::ModelBasicList> contourMapProjectionModelBasicList = new cvf::ModelBasicList;
             contourMapProjectionModelBasicList->setName( name );
 
-            cvf::ref<caf::DisplayCoordTransform> transForm = this->displayCoordTransform();
+            cvf::ref<caf::DisplayCoordTransform> transForm = displayCoordTransform();
 
             m_contourMapProjectionPartMgr->appendProjectionToModel( contourMapProjectionModelBasicList.p(), transForm.p() );
             contourMapProjectionModelBasicList->updateBoundingBoxesRecursive();
@@ -330,7 +330,7 @@ void RimGeoMechContourMapView::appendContourLinesToModel()
             cvf::ref<cvf::ModelBasicList> contourMapLabelModelBasicList = new cvf::ModelBasicList;
             contourMapLabelModelBasicList->setName( name );
 
-            cvf::ref<caf::DisplayCoordTransform> transForm = this->displayCoordTransform();
+            cvf::ref<caf::DisplayCoordTransform> transForm = displayCoordTransform();
 
             m_contourMapProjectionPartMgr->appendContourLinesToModel( viewer()->mainCamera(), contourMapLabelModelBasicList.p(), transForm.p() );
             contourMapLabelModelBasicList->updateBoundingBoxesRecursive();
@@ -355,7 +355,7 @@ void RimGeoMechContourMapView::appendPickPointVisToModel()
             cvf::ref<cvf::ModelBasicList> contourMapProjectionModelBasicList = new cvf::ModelBasicList;
             contourMapProjectionModelBasicList->setName( name );
 
-            cvf::ref<caf::DisplayCoordTransform> transForm = this->displayCoordTransform();
+            cvf::ref<caf::DisplayCoordTransform> transForm = displayCoordTransform();
 
             m_contourMapProjectionPartMgr->appendPickPointVisToModel( contourMapProjectionModelBasicList.p(), transForm.p() );
             contourMapProjectionModelBasicList->updateBoundingBoxesRecursive();

ApplicationLibCode/ProjectDataModel/GeoMech/RimGeoMechModels.cpp

@@ -98,7 +98,7 @@ RimGeoMechCase* RimGeoMechModels::copyCase( RimGeoMechCase* thecase, const QStri
     copy->resolveReferencesRecursively();
 
     copy->updateConnectedEditors();
-    this->updateConnectedEditors();
+    updateConnectedEditors();
 
     for ( auto riv : copy->views() )
     {

ApplicationLibCode/ProjectDataModel/GeoMech/RimGeoMechResultDefinition.cpp

@@ -351,7 +351,7 @@ void RimGeoMechResultDefinition::fieldChangedByUi( const caf::PdmFieldHandle* ch
     }
 
     // Get the possible property filter owner
-    auto propFilter        = dynamic_cast<RimGeoMechPropertyFilter*>( this->parentField()->ownerObject() );
+    auto propFilter        = dynamic_cast<RimGeoMechPropertyFilter*>( parentField()->ownerObject() );
     auto view              = firstAncestorOrThisOfType<RimGridView>();
     auto curve             = firstAncestorOrThisOfType<RimPlotCurve>();
     auto rim3dWellLogCurve = firstAncestorOrThisOfType<Rim3dWellLogCurve>();
@@ -400,7 +400,7 @@ void RimGeoMechResultDefinition::fieldChangedByUi( const caf::PdmFieldHandle* ch
 
             if ( dynamic_cast<RimGeoMechCellColors*>( this ) )
             {
-                this->updateLegendCategorySettings();
+                updateLegendCategorySettings();
 
                 if ( view )
                 {
@@ -566,8 +566,8 @@ void RimGeoMechResultDefinition::loadResult()
 {
     if ( m_geomCase && m_geomCase->geoMechData() )
     {
-        if ( this->resultAddress().fieldName == RiaResultNames::wbsFGResult().toStdString() ||
-             this->resultAddress().fieldName == RiaResultNames::wbsSFGResult().toStdString() )
+        if ( resultAddress().fieldName == RiaResultNames::wbsFGResult().toStdString() ||
+             resultAddress().fieldName == RiaResultNames::wbsSFGResult().toStdString() )
         {
             RigFemResultAddress stressResAddr( RIG_ELEMENT_NODAL, std::string( "ST" ), "" );
             RigFemResultAddress porBarResAddr( RIG_ELEMENT_NODAL, std::string( "POR-Bar" ), "" );
@@ -576,7 +576,7 @@ void RimGeoMechResultDefinition::loadResult()
         }
         else
         {
-            m_geomCase->geoMechData()->femPartResults()->assertResultsLoaded( this->resultAddress() );
+            m_geomCase->geoMechData()->femPartResults()->assertResultsLoaded( resultAddress() );
         }
     }
 }
@@ -730,7 +730,7 @@ bool RimGeoMechResultDefinition::hasResult()
         RigFemPartResultsCollection* results = caseData->femPartResults();
         if ( results )
         {
-            return results->assertResultsLoaded( this->resultAddress() );
+            return results->assertResultsLoaded( resultAddress() );
         }
     }
     return false;
@@ -789,17 +789,17 @@ QString RimGeoMechResultDefinition::resultVariableName() const
 //--------------------------------------------------------------------------------------------------
 QString RimGeoMechResultDefinition::currentResultUnits() const
 {
-    RigFemResultAddress rigFemResultAddress = this->resultAddress();
+    RigFemResultAddress rigFemResultAddress = resultAddress();
 
     if ( RigFemPartResultCalculatorStressAnisotropy::isAnisotropyResult( rigFemResultAddress ) )
     {
         return RiaWellLogUnitTools<double>::noUnitString();
     }
 
-    if ( this->resultFieldName() == "SE" || this->resultFieldName() == "ST" || this->resultFieldName() == "POR-Bar" ||
-         this->resultFieldName() == "SM" || this->resultFieldName() == "SEM" || this->resultFieldName() == "Q" )
+    if ( resultFieldName() == "SE" || resultFieldName() == "ST" || resultFieldName() == "POR-Bar" || resultFieldName() == "SM" ||
+         resultFieldName() == "SEM" || resultFieldName() == "Q" )
     {
-        auto componentName = this->resultComponentName();
+        auto componentName = resultComponentName();
         if ( componentName.endsWith( "azi" ) || componentName.endsWith( "inc" ) )
         {
             return "Deg";
@@ -807,16 +807,15 @@ QString RimGeoMechResultDefinition::currentResultUnits() const
 
         return "Bar";
     }
-    else if ( this->resultFieldName() == "MODULUS" )
+    else if ( resultFieldName() == "MODULUS" )
     {
         return "GPa";
     }
-    else if ( this->resultFieldName() == "COMPRESSIBILITY" &&
-              ( this->resultComponentName() == "PORE" || this->resultComponentName() == "VERTICAL" ) )
+    else if ( resultFieldName() == "COMPRESSIBILITY" && ( resultComponentName() == "PORE" || resultComponentName() == "VERTICAL" ) )
     {
         return "1/GPa";
     }
-    else if ( this->resultFieldName() == "PORO-PERM" && this->resultComponentName() == "PERM" )
+    else if ( resultFieldName() == "PORO-PERM" && resultComponentName() == "PERM" )
     {
         return "mD";
     }
@@ -824,7 +823,7 @@ QString RimGeoMechResultDefinition::currentResultUnits() const
     {
         for ( auto resultName : RiaResultNames::wbsDerivedResultNames() )
         {
-            if ( resultName == this->resultFieldName() )
+            if ( resultName == resultFieldName() )
             {
                 return RiaWellLogUnitTools<double>::sg_emwUnitString();
             }
@@ -889,7 +888,7 @@ QString RimGeoMechResultDefinition::convertToUiResultFieldName( QString resultFi
 //--------------------------------------------------------------------------------------------------
 bool RimGeoMechResultDefinition::normalizableResultSelected() const
 {
-    return RigFemPartResultsCollection::isNormalizableResult( this->resultAddress() );
+    return RigFemPartResultsCollection::isNormalizableResult( resultAddress() );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -897,7 +896,7 @@ bool RimGeoMechResultDefinition::normalizableResultSelected() const
 //--------------------------------------------------------------------------------------------------
 bool RimGeoMechResultDefinition::referenceCaseDependentResultSelected() const
 {
-    return RigFemPartResultsCollection::isReferenceCaseDependentResult( this->resultAddress() );
+    return RigFemPartResultsCollection::isReferenceCaseDependentResult( resultAddress() );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -924,7 +923,7 @@ void RimGeoMechResultDefinition::updateLegendTextAndRanges( RimRegularLegendConf
                                                             const QString&          legendHeading,
                                                             int                     viewerStepIndex )
 {
-    if ( !this->ownerCaseData() || !( this->resultAddress().isValid() ) )
+    if ( !ownerCaseData() || !( resultAddress().isValid() ) )
     {
         return;
     }
@@ -934,10 +933,10 @@ void RimGeoMechResultDefinition::updateLegendTextAndRanges( RimRegularLegendConf
     double globalMin, globalMax;
     double globalPosClosestToZero, globalNegClosestToZero;
 
-    RigGeoMechCaseData* gmCase = this->ownerCaseData();
+    RigGeoMechCaseData* gmCase = ownerCaseData();
     CVF_ASSERT( gmCase );
 
-    RigFemResultAddress resVarAddress = this->resultAddress();
+    RigFemResultAddress resVarAddress = resultAddress();
 
     auto [stepIdx, frameIdx] = gmCase->femPartResults()->stepListIndexToTimeStepAndDataFrameIndex( viewerStepIndex );
 
@@ -950,18 +949,17 @@ void RimGeoMechResultDefinition::updateLegendTextAndRanges( RimRegularLegendConf
     legendConfigToUpdate->setClosestToZeroValues( globalPosClosestToZero, globalNegClosestToZero, localPosClosestToZero, localNegClosestToZero );
     legendConfigToUpdate->setAutomaticRanges( globalMin, globalMax, localMin, localMax );
 
-    if ( this->hasCategoryResult() )
+    if ( hasCategoryResult() )
     {
         std::vector<QString> fnVector = gmCase->femPartResults()->formationNames();
         legendConfigToUpdate->setNamedCategories( fnVector );
     }
 
-    QString legendTitle = legendHeading + caf::AppEnum<RigFemResultPosEnum>( this->resultPositionType() ).uiText() + "\n" +
-                          this->resultFieldUiName();
+    QString legendTitle = legendHeading + caf::AppEnum<RigFemResultPosEnum>( resultPositionType() ).uiText() + "\n" + resultFieldUiName();
 
-    if ( !this->resultComponentUiName().isEmpty() )
+    if ( !resultComponentUiName().isEmpty() )
     {
-        legendTitle += ", " + this->resultComponentUiName();
+        legendTitle += ", " + resultComponentUiName();
     }
 
     QString unitString = currentResultUnits();
@@ -970,9 +968,9 @@ void RimGeoMechResultDefinition::updateLegendTextAndRanges( RimRegularLegendConf
         legendTitle += QString( " [%1]" ).arg( unitString );
     }
 
-    if ( !this->diffResultUiShortName().isEmpty() )
+    if ( !diffResultUiShortName().isEmpty() )
     {
-        legendTitle += QString( "\nTime Diff:\n%1" ).arg( this->diffResultUiShortName() );
+        legendTitle += QString( "\nTime Diff:\n%1" ).arg( diffResultUiShortName() );
     }
 
     legendConfigToUpdate->setTitle( legendTitle );
@@ -983,5 +981,5 @@ void RimGeoMechResultDefinition::updateLegendTextAndRanges( RimRegularLegendConf
 //--------------------------------------------------------------------------------------------------
 bool RimGeoMechResultDefinition::isBiotCoefficientDependent() const
 {
-    return ( this->resultFieldName() == "COMPRESSIBILITY" || this->resultFieldName() == "PORO-PERM" );
+    return ( resultFieldName() == "COMPRESSIBILITY" || resultFieldName() == "PORO-PERM" );
 }

ApplicationLibCode/ProjectDataModel/GeoMech/RimGeoMechView.cpp

@@ -157,7 +157,7 @@ void RimGeoMechView::onLoadDataAndUpdate()
 
     onUpdateScaleTransform();
 
-    this->updateSurfacesInViewTreeItems();
+    updateSurfacesInViewTreeItems();
 
     if ( m_geomechCase )
     {
@@ -186,22 +186,22 @@ void RimGeoMechView::onLoadDataAndUpdate()
 
     progress.setProgressDescription( "Reading Current Result" );
 
-    CVF_ASSERT( this->cellResult() != nullptr );
-    m_geomechCase->geoMechData()->femPartResults()->setNormalizationAirGap( this->cellResult()->normalizationAirGap() );
-    m_geomechCase->geoMechData()->femPartResults()->assertResultsLoaded( this->cellResult()->resultAddress() );
+    CVF_ASSERT( cellResult() != nullptr );
+    m_geomechCase->geoMechData()->femPartResults()->setNormalizationAirGap( cellResult()->normalizationAirGap() );
+    m_geomechCase->geoMechData()->femPartResults()->assertResultsLoaded( cellResult()->resultAddress() );
     progress.incrementProgress();
     progress.setProgressDescription( "Create Display model" );
 
     updateMdiWindowVisibility();
 
-    this->geoMechPropertyFilterCollection()->loadAndInitializePropertyFilters();
+    geoMechPropertyFilterCollection()->loadAndInitializePropertyFilters();
     m_wellMeasurementCollection->syncWithChangesInWellMeasurementCollection();
 
     if ( m_surfaceCollection ) m_surfaceCollection->loadData();
 
     if ( m_partsCollection ) m_partsCollection->syncWithCase( m_geomechCase );
 
-    this->scheduleCreateDisplayModelAndRedraw();
+    scheduleCreateDisplayModelAndRedraw();
 
     progress.incrementProgress();
 }
@@ -215,7 +215,7 @@ void RimGeoMechView::onUpdateScaleTransform()
     cvf::Mat4d scale = cvf::Mat4d::IDENTITY;
     scale( 2, 2 )    = scaleZ();
 
-    this->scaleTransform()->setLocalTransform( scale );
+    scaleTransform()->setLocalTransform( scale );
 
     if ( nativeOrOverrideViewer() ) nativeOrOverrideViewer()->updateCachedValuesInScene();
 }
@@ -414,7 +414,7 @@ void RimGeoMechView::onUpdateDisplayModelForCurrentTimeStep()
 
     updateElementDisplacements();
 
-    if ( this->isTimeStepDependentDataVisibleInThisOrComparisonView() )
+    if ( isTimeStepDependentDataVisibleInThisOrComparisonView() )
     {
         if ( nativeOrOverrideViewer() )
         {
@@ -469,10 +469,10 @@ void RimGeoMechView::onUpdateDisplayModelForCurrentTimeStep()
             }
         }
 
-        bool hasGeneralCellResult = this->cellResult()->hasResult();
+        bool hasGeneralCellResult = cellResult()->hasResult();
 
         if ( hasGeneralCellResult )
-            m_vizLogic->updateCellResultColor( m_currentTimeStep(), m_currentInternalTimeStep, m_currentDataFrameIndex, this->cellResult() );
+            m_vizLogic->updateCellResultColor( m_currentTimeStep(), m_currentInternalTimeStep, m_currentDataFrameIndex, cellResult() );
         else
             m_vizLogic->updateStaticCellColors( m_currentTimeStep() );
 
@@ -550,7 +550,7 @@ void RimGeoMechView::onUpdateLegends()
         }
         else
         {
-            std::vector<RimLegendConfig*> legendConfs = this->legendConfigs();
+            std::vector<RimLegendConfig*> legendConfs = legendConfigs();
 
             for ( auto legendConf : legendConfs )
             {
@@ -558,7 +558,7 @@ void RimGeoMechView::onUpdateLegends()
             }
         }
 
-        this->updateLegendTextAndRanges( cellResult()->legendConfig(), m_currentTimeStep() );
+        updateLegendTextAndRanges( cellResult()->legendConfig(), m_currentTimeStep() );
 
         if ( cellResult()->hasResult() && cellResult()->legendConfig()->showLegend() )
         {
@@ -566,12 +566,12 @@ void RimGeoMechView::onUpdateLegends()
                                                                         isUsingOverrideViewer() );
         }
 
-        for ( RimIntersectionResultDefinition* sepInterResDef : this->separateIntersectionResultsCollection()->intersectionResultsDefinitions() )
+        for ( RimIntersectionResultDefinition* sepInterResDef : separateIntersectionResultsCollection()->intersectionResultsDefinitions() )
         {
             sepInterResDef->updateLegendRangesTextAndVisibility( "Intersection Results:\n", nativeOrOverrideViewer(), isUsingOverrideViewer() );
         }
 
-        for ( RimIntersectionResultDefinition* sepInterResDef : this->separateSurfaceResultsCollection()->intersectionResultsDefinitions() )
+        for ( RimIntersectionResultDefinition* sepInterResDef : separateSurfaceResultsCollection()->intersectionResultsDefinitions() )
         {
             sepInterResDef->updateLegendRangesTextAndVisibility( "Surface Results:\n", nativeOrOverrideViewer(), isUsingOverrideViewer() );
         }
@@ -655,7 +655,7 @@ void RimGeoMechView::updateTensorLegendTextAndRanges( RimRegularLegendConfig* le
 //--------------------------------------------------------------------------------------------------
 void RimGeoMechView::updateLegendTextAndRanges( RimRegularLegendConfig* legendConfig, int timeStepIndex )
 {
-    if ( !this->isTimeStepDependentDataVisible() )
+    if ( !isTimeStepDependentDataVisible() )
     {
         return;
     }
@@ -697,12 +697,12 @@ std::vector<RimLegendConfig*> RimGeoMechView::legendConfigs() const
     absLegendConfigs.push_back( cellResult()->legendConfig() );
     absLegendConfigs.push_back( tensorResults()->arrowColorLegendConfig() );
 
-    for ( RimIntersectionResultDefinition* sepInterResDef : this->separateIntersectionResultsCollection()->intersectionResultsDefinitions() )
+    for ( RimIntersectionResultDefinition* sepInterResDef : separateIntersectionResultsCollection()->intersectionResultsDefinitions() )
     {
         absLegendConfigs.push_back( sepInterResDef->regularLegendConfig() );
     }
 
-    for ( RimIntersectionResultDefinition* sepInterResDef : this->separateSurfaceResultsCollection()->intersectionResultsDefinitions() )
+    for ( RimIntersectionResultDefinition* sepInterResDef : separateSurfaceResultsCollection()->intersectionResultsDefinitions() )
     {
         absLegendConfigs.push_back( sepInterResDef->regularLegendConfig() );
     }
@@ -768,10 +768,10 @@ void RimGeoMechView::convertCameraPositionFromOldProjectFiles()
         RimCase*                  rimCase               = geoMechCase;
         RiuViewerToViewInterface* viewerToViewInterface = this;
         cvf::Vec3d                offset                = rimCase->displayModelOffset();
-        auto                      diplayCoordTrans      = this->displayCoordTransform();
+        auto                      diplayCoordTrans      = displayCoordTransform();
 
         {
-            cvf::Mat4d cameraMx = this->cameraPosition().getInverted();
+            cvf::Mat4d cameraMx = cameraPosition().getInverted();
 
             cvf::Vec3d translation = cameraMx.translation();
 
@@ -786,7 +786,7 @@ void RimGeoMechView::convertCameraPositionFromOldProjectFiles()
         }
 
         {
-            cvf::Vec3d pointOfInterest = this->cameraPointOfInterest();
+            cvf::Vec3d pointOfInterest = cameraPointOfInterest();
 
             cvf::Vec3d pointOfInterestDomain = diplayCoordTrans->scaleToDomainSize( pointOfInterest );
             pointOfInterestDomain -= offset;
@@ -798,8 +798,8 @@ void RimGeoMechView::convertCameraPositionFromOldProjectFiles()
 
         if ( viewer() )
         {
-            viewer()->mainCamera()->setViewMatrix( this->cameraPosition() );
-            viewer()->setPointOfInterest( this->cameraPointOfInterest() );
+            viewer()->mainCamera()->setViewMatrix( cameraPosition() );
+            viewer()->setPointOfInterest( cameraPointOfInterest() );
         }
     }
 }
@@ -847,22 +847,22 @@ size_t RimGeoMechView::onTimeStepCountRequested()
 //--------------------------------------------------------------------------------------------------
 bool RimGeoMechView::isTimeStepDependentDataVisible() const
 {
-    if ( this->cellResult()->hasResult() || this->geoMechPropertyFilterCollection()->hasActiveFilters() )
+    if ( cellResult()->hasResult() || geoMechPropertyFilterCollection()->hasActiveFilters() )
     {
         return true;
     }
 
-    if ( this->hasVisibleTimeStepDependent3dWellLogCurves() )
+    if ( hasVisibleTimeStepDependent3dWellLogCurves() )
     {
         return true;
     }
 
-    if ( this->intersectionCollection()->hasAnyActiveSeparateResults() )
+    if ( intersectionCollection()->hasAnyActiveSeparateResults() )
     {
         return true;
     }
 
-    if ( this->surfaceInViewCollection() && this->surfaceInViewCollection()->hasAnyActiveSeparateResults() )
+    if ( surfaceInViewCollection() && surfaceInViewCollection()->hasAnyActiveSeparateResults() )
     {
         return true;
     }
@@ -897,7 +897,7 @@ void RimGeoMechView::fieldChangedByUi( const caf::PdmFieldHandle* changedField,
 
     if ( ( changedField == &m_showDisplacement ) || ( ( changedField == &m_displacementScaling ) && m_showDisplacement() ) )
     {
-        this->createDisplayModelAndRedraw();
+        createDisplayModelAndRedraw();
     }
 }
 
@@ -907,9 +907,9 @@ void RimGeoMechView::fieldChangedByUi( const caf::PdmFieldHandle* changedField,
 void RimGeoMechView::initAfterRead()
 {
     RimGridView::initAfterRead();
-    this->cellResult()->setGeoMechCase( m_geomechCase );
+    cellResult()->setGeoMechCase( m_geomechCase );
 
-    this->updateUiIconFromToggleField();
+    updateUiIconFromToggleField();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -927,9 +927,9 @@ void RimGeoMechView::scheduleGeometryRegen( RivCellSetEnum geometryType )
 {
     m_vizLogic->scheduleGeometryRegen( geometryType );
 
-    if ( this->isMasterView() )
+    if ( isMasterView() )
     {
-        RimViewLinker* viewLinker = this->assosiatedViewLinker();
+        RimViewLinker* viewLinker = assosiatedViewLinker();
         if ( viewLinker )
         {
             viewLinker->scheduleGeometryRegenForDepViews( geometryType );
@@ -950,8 +950,8 @@ void RimGeoMechView::setOverridePropertyFilterCollection( RimGeoMechPropertyFilt
     }
     m_propertyFilterCollection.uiCapability()->updateConnectedEditors();
 
-    this->scheduleGeometryRegen( PROPERTY_FILTERED );
-    this->scheduleCreateDisplayModelAndRedraw();
+    scheduleGeometryRegen( PROPERTY_FILTERED );
+    scheduleCreateDisplayModelAndRedraw();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/GridCrossPlots/RimGridCrossPlot.cpp

@@ -477,7 +477,7 @@ RiuPlotWidget* RimGridCrossPlot::doCreatePlotViewWidget( QWidget* mainWindowPare
 
         updateCurveNamesAndPlotTitle();
 
-        this->connect( m_plotWidget, SIGNAL( plotZoomed() ), SLOT( onPlotZoomed() ) );
+        connect( m_plotWidget, SIGNAL( plotZoomed() ), SLOT( onPlotZoomed() ) );
     }
     return m_plotWidget;
 }
@@ -623,7 +623,7 @@ void RimGridCrossPlot::updateCurveNamesAndPlotTitle()
 
     if ( m_plotWidget )
     {
-        QString plotTitle = this->createAutoName();
+        QString plotTitle = createAutoName();
         m_plotWidget->setPlotTitle( plotTitle );
         m_plotWidget->setPlotTitleEnabled( m_showPlotTitle && !isSubPlot() );
     }

ApplicationLibCode/ProjectDataModel/GridCrossPlots/RimGridCrossPlotDataSet.cpp

@@ -1493,7 +1493,7 @@ void RimGridCrossPlotDataSet::updateCurveNames( size_t dataSetIndex, size_t data
 //--------------------------------------------------------------------------------------------------
 void RimGridCrossPlotDataSet::updateDataSetName()
 {
-    this->setName( createAutoName() );
+    setName( createAutoName() );
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/Intersections/RimBoxIntersection.cpp

@@ -501,7 +501,7 @@ void RimBoxIntersection::defineUiOrdering( QString uiConfigName, caf::PdmUiOrder
 
     uiOrdering.add( &m_show3DManipulator );
 
-    this->defineSeparateDataSourceUi( uiConfigName, uiOrdering );
+    defineSeparateDataSourceUi( uiConfigName, uiOrdering );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -564,21 +564,21 @@ void RimBoxIntersection::updateVisibility()
     if ( m_singlePlaneState == PLANE_STATE_X )
     {
         m_maxXCoord.uiCapability()->setUiReadOnly( true );
-        this->setUiIconFromResourceString( QString( ":/IntersectionXPlane16x16.png" ) );
+        setUiIconFromResourceString( QString( ":/IntersectionXPlane16x16.png" ) );
     }
     else if ( m_singlePlaneState == PLANE_STATE_Y )
     {
         m_maxYCoord.uiCapability()->setUiReadOnly( true );
-        this->setUiIconFromResourceString( QString( ":/IntersectionYPlane16x16.png" ) );
+        setUiIconFromResourceString( QString( ":/IntersectionYPlane16x16.png" ) );
     }
     else if ( m_singlePlaneState == PLANE_STATE_Z )
     {
         m_maxDepth.uiCapability()->setUiReadOnly( true );
-        this->setUiIconFromResourceString( QString( ":/IntersectionZPlane16x16.png" ) );
+        setUiIconFromResourceString( QString( ":/IntersectionZPlane16x16.png" ) );
     }
     else
     {
-        this->setUiIconFromResourceString( QString( ":/IntersectionBox16x16.png" ) );
+        setUiIconFromResourceString( QString( ":/IntersectionBox16x16.png" ) );
     }
 }
 

ApplicationLibCode/ProjectDataModel/Intersections/RimExtrudedCurveIntersection.cpp

@@ -627,7 +627,7 @@ void RimExtrudedCurveIntersection::defineUiOrdering( QString uiConfigName, caf::
         }
     }
 
-    this->defineSeparateDataSourceUi( uiConfigName, uiOrdering );
+    defineSeparateDataSourceUi( uiConfigName, uiOrdering );
 
     uiOrdering.skipRemainingFields( true );
 }
@@ -1161,7 +1161,7 @@ cvf::Vec3d RimExtrudedCurveIntersection::extrusionDirection() const
 
     if ( m_direction() == RimExtrudedCurveIntersection::CrossSectionDirEnum::CS_HORIZONTAL )
     {
-        std::vector<std::vector<cvf::Vec3d>> lines = this->polyLines();
+        std::vector<std::vector<cvf::Vec3d>> lines = polyLines();
         if ( !lines.empty() && lines[0].size() > 1 )
         {
             std::vector<cvf::Vec3d> firstLine = lines[0];

ApplicationLibCode/ProjectDataModel/Intersections/RimIntersection.cpp

@@ -146,7 +146,7 @@ caf::PdmFieldHandle* RimIntersection::objectToggleField()
 void RimIntersection::defineSeparateDataSourceUi( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
 {
     QString inactiveText;
-    if ( !this->activeSeparateResultDefinition() )
+    if ( !activeSeparateResultDefinition() )
     {
         inactiveText = " (Inactive)";
     }
@@ -199,7 +199,7 @@ cvf::ref<RivIntersectionHexGridInterface> RimIntersection::createHexGridInterfac
             return new RivEclipseIntersectionGrid( eclipseCase->eclipseCaseData()->mainGrid(),
                                                    eclipseCase->eclipseCaseData()->activeCellInfo(
                                                        resDef->eclipseResultDefinition()->porosityModel() ),
-                                                   this->isInactiveCellsVisible() );
+                                                   isInactiveCellsVisible() );
         }
 
         // Geomech case
@@ -217,7 +217,7 @@ cvf::ref<RivIntersectionHexGridInterface> RimIntersection::createHexGridInterfac
     {
         RigMainGrid* grid = eclipseView->mainGrid();
 
-        return new RivEclipseIntersectionGrid( grid, eclipseView->currentActiveCellInfo(), this->isInactiveCellsVisible() );
+        return new RivEclipseIntersectionGrid( grid, eclipseView->currentActiveCellInfo(), isInactiveCellsVisible() );
     }
 
     if ( geoView && geoView->femParts() )

ApplicationLibCode/ProjectDataModel/Intersections/RimIntersectionCollection.cpp

@@ -125,7 +125,7 @@ void RimIntersectionCollection::defineUiTreeOrdering( caf::PdmUiTreeOrdering& ui
 //--------------------------------------------------------------------------------------------------
 void RimIntersectionCollection::applySingleColorEffect()
 {
-    if ( !this->isActive() ) return;
+    if ( !isActive() ) return;
 
     for ( RimExtrudedCurveIntersection* cs : m_intersections )
     {
@@ -149,7 +149,7 @@ void RimIntersectionCollection::applySingleColorEffect()
 //--------------------------------------------------------------------------------------------------
 void RimIntersectionCollection::updateCellResultColor( bool hasGeneralCellResult, int timeStepIndex )
 {
-    if ( !this->isActive() ) return;
+    if ( !isActive() ) return;
 
     for ( RimExtrudedCurveIntersection* cs : m_intersections )
     {
@@ -190,7 +190,7 @@ void RimIntersectionCollection::updateCellResultColor( bool hasGeneralCellResult
 //--------------------------------------------------------------------------------------------------
 bool RimIntersectionCollection::hasAnyActiveSeparateResults()
 {
-    if ( !this->isActive() ) return false;
+    if ( !isActive() ) return false;
 
     for ( RimExtrudedCurveIntersection* cs : m_intersections )
     {

ApplicationLibCode/ProjectDataModel/Intersections/RimIntersectionResultDefinition.cpp

@@ -235,10 +235,10 @@ void RimIntersectionResultDefinition::updateLegendRangesTextAndVisibility( const
 {
     assignCaseIfMissing();
 
-    if ( !this->isInAction() ) return;
+    if ( !isInAction() ) return;
 
-    if ( ( this->isEclipseResultDefinition() && m_eclipseResultDefinition()->hasCategoryResult() ) ||
-         ( !this->isEclipseResultDefinition() && m_geomResultDefinition()->hasCategoryResult() ) )
+    if ( ( isEclipseResultDefinition() && m_eclipseResultDefinition()->hasCategoryResult() ) ||
+         ( !isEclipseResultDefinition() && m_geomResultDefinition()->hasCategoryResult() ) )
     {
         regularLegendConfig()->setMappingMode( RimRegularLegendConfig::MappingType::CATEGORY_INTEGER );
         regularLegendConfig()->setColorLegend( RimRegularLegendConfig::mapToColorLegend( RimRegularLegendConfig::ColorRangesType::CATEGORY ) );
@@ -257,31 +257,31 @@ void RimIntersectionResultDefinition::updateLegendRangesTextAndVisibility( const
         }
     }
 
-    if ( this->isEclipseResultDefinition() )
+    if ( isEclipseResultDefinition() )
     {
-        RimEclipseResultDefinition* eclResultDef = this->eclipseResultDefinition();
-        eclResultDef->updateRangesForExplicitLegends( this->regularLegendConfig(), this->ternaryLegendConfig(), this->timeStep() );
+        RimEclipseResultDefinition* eclResultDef = eclipseResultDefinition();
+        eclResultDef->updateRangesForExplicitLegends( regularLegendConfig(), ternaryLegendConfig(), timeStep() );
 
-        eclResultDef->updateLegendTitle( this->regularLegendConfig(), title );
+        eclResultDef->updateLegendTitle( regularLegendConfig(), title );
 
-        if ( this->regularLegendConfig()->showLegend() && eclResultDef->hasResult() )
+        if ( regularLegendConfig()->showLegend() && eclResultDef->hasResult() )
         {
-            nativeOrOverrideViewer->addColorLegendToBottomLeftCorner( this->regularLegendConfig()->titledOverlayFrame(), isUsingOverrideViewer );
+            nativeOrOverrideViewer->addColorLegendToBottomLeftCorner( regularLegendConfig()->titledOverlayFrame(), isUsingOverrideViewer );
         }
         else if ( eclResultDef->isTernarySaturationSelected() && eclResultDef->currentGridCellResults()->maxTimeStepCount() > 1 &&
-                  this->ternaryLegendConfig()->showLegend() && this->ternaryLegendConfig()->titledOverlayFrame() )
+                  ternaryLegendConfig()->showLegend() && ternaryLegendConfig()->titledOverlayFrame() )
         {
-            this->ternaryLegendConfig()->setTitle( title );
-            nativeOrOverrideViewer->addColorLegendToBottomLeftCorner( this->ternaryLegendConfig()->titledOverlayFrame(), isUsingOverrideViewer );
+            ternaryLegendConfig()->setTitle( title );
+            nativeOrOverrideViewer->addColorLegendToBottomLeftCorner( ternaryLegendConfig()->titledOverlayFrame(), isUsingOverrideViewer );
         }
     }
     else
     {
-        this->geoMechResultDefinition()->updateLegendTextAndRanges( this->regularLegendConfig(), title, this->timeStep() );
+        geoMechResultDefinition()->updateLegendTextAndRanges( regularLegendConfig(), title, timeStep() );
 
-        if ( this->geoMechResultDefinition()->hasResult() && this->regularLegendConfig()->showLegend() )
+        if ( geoMechResultDefinition()->hasResult() && regularLegendConfig()->showLegend() )
         {
-            nativeOrOverrideViewer->addColorLegendToBottomLeftCorner( this->regularLegendConfig()->titledOverlayFrame(), isUsingOverrideViewer );
+            nativeOrOverrideViewer->addColorLegendToBottomLeftCorner( regularLegendConfig()->titledOverlayFrame(), isUsingOverrideViewer );
         }
     }
 }
@@ -321,7 +321,7 @@ void RimIntersectionResultDefinition::fieldChangedByUi( const caf::PdmFieldHandl
         reDraw = true;
     }
 
-    this->updateConnectedEditors();
+    updateConnectedEditors();
 
     auto interResDefColl = firstAncestorOrThisOfType<RimIntersectionResultsDefinitionCollection>();
     bool isInAction      = isActive() && interResDefColl && interResDefColl->isActive();
@@ -345,7 +345,7 @@ void RimIntersectionResultDefinition::fieldChangedByUi( const caf::PdmFieldHandl
         update2dIntersectionViews();
     }
 
-    this->updateUiIconFromToggleField();
+    updateUiIconFromToggleField();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -374,8 +374,8 @@ void RimIntersectionResultDefinition::setDefaultEclipseLegendConfig()
     bool useDiscreteLogLevels = false;
     bool isCategoryResult     = m_eclipseResultDefinition->hasCategoryResult();
 
-    auto eclResultDef = this->eclipseResultDefinition();
-    eclResultDef->updateRangesForExplicitLegends( this->regularLegendConfig(), this->ternaryLegendConfig(), this->timeStep() );
+    auto eclResultDef = eclipseResultDefinition();
+    eclResultDef->updateRangesForExplicitLegends( regularLegendConfig(), ternaryLegendConfig(), timeStep() );
 
     m_legendConfig->setDefaultConfigForResultName( m_case->caseId(),
                                                    m_eclipseResultDefinition->resultVariable(),
@@ -456,7 +456,7 @@ void RimIntersectionResultDefinition::initAfterRead()
 {
     updateCaseInResultDefinitions();
 
-    this->updateUiIconFromToggleField();
+    updateUiIconFromToggleField();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/Intersections/RimIntersectionResultsDefinitionCollection.cpp

@@ -93,7 +93,7 @@ void RimIntersectionResultsDefinitionCollection::fieldChangedByUi( const caf::Pd
                                                                    const QVariant&            oldValue,
                                                                    const QVariant&            newValue )
 {
-    this->updateUiIconFromToggleField();
+    updateUiIconFromToggleField();
 
     auto gridView = firstAncestorOrThisOfType<RimGridView>();
     if ( gridView ) gridView->scheduleCreateDisplayModelAndRedraw();
@@ -105,7 +105,7 @@ void RimIntersectionResultsDefinitionCollection::fieldChangedByUi( const caf::Pd
 //--------------------------------------------------------------------------------------------------
 void RimIntersectionResultsDefinitionCollection::initAfterRead()
 {
-    this->updateUiIconFromToggleField();
+    updateUiIconFromToggleField();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/PlotTemplates/RimPlotTemplateFileItem.cpp

@@ -53,11 +53,11 @@ RimPlotTemplateFileItem::~RimPlotTemplateFileItem()
 void RimPlotTemplateFileItem::setFilePath( const QString& filePath )
 {
     QFileInfo fi( filePath );
-    this->uiCapability()->setUiName( fi.baseName() );
+    uiCapability()->setUiName( fi.baseName() );
 
     m_absoluteFileName = filePath;
 
-    if ( isEnsembleTemplate() ) this->uiCapability()->setUiIcon( caf::IconProvider( ":/plot-template-ensemble.svg" ) );
+    if ( isEnsembleTemplate() ) uiCapability()->setUiIcon( caf::IconProvider( ":/plot-template-ensemble.svg" ) );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -81,7 +81,7 @@ bool RimPlotTemplateFileItem::isEnsembleTemplate() const
 //--------------------------------------------------------------------------------------------------
 void RimPlotTemplateFileItem::updateIconState()
 {
-    caf::IconProvider iconProvider = this->uiIconProvider();
+    caf::IconProvider iconProvider = uiIconProvider();
     if ( !iconProvider.valid() ) return;
 
     if ( isDefaultTemplate() )
@@ -93,7 +93,7 @@ void RimPlotTemplateFileItem::updateIconState()
         iconProvider.setOverlayResourceString( "" );
     }
 
-    this->setUiIcon( iconProvider );
+    setUiIcon( iconProvider );
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/PlotTemplates/RimPlotTemplateFolderItem.cpp

@@ -131,7 +131,7 @@ void RimPlotTemplateFolderItem::setFolderPath( const QString& path )
     m_folderName.v().setPath( path );
 
     QFileInfo fi( path );
-    this->uiCapability()->setUiName( fi.baseName() );
+    uiCapability()->setUiName( fi.baseName() );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -154,7 +154,7 @@ void RimPlotTemplateFolderItem::searchForFileAndFolderNames( int levelsLeft )
         return;
     }
 
-    QDir myDir( this->m_folderName().path() );
+    QDir myDir( m_folderName().path() );
     if ( !myDir.isReadable() )
     {
         return;

ApplicationLibCode/ProjectDataModel/Rim2dIntersectionView.cpp

@@ -136,7 +136,7 @@ void Rim2dIntersectionView::setIntersection( RimExtrudedCurveIntersection* inter
 
     m_intersection = intersection;
 
-    this->updateName();
+    updateName();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -348,7 +348,7 @@ void Rim2dIntersectionView::updateName()
     if ( m_intersection )
     {
         Rim3dView* parentView = m_intersection->firstAncestorOrThisOfTypeAsserted<Rim3dView>();
-        this->setName( parentView->name() + ": " + m_intersection->name() );
+        setName( parentView->name() + ": " + m_intersection->name() );
     }
 }
 
@@ -471,7 +471,7 @@ size_t Rim2dIntersectionView::onTimeStepCountRequested()
 {
     if ( isTimeStepDependentDataVisible() )
     {
-        return this->ownerCase()->timeStepStrings().size();
+        return ownerCase()->timeStepStrings().size();
     }
 
     return 0;
@@ -528,7 +528,7 @@ void Rim2dIntersectionView::onCreateDisplayModel()
 
     nativeOrOverrideViewer()->removeAllFrames( isUsingOverrideViewer() );
 
-    size_t tsCount = this->timeStepCount();
+    size_t tsCount = timeStepCount();
 
     for ( size_t i = 0; i < tsCount; ++i )
     {
@@ -563,9 +563,9 @@ void Rim2dIntersectionView::onCreateDisplayModel()
         {
             m_flatWellpathPartMgr = new RivWellPathPartMgr( m_intersection->wellPath(), settingsView );
             m_flatWellpathPartMgr->appendFlattenedStaticGeometryPartsToModel( m_intersectionVizModel.p(),
-                                                                              this->displayCoordTransform().p(),
-                                                                              this->ownerCase()->characteristicCellSize(),
-                                                                              this->ownerCase()->activeCellsBoundingBox() );
+                                                                              displayCoordTransform().p(),
+                                                                              ownerCase()->characteristicCellSize(),
+                                                                              ownerCase()->activeCellsBoundingBox() );
         }
     }
 
@@ -578,7 +578,7 @@ void Rim2dIntersectionView::onCreateDisplayModel()
         viewer()->setCurrentFrame( m_currentTimeStep );
         if ( viewer()->mainCamera() && viewer()->mainCamera()->viewMatrix() == sm_defaultViewMatrix )
         {
-            this->zoomAll();
+            zoomAll();
         }
     }
 }
@@ -607,7 +607,7 @@ void Rim2dIntersectionView::onUpdateDisplayModelForCurrentTimeStep()
 
                 m_flatSimWellPipePartMgr->appendFlattenedDynamicGeometryPartsToModel( simWellModelBasicList.p(),
                                                                                       m_currentTimeStep,
-                                                                                      this->displayCoordTransform().p(),
+                                                                                      displayCoordTransform().p(),
                                                                                       m_intersection->extentLength(),
                                                                                       m_intersection->branchIndex() );
 
@@ -615,7 +615,7 @@ void Rim2dIntersectionView::onUpdateDisplayModelForCurrentTimeStep()
                 {
                     m_flatWellHeadPartMgr->appendFlattenedDynamicGeometryPartsToModel( simWellModelBasicList.p(),
                                                                                        m_currentTimeStep,
-                                                                                       this->displayCoordTransform().p(),
+                                                                                       displayCoordTransform().p(),
                                                                                        offset );
                 }
 
@@ -639,16 +639,16 @@ void Rim2dIntersectionView::onUpdateDisplayModelForCurrentTimeStep()
 
                 m_flatWellpathPartMgr->appendFlattenedDynamicGeometryPartsToModel( dynWellPathModel.p(),
                                                                                    m_currentTimeStep,
-                                                                                   this->displayCoordTransform().p(),
-                                                                                   this->ownerCase()->characteristicCellSize(),
-                                                                                   this->ownerCase()->activeCellsBoundingBox() );
+                                                                                   displayCoordTransform().p(),
+                                                                                   ownerCase()->characteristicCellSize(),
+                                                                                   ownerCase()->activeCellsBoundingBox() );
                 dynWellPathModel->updateBoundingBoxesRecursive();
                 frameScene->addModel( dynWellPathModel.p() );
             }
         }
     }
 
-    if ( m_flatIntersectionPartMgr.notNull() && this->hasResults() )
+    if ( m_flatIntersectionPartMgr.notNull() && hasResults() )
     {
         m_flatIntersectionPartMgr->updateCellResultColor( m_currentTimeStep,
                                                           m_legendConfig->scalarMapper(),
@@ -800,7 +800,7 @@ void Rim2dIntersectionView::onUpdateScaleTransform()
     cvf::Mat4d scale = cvf::Mat4d::IDENTITY;
     scale( 2, 2 )    = scaleZ();
 
-    this->scaleTransform()->setLocalTransform( scale );
+    scaleTransform()->setLocalTransform( scale );
 
     if ( nativeOrOverrideViewer() ) nativeOrOverrideViewer()->updateCachedValuesInScene();
 }
@@ -820,7 +820,7 @@ void Rim2dIntersectionView::onLoadDataAndUpdate()
 {
     updateMdiWindowVisibility();
 
-    this->scheduleCreateDisplayModelAndRedraw();
+    scheduleCreateDisplayModelAndRedraw();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -832,12 +832,12 @@ void Rim2dIntersectionView::fieldChangedByUi( const caf::PdmFieldHandle* changed
 
     if ( changedField == &m_intersection || changedField == &m_showDefiningPoints )
     {
-        this->loadDataAndUpdate();
+        loadDataAndUpdate();
     }
     else if ( changedField == &m_showAxisLines )
     {
         nativeOrOverrideViewer()->showEdgeTickMarksXZ( true, m_showAxisLines() );
-        this->loadDataAndUpdate();
+        loadDataAndUpdate();
     }
 }
 

ApplicationLibCode/ProjectDataModel/Rim2dIntersectionViewCollection.cpp

@@ -109,7 +109,7 @@ void Rim2dIntersectionViewCollection::syncFromExistingIntersections( bool doUpda
         }
     }
 
-    if ( doUpdate ) this->updateConnectedEditors();
+    if ( doUpdate ) updateConnectedEditors();
 
     auto rimCase = firstAncestorOrThisOfType<RimCase>();
 

ApplicationLibCode/ProjectDataModel/Rim3dOverlayInfoConfig.cpp

@@ -132,7 +132,7 @@ void Rim3dOverlayInfoConfig::fieldChangedByUi( const caf::PdmFieldHandle* change
         }
     }
 
-    this->update3DInfo();
+    update3DInfo();
 
     if ( m_viewDef && m_viewDef->viewer() )
     {
@@ -691,12 +691,12 @@ void Rim3dOverlayInfoConfig::showStatisticsInfoDialog( bool raise )
 //--------------------------------------------------------------------------------------------------
 void Rim3dOverlayInfoConfig::update3DInfo()
 {
-    this->updateUiIconFromToggleField();
+    updateUiIconFromToggleField();
 
     if ( !m_viewDef ) return;
     if ( !m_viewDef->viewer() ) return;
 
-    if ( !this->m_active() )
+    if ( !m_active() )
     {
         m_viewDef->viewer()->showInfoText( false );
         m_viewDef->viewer()->showHistogram( false );

ApplicationLibCode/ProjectDataModel/Rim3dView.cpp

@@ -164,7 +164,7 @@ Rim3dView::Rim3dView()
     m_cellfilterPartManager  = new RivCellFilterPartMgr( this );
     m_measurementPartManager = new RivMeasurementPartMgr( this );
 
-    this->setAs3DViewMdiWindow();
+    setAs3DViewMdiWindow();
 
     // Every timer tick, send a signal for updating animations.
     // Any animation is supposed to connect to this signal
@@ -198,9 +198,9 @@ Rim3dView::~Rim3dView()
             }
         }
 
-        if ( this->isMasterView() )
+        if ( isMasterView() )
         {
-            RimViewLinker* viewLinker = this->assosiatedViewLinker();
+            RimViewLinker* viewLinker = assosiatedViewLinker();
             viewLinker->setMasterView( nullptr );
 
             delete proj->viewLinkerCollection->viewLinker();
@@ -209,7 +209,7 @@ Rim3dView::~Rim3dView()
             proj->uiCapability()->updateConnectedEditors();
         }
 
-        RimViewController* vController = this->viewController();
+        RimViewController* vController = viewController();
         if ( vController )
         {
             vController->setManagedView( nullptr );
@@ -359,7 +359,7 @@ QWidget* Rim3dView::createViewWidget( QWidget* mainWindowParent )
     cvf::String yLabel;
     cvf::String zLabel;
 
-    this->defineAxisLabels( &xLabel, &yLabel, &zLabel );
+    defineAxisLabels( &xLabel, &yLabel, &zLabel );
     m_viewer->setAxisLabels( xLabel, yLabel, zLabel );
 
     updateZScaleLabel();
@@ -375,7 +375,7 @@ void Rim3dView::updateViewWidgetAfterCreation()
 
     m_viewer->setDefaultPerspectiveNearPlaneDistance( 10 );
 
-    this->onResetLegendsInViewer();
+    onResetLegendsInViewer();
 
     m_viewer->updateNavigationPolicy();
     m_viewer->enablePerfInfoHud( RiaPreferencesSystem::current()->show3dInformation() );
@@ -386,9 +386,9 @@ void Rim3dView::updateViewWidgetAfterCreation()
 
     m_viewer->mainCamera()->viewport()->setClearColor( cvf::Color4f( backgroundColor() ) );
 
-    this->updateGridBoxData();
-    this->updateAnnotationItems();
-    this->createHighlightAndGridBoxDisplayModel();
+    updateGridBoxData();
+    updateAnnotationItems();
+    createHighlightAndGridBoxDisplayModel();
 
     m_viewer->update();
 }
@@ -400,7 +400,7 @@ void Rim3dView::setId( int id )
 {
     m_id                  = id;
     QString viewIdTooltip = QString( "View id: %1" ).arg( m_id );
-    this->setUiToolTip( viewIdTooltip );
+    setUiToolTip( viewIdTooltip );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -441,7 +441,7 @@ void Rim3dView::updateMdiWindowTitle()
 //--------------------------------------------------------------------------------------------------
 RimViewLinker* Rim3dView::assosiatedViewLinker() const
 {
-    RimViewLinker* viewLinker = this->viewLinkerIfMasterView();
+    RimViewLinker* viewLinker = viewLinkerIfMasterView();
     if ( !viewLinker )
     {
         RimViewController* viewController = this->viewController();
@@ -502,7 +502,7 @@ void Rim3dView::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOr
 
     caf::PdmUiGroup* gridGroup = uiOrdering.addNewGroup( "Grid Appearance" );
     gridGroup->add( &m_scaleZ );
-    m_scaleZ.uiCapability()->setUiReadOnly( !this->isScaleZEditable() );
+    m_scaleZ.uiCapability()->setUiReadOnly( !isScaleZEditable() );
     gridGroup->add( &meshMode );
     gridGroup->add( &surfaceMode );
 
@@ -533,9 +533,9 @@ QImage Rim3dView::snapshotWindowContent()
 void Rim3dView::scheduleCreateDisplayModelAndRedraw()
 {
     RiaViewRedrawScheduler::instance()->scheduleDisplayModelUpdateAndRedraw( this );
-    if ( this->isMasterView() )
+    if ( isMasterView() )
     {
-        RimViewLinker* viewLinker = this->assosiatedViewLinker();
+        RimViewLinker* viewLinker = assosiatedViewLinker();
         if ( viewLinker )
         {
             viewLinker->scheduleCreateDisplayModelAndRedrawForDependentViews();
@@ -579,7 +579,7 @@ std::set<Rim3dView*> Rim3dView::viewsUsingThisAsComparisonView()
 //--------------------------------------------------------------------------------------------------
 bool Rim3dView::isScaleZEditable()
 {
-    return ( this->viewsUsingThisAsComparisonView().empty() || ( this->viewController() && this->viewController()->isCameraLinked() ) );
+    return ( viewsUsingThisAsComparisonView().empty() || ( viewController() && viewController()->isCameraLinked() ) );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -610,7 +610,7 @@ bool Rim3dView::isTimeStepDependentDataVisibleInThisOrComparisonView() const
 //--------------------------------------------------------------------------------------------------
 size_t Rim3dView::timeStepCount()
 {
-    return this->onTimeStepCountRequested();
+    return onTimeStepCountRequested();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -618,9 +618,9 @@ size_t Rim3dView::timeStepCount()
 //--------------------------------------------------------------------------------------------------
 QString Rim3dView::timeStepName( int frameIdx ) const
 {
-    if ( this->ownerCase() )
+    if ( ownerCase() )
     {
-        return this->ownerCase()->timeStepName( frameIdx );
+        return ownerCase()->timeStepName( frameIdx );
     }
     return QString( "" );
 }
@@ -638,7 +638,7 @@ void Rim3dView::setCurrentTimeStep( int frameIndex )
     if ( m_currentTimeStep != oldTimeStep )
     {
         RiuTimeStepChangedHandler::instance()->handleTimeStepChanged( this );
-        this->onClearReservoirCellVisibilitiesIfNecessary();
+        onClearReservoirCellVisibilitiesIfNecessary();
     }
 }
 
@@ -660,7 +660,7 @@ void Rim3dView::updateDisplayModelForCurrentTimeStepAndRedraw()
 
     if ( nativeOrOverrideViewer() )
     {
-        this->onUpdateDisplayModelForCurrentTimeStep();
+        onUpdateDisplayModelForCurrentTimeStep();
         appendAnnotationsToModel();
         appendMeasurementToModel();
         appendCellFiltersToModel();
@@ -680,7 +680,7 @@ void Rim3dView::updateDisplayModelForCurrentTimeStepAndRedraw()
 
     m_isCallingUpdateDisplayModelForCurrentTimestepAndRedraw = true;
 
-    std::set<Rim3dView*> containerViews = this->viewsUsingThisAsComparisonView();
+    std::set<Rim3dView*> containerViews = viewsUsingThisAsComparisonView();
     if ( !containerViews.empty() && !isUsingOverrideViewer() )
     {
         for ( auto view : containerViews )
@@ -701,7 +701,7 @@ void Rim3dView::createDisplayModelAndRedraw()
 {
     if ( nativeOrOverrideViewer() )
     {
-        this->onClampCurrentTimestep();
+        onClampCurrentTimestep();
 
         onUpdateScaleTransform();
 
@@ -783,7 +783,7 @@ void Rim3dView::setDefaultView()
 //--------------------------------------------------------------------------------------------------
 void Rim3dView::endAnimation()
 {
-    this->onUpdateStaticCellColors();
+    onUpdateStaticCellColors();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -936,7 +936,7 @@ void Rim3dView::fieldChangedByUi( const caf::PdmFieldHandle* changedField, const
 
         RiuMainWindow::instance()->updateScaleValue();
 
-        RimViewLinker* viewLinker = this->assosiatedViewLinker();
+        RimViewLinker* viewLinker = assosiatedViewLinker();
         if ( viewLinker )
         {
             viewLinker->updateScaleZ( this, scaleZ() );
@@ -995,8 +995,8 @@ void Rim3dView::fieldChangedByUi( const caf::PdmFieldHandle* changedField, const
                 fontHolder->updateFonts();
             }
         }
-        this->applyBackgroundColorAndFontChanges();
-        this->updateConnectedEditors();
+        applyBackgroundColorAndFontChanges();
+        updateConnectedEditors();
     }
     else if ( changedField == &maximumFrameRate )
     {
@@ -1026,13 +1026,13 @@ void Rim3dView::fieldChangedByUi( const caf::PdmFieldHandle* changedField, const
 //--------------------------------------------------------------------------------------------------
 void Rim3dView::addWellPathsToModel( cvf::ModelBasicList* wellPathModelBasicList, const cvf::BoundingBox& wellPathClipBoundingBox )
 {
-    if ( !this->ownerCase() ) return;
+    if ( !ownerCase() ) return;
 
     cvf::ref<caf::DisplayCoordTransform> transForm = displayCoordTransform();
 
     m_wellPathsPartManager->appendStaticGeometryPartsToModel( wellPathModelBasicList,
                                                               transForm.p(),
-                                                              this->ownerCase()->characteristicCellSize(),
+                                                              ownerCase()->characteristicCellSize(),
                                                               wellPathClipBoundingBox );
 
     wellPathModelBasicList->updateBoundingBoxesRecursive();
@@ -1043,7 +1043,7 @@ void Rim3dView::addWellPathsToModel( cvf::ModelBasicList* wellPathModelBasicList
 //--------------------------------------------------------------------------------------------------
 void Rim3dView::addDynamicWellPathsToModel( cvf::ModelBasicList* wellPathModelBasicList, const cvf::BoundingBox& wellPathClipBoundingBox )
 {
-    if ( !this->ownerCase() ) return;
+    if ( !ownerCase() ) return;
 
     cvf::ref<caf::DisplayCoordTransform> transForm = displayCoordTransform();
 
@@ -1051,7 +1051,7 @@ void Rim3dView::addDynamicWellPathsToModel( cvf::ModelBasicList* wellPathModelBa
     m_wellPathsPartManager->appendDynamicGeometryPartsToModel( wellPathModelBasicList,
                                                                timeStepIndex,
                                                                transForm.p(),
-                                                               this->ownerCase()->characteristicCellSize(),
+                                                               ownerCase()->characteristicCellSize(),
                                                                wellPathClipBoundingBox );
 
     wellPathModelBasicList->updateBoundingBoxesRecursive();
@@ -1062,7 +1062,7 @@ void Rim3dView::addDynamicWellPathsToModel( cvf::ModelBasicList* wellPathModelBa
 //--------------------------------------------------------------------------------------------------
 void Rim3dView::addAnnotationsToModel( cvf::ModelBasicList* annotationsModel )
 {
-    if ( !this->ownerCase() ) return;
+    if ( !ownerCase() ) return;
 
     auto annotationCollections = descendantsIncludingThisOfType<RimAnnotationInViewCollection>();
 
@@ -1084,7 +1084,7 @@ void Rim3dView::addAnnotationsToModel( cvf::ModelBasicList* annotationsModel )
 //--------------------------------------------------------------------------------------------------
 void Rim3dView::addCellFiltersToModel( cvf::ModelBasicList* cellFilterModel )
 {
-    if ( !this->ownerCase() ) return;
+    if ( !ownerCase() ) return;
 
     cvf::ref<caf::DisplayCoordTransform> transForm = displayCoordTransform();
     m_cellfilterPartManager->appendGeometryPartsToModel( cellFilterModel, transForm.p(), ownerCase()->allCellsBoundingBox() );
@@ -1097,7 +1097,7 @@ void Rim3dView::addCellFiltersToModel( cvf::ModelBasicList* cellFilterModel )
 //--------------------------------------------------------------------------------------------------
 void Rim3dView::addMeasurementToModel( cvf::ModelBasicList* measureModel )
 {
-    if ( !this->ownerCase() ) return;
+    if ( !ownerCase() ) return;
 
     RimMeasurement* measurement = RimProject::current()->measurement();
 
@@ -1124,7 +1124,7 @@ void Rim3dView::addMeasurementToModel( cvf::ModelBasicList* measureModel )
 //---------------------------------------------------- ----------------------------------------------
 bool Rim3dView::isMasterView() const
 {
-    RimViewLinker* viewLinker = this->assosiatedViewLinker();
+    RimViewLinker* viewLinker = assosiatedViewLinker();
     return viewLinker && this == viewLinker->masterView();
 }
 
@@ -1197,7 +1197,7 @@ void Rim3dView::setScaleZAndUpdate( double scalingFactor )
 {
     if ( scaleZ() != scalingFactor )
     {
-        this->m_scaleZ.setValueWithFieldChanged( scalingFactor );
+        m_scaleZ.setValueWithFieldChanged( scalingFactor );
     }
 }
 
@@ -1230,8 +1230,8 @@ void Rim3dView::updateScaling()
         dir = viewer()->mainCamera()->direction();
         up  = viewer()->mainCamera()->up();
 
-        eye[2] = poi[2] * m_scaleZ() / this->scaleTransform()->worldTransform()( 2, 2 ) + ( eye[2] - poi[2] );
-        poi[2] = poi[2] * m_scaleZ() / this->scaleTransform()->worldTransform()( 2, 2 );
+        eye[2] = poi[2] * m_scaleZ() / scaleTransform()->worldTransform()( 2, 2 ) + ( eye[2] - poi[2] );
+        poi[2] = poi[2] * m_scaleZ() / scaleTransform()->worldTransform()( 2, 2 );
 
         viewer()->mainCamera()->setFromLookAt( eye, eye + dir, up );
         viewer()->setPointOfInterest( poi );
@@ -1246,7 +1246,7 @@ void Rim3dView::updateScaling()
     updateGridBoxData();
     updateZScaleLabel();
 
-    this->scheduleCreateDisplayModelAndRedraw();
+    scheduleCreateDisplayModelAndRedraw();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -1319,7 +1319,7 @@ void Rim3dView::createHighlightAndGridBoxDisplayModel()
         nativeOrOverrideViewer()->addStaticModelOnce( m_highlightVizModel.p(), isUsingOverrideViewer() );
     }
 
-    this->updateGridBoxData();
+    updateGridBoxData();
 
     if ( viewer() ) viewer()->showGridBox( m_showGridBox() );
 }
@@ -1355,7 +1355,7 @@ void Rim3dView::applyBackgroundColorAndFontChanges()
     updateConnectedEditors();
 
     onUpdateLegends();
-    this->scheduleCreateDisplayModelAndRedraw();
+    scheduleCreateDisplayModelAndRedraw();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -1431,7 +1431,7 @@ void Rim3dView::updateDisplayModelVisibility()
     viewer()->setEnableMask( mask, false );
     viewer()->setEnableMask( mask, true );
 
-    this->onUpdateDisplayModelVisibility();
+    onUpdateDisplayModelVisibility();
 
     viewer()->update();
 }
@@ -1627,7 +1627,7 @@ void Rim3dView::appendAnnotationsToModel()
     if ( frameScene )
     {
         cvf::String name = "Annotations";
-        this->removeModelByName( frameScene, name );
+        removeModelByName( frameScene, name );
 
         cvf::ref<cvf::ModelBasicList> model = new cvf::ModelBasicList;
         model->setName( name );
@@ -1649,7 +1649,7 @@ void Rim3dView::appendCellFiltersToModel()
     if ( frameScene )
     {
         cvf::String name = "CellFilters";
-        this->removeModelByName( frameScene, name );
+        removeModelByName( frameScene, name );
 
         cvf::ref<cvf::ModelBasicList> model = new cvf::ModelBasicList;
         model->setName( name );
@@ -1671,7 +1671,7 @@ void Rim3dView::appendMeasurementToModel()
     if ( frameScene )
     {
         cvf::String name = "Measurement";
-        this->removeModelByName( frameScene, name );
+        removeModelByName( frameScene, name );
 
         cvf::ref<cvf::ModelBasicList> model = new cvf::ModelBasicList;
         model->setName( name );

ApplicationLibCode/ProjectDataModel/RimCase.cpp

@@ -123,8 +123,8 @@ void RimCase::setGridFileName( const QString& fileName )
 {
     m_caseFileName.v().setPath( fileName );
 
-    this->updateAutoShortName();
-    this->updateTreeItemName();
+    updateAutoShortName();
+    updateTreeItemName();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -167,7 +167,7 @@ std::vector<Rim3dView*> RimCase::views() const
 {
     if ( m_isInActiveDestruction ) return std::vector<Rim3dView*>();
 
-    std::vector<Rim3dView*>             allViews   = this->allSpecialViews();
+    std::vector<Rim3dView*>             allViews   = allSpecialViews();
     std::vector<Rim2dIntersectionView*> isectViews = m_2dIntersectionViewCollection->views();
 
     for ( auto view : isectViews )

ApplicationLibCode/ProjectDataModel/RimCaseCollection.cpp

@@ -49,7 +49,7 @@ RimCaseCollection::~RimCaseCollection()
 //--------------------------------------------------------------------------------------------------
 RimIdenticalGridCaseGroup* RimCaseCollection::parentCaseGroup()
 {
-    return dynamic_cast<RimIdenticalGridCaseGroup*>( this->parentField()->ownerObject() );
+    return dynamic_cast<RimIdenticalGridCaseGroup*>( parentField()->ownerObject() );
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/RimCellEdgeColors.cpp

@@ -184,7 +184,7 @@ void RimCellEdgeColors::loadResult()
 //--------------------------------------------------------------------------------------------------
 void RimCellEdgeColors::initAfterRead()
 {
-    this->updateUiIconFromToggleField();
+    updateUiIconFromToggleField();
 
     if ( m_singleVarEdgeResultColors_OBSOLETE->resultVariableUiName() != RiaResultNames::undefinedResultName() )
     {
@@ -432,10 +432,10 @@ void RimCellEdgeColors::cellEdgeMetaData( std::vector<RimCellEdgeMetaData>* meta
 {
     CVF_ASSERT( metaDataVector );
 
-    auto addresses = this->resultAddresses();
+    auto addresses = resultAddresses();
 
     std::vector<QString> resultNames;
-    this->gridScalarResultNames( &resultNames );
+    gridScalarResultNames( &resultNames );
 
     bool isStatic = true;
 

ApplicationLibCode/ProjectDataModel/RimColorLegend.cpp

@@ -127,7 +127,7 @@ void RimColorLegend::fieldChangedByUi( const caf::PdmFieldHandle* changedField,
 //--------------------------------------------------------------------------------------------------
 void RimColorLegend::defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName )
 {
-    this->setUiIcon( paletteIconProvider() );
+    setUiIcon( paletteIconProvider() );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -181,7 +181,7 @@ caf::IconProvider RimColorLegend::paletteIconProvider() const
 //--------------------------------------------------------------------------------------------------
 void RimColorLegend::onColorLegendItemHasChanged()
 {
-    this->updateConnectedEditors();
+    updateConnectedEditors();
 
     std::vector<caf::PdmObjectHandle*> referringObjects = objectsWithReferringPtrFields();
 

ApplicationLibCode/ProjectDataModel/RimColorLegendCollection.cpp

@@ -181,7 +181,7 @@ void RimColorLegendCollection::createStandardColorLegends()
 
     m_standardColorLegends.push_back( createRockTypeColorLegend() );
 
-    this->updateConnectedEditors();
+    updateConnectedEditors();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/RimColorLegendItem.cpp

@@ -159,8 +159,8 @@ void RimColorLegendItem::defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeOrd
 {
     QColor qcolor( m_color().rByte(), m_color().gByte(), m_color().bByte() );
 
-    caf::IconProvider iconProvider = this->uiIconProvider();
+    caf::IconProvider iconProvider = uiIconProvider();
 
     iconProvider.setBackgroundColorString( qcolor.name() );
-    this->setUiIcon( iconProvider );
+    setUiIcon( iconProvider );
 }

ApplicationLibCode/ProjectDataModel/RimCommandObject.cpp

@@ -89,7 +89,7 @@ void RimCommandExecuteScript::redo()
         QStringList arguments = app->octaveArguments();
 
         arguments.append( "--eval" );
-        arguments << this->scriptText();
+        arguments << scriptText();
 
         RiaApplication::instance()->launchProcess( octavePath, arguments, app->octaveProcessEnvironment() );
     }
@@ -210,11 +210,11 @@ void RimCommandIssueFieldChanged::redo()
     RiaApplication* app     = RiaApplication::instance();
     PdmObject*      project = app->project();
 
-    caf::PdmObjectHandle* pdmObject = findObjectByName( project, this->objectName );
+    caf::PdmObjectHandle* pdmObject = findObjectByName( project, objectName );
 
     if ( pdmObject )
     {
-        caf::PdmFieldHandle* fieldHandle = findFieldByKeyword( pdmObject, this->fieldName );
+        caf::PdmFieldHandle* fieldHandle = findFieldByKeyword( pdmObject, fieldName );
 
         if ( fieldHandle && fieldHandle->uiCapability() )
         {
@@ -222,7 +222,7 @@ void RimCommandIssueFieldChanged::redo()
             CVF_ASSERT( valueField );
 
             QVariant oldValue = valueField->toQVariant();
-            QVariant newValue( this->fieldValueToApply );
+            QVariant newValue( fieldValueToApply );
 
             valueField->setFromQVariant( newValue );
 

ApplicationLibCode/ProjectDataModel/RimContourMapProjection.cpp

@@ -334,7 +334,7 @@ cvf::Vec2ui RimContourMapProjection::numberOfElementsIJ() const
 //--------------------------------------------------------------------------------------------------
 cvf::Vec2ui RimContourMapProjection::numberOfVerticesIJ() const
 {
-    cvf::Vec2ui mapSize = this->numberOfElementsIJ();
+    cvf::Vec2ui mapSize = numberOfElementsIJ();
     mapSize.x() += 1u;
     mapSize.y() += 1u;
     return mapSize;
@@ -1546,7 +1546,7 @@ double RimContourMapProjection::calculateValueAtVertex( uint vi, uint vj ) const
 //--------------------------------------------------------------------------------------------------
 std::vector<std::pair<size_t, double>> RimContourMapProjection::cellsAtIJ( uint i, uint j ) const
 {
-    size_t cellIndex = this->cellIndexFromIJ( i, j );
+    size_t cellIndex = cellIndexFromIJ( i, j );
     if ( cellIndex < m_projected3dGridIndices.size() )
     {
         return m_projected3dGridIndices[cellIndex];

ApplicationLibCode/ProjectDataModel/RimDepthTrackPlot.cpp

@@ -1265,7 +1265,7 @@ void RimDepthTrackPlot::updatePlots()
         {
             plot->loadDataAndUpdate();
         }
-        this->updateZoom();
+        updateZoom();
     }
 }
 

ApplicationLibCode/ProjectDataModel/RimEclipseCase.cpp

@@ -129,7 +129,7 @@ RimEclipseCase::RimEclipseCase()
     m_fractureModelResults.uiCapability()->setUiTreeHidden( true );
     m_fractureModelResults.uiCapability()->setUiTreeChildrenHidden( true );
 
-    this->setReservoirData( nullptr );
+    setReservoirData( nullptr );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -151,15 +151,15 @@ RimEclipseCase::~RimEclipseCase()
             RimWellLogPlotCollection* plotCollection = project->mainPlotCollection()->wellLogPlotCollection();
             if ( plotCollection )
             {
-                plotCollection->removeExtractors( this->eclipseCaseData() );
+                plotCollection->removeExtractors( eclipseCaseData() );
             }
         }
     }
 
-    if ( this->eclipseCaseData() )
+    if ( eclipseCaseData() )
     {
         // At this point, we assume that memory should be released
-        CVF_ASSERT( this->eclipseCaseData()->refCount() == 1 );
+        CVF_ASSERT( eclipseCaseData()->refCount() == 1 );
     }
 }
 
@@ -217,7 +217,7 @@ cvf::Color3f RimEclipseCase::defaultWellColor( const QString& wellName )
         cvf::Color3ubArray     wellColors             = colorTable.color3ubArray();
         cvf::Color3ubArray     interpolatedWellColors = wellColors;
 
-        const cvf::Collection<RigSimWellData>& simWellData = this->eclipseCaseData()->wellResults();
+        const cvf::Collection<RigSimWellData>& simWellData = eclipseCaseData()->wellResults();
         if ( simWellData.size() > 1 )
         {
             interpolatedWellColors = caf::ColorTable::interpolateColorArray( wellColors, simWellData.size() );
@@ -665,7 +665,7 @@ void RimEclipseCase::computeCachedData()
 //--------------------------------------------------------------------------------------------------
 RimCaseCollection* RimEclipseCase::parentCaseCollection()
 {
-    return dynamic_cast<RimCaseCollection*>( this->parentField()->ownerObject() );
+    return dynamic_cast<RimCaseCollection*>( parentField()->ownerObject() );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -708,8 +708,8 @@ void RimEclipseCase::loadAndSynchronizeInputProperties( bool importGridOrFaultDa
 {
     // Make sure we actually have reservoir data
 
-    CVF_ASSERT( this->eclipseCaseData() );
-    CVF_ASSERT( this->eclipseCaseData()->mainGrid()->gridPointDimensions() != cvf::Vec3st( 0, 0, 0 ) );
+    CVF_ASSERT( eclipseCaseData() );
+    CVF_ASSERT( eclipseCaseData()->mainGrid()->gridPointDimensions() != cvf::Vec3st( 0, 0, 0 ) );
 
     // Then read the properties from all the files referenced by the InputReservoir
 
@@ -778,7 +778,7 @@ void RimEclipseCase::createDisplayModelAndUpdateAllViews()
 void RimEclipseCase::setReservoirData( RigEclipseCaseData* eclipseCase )
 {
     m_rigEclipseCase = eclipseCase;
-    if ( this->eclipseCaseData() )
+    if ( eclipseCaseData() )
     {
         m_fractureModelResults()->setCellResults( eclipseCaseData()->results( RiaDefines::PorosityModelType::FRACTURE_MODEL ) );
         m_matrixModelResults()->setCellResults( eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL ) );
@@ -1092,7 +1092,7 @@ QStringList RimEclipseCase::timeStepStrings() const
         int timeStepCount = static_cast<int>( cellResultData->maxTimeStepCount() );
         for ( int i = 0; i < timeStepCount; i++ )
         {
-            stringList += this->timeStepName( i );
+            stringList += timeStepName( i );
         }
     }
 

ApplicationLibCode/ProjectDataModel/RimEclipseCellColors.cpp

@@ -54,17 +54,17 @@ RimEclipseCellColors::RimEclipseCellColors()
     CAF_PDM_InitScriptableObjectWithNameAndComment( "Cell Result", ":/CellResult.png", "", "", "CellColors", "Eclipse Cell Colors class" );
 
     CAF_PDM_InitFieldNoDefault( &obsoleteField_legendConfig, "LegendDefinition", "Color Legend" );
-    this->obsoleteField_legendConfig.xmlCapability()->setIOWritable( false );
+    obsoleteField_legendConfig.xmlCapability()->setIOWritable( false );
 
     CAF_PDM_InitFieldNoDefault( &m_legendConfigData, "ResultVarLegendDefinitionList", "" );
 
     CAF_PDM_InitFieldNoDefault( &m_ternaryLegendConfig, "TernaryLegendDefinition", "Ternary Color Legend" );
-    this->m_ternaryLegendConfig = new RimTernaryLegendConfig();
+    m_ternaryLegendConfig = new RimTernaryLegendConfig();
 
     CAF_PDM_InitFieldNoDefault( &m_legendConfigPtrField, "LegendDefinitionPtrField", "Color Legend PtrField" );
 
     // Make sure we have a created legend for the default/undefined result variable
-    changeLegendConfig( this->resultVariable() );
+    changeLegendConfig( resultVariable() );
 
     m_useDiscreteLogLevels = false;
 }
@@ -89,21 +89,21 @@ void RimEclipseCellColors::fieldChangedByUi( const caf::PdmFieldHandle* changedF
     RimEclipseResultDefinition::fieldChangedByUi( changedField, oldValue, newValue );
 
     // Update of legend config must happen after RimEclipseResultDefinition::fieldChangedByUi(), as this function
-    // modifies this->resultVariable()
+    // modifies resultVariable()
     if ( changedField == &m_resultVariableUiField )
     {
         if ( oldValue != newValue )
         {
-            changeLegendConfig( this->resultVariableUiName() );
+            changeLegendConfig( resultVariableUiName() );
         }
 
-        RimEclipseFaultColors* faultColors = dynamic_cast<RimEclipseFaultColors*>( this->parentField()->ownerObject() );
+        RimEclipseFaultColors* faultColors = dynamic_cast<RimEclipseFaultColors*>( parentField()->ownerObject() );
         if ( faultColors )
         {
             faultColors->updateConnectedEditors();
         }
 
-        RimCellEdgeColors* cellEdgeColors = dynamic_cast<RimCellEdgeColors*>( this->parentField()->ownerObject() );
+        RimCellEdgeColors* cellEdgeColors = dynamic_cast<RimCellEdgeColors*>( parentField()->ownerObject() );
         if ( cellEdgeColors )
         {
             cellEdgeColors->updateConnectedEditors();
@@ -122,20 +122,20 @@ void RimEclipseCellColors::changeLegendConfig( QString resultVarNameOfNewLegend
     {
         QString legendResultVariable;
 
-        if ( this->m_legendConfigPtrField() )
+        if ( m_legendConfigPtrField() )
         {
-            legendResultVariable = this->m_legendConfigPtrField()->resultVariableName();
+            legendResultVariable = m_legendConfigPtrField()->resultVariableName();
         }
 
-        if ( !this->m_legendConfigPtrField() || legendResultVariable != resultVarNameOfNewLegend )
+        if ( !m_legendConfigPtrField() || legendResultVariable != resultVarNameOfNewLegend )
         {
             bool found = false;
             for ( size_t i = 0; i < m_legendConfigData.size(); i++ )
             {
                 if ( m_legendConfigData[i]->resultVariableName() == resultVarNameOfNewLegend )
                 {
-                    this->m_legendConfigPtrField = m_legendConfigData[i];
-                    found                        = true;
+                    m_legendConfigPtrField = m_legendConfigData[i];
+                    found                  = true;
                     break;
                 }
             }
@@ -145,14 +145,13 @@ void RimEclipseCellColors::changeLegendConfig( QString resultVarNameOfNewLegend
                 int caseId = 0;
                 if ( eclipseCase() ) caseId = eclipseCase()->caseId();
 
-                auto newLegend =
-                    createLegendForResult( caseId, resultVarNameOfNewLegend, this->m_useDiscreteLogLevels, this->hasCategoryResult() );
+                auto newLegend = createLegendForResult( caseId, resultVarNameOfNewLegend, m_useDiscreteLogLevels, hasCategoryResult() );
 
                 newLegend->changed.connect( this, &RimEclipseCellColors::onLegendConfigChanged );
 
                 m_legendConfigData.push_back( newLegend );
 
-                this->m_legendConfigPtrField = newLegend;
+                m_legendConfigPtrField = newLegend;
             }
         }
     }
@@ -187,9 +186,9 @@ void RimEclipseCellColors::initAfterRead()
 {
     RimEclipseResultDefinition::initAfterRead();
 
-    if ( this->m_legendConfigPtrField() && this->m_legendConfigPtrField()->resultVariableName() == "" )
+    if ( m_legendConfigPtrField() && m_legendConfigPtrField()->resultVariableName() == "" )
     {
-        this->m_legendConfigPtrField()->resultVariableName = this->resultVariable();
+        m_legendConfigPtrField()->resultVariableName = resultVariable();
     }
 
     if ( obsoleteField_legendConfig )
@@ -206,7 +205,7 @@ void RimEclipseCellColors::initAfterRead()
         m_legendConfigPtrField = obsoleteLegend;
     }
 
-    changeLegendConfig( this->resultVariable() );
+    changeLegendConfig( resultVariable() );
 
     updateIconState();
 }
@@ -229,7 +228,7 @@ void RimEclipseCellColors::defineUiOrdering( QString uiConfigName, caf::PdmUiOrd
 //--------------------------------------------------------------------------------------------------
 void RimEclipseCellColors::defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName /*= ""*/ )
 {
-    if ( this->resultVariable() == RiaResultNames::ternarySaturationResultName() )
+    if ( resultVariable() == RiaResultNames::ternarySaturationResultName() )
     {
         uiTreeOrdering.add( m_ternaryLegendConfig() );
     }
@@ -251,7 +250,7 @@ void RimEclipseCellColors::defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeO
 //--------------------------------------------------------------------------------------------------
 void RimEclipseCellColors::updateLegendCategorySettings()
 {
-    changeLegendConfig( this->resultVariableUiName() );
+    changeLegendConfig( resultVariableUiName() );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -286,7 +285,7 @@ void RimEclipseCellColors::setReservoirView( RimEclipseView* ownerReservoirView
     m_reservoirView = ownerReservoirView;
     if ( ownerReservoirView )
     {
-        this->setEclipseCase( ownerReservoirView->eclipseCase() );
+        setEclipseCase( ownerReservoirView->eclipseCase() );
     }
 }
 
@@ -303,7 +302,7 @@ RimEclipseView* RimEclipseCellColors::reservoirView()
 //--------------------------------------------------------------------------------------------------
 void RimEclipseCellColors::updateRangesForEmbeddedLegends( int currentTimeStep )
 {
-    this->updateRangesForExplicitLegends( legendConfig(), m_ternaryLegendConfig(), currentTimeStep );
+    updateRangesForExplicitLegends( legendConfig(), m_ternaryLegendConfig(), currentTimeStep );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -313,7 +312,7 @@ void RimEclipseCellColors::setResultVariable( const QString& val )
 {
     RimEclipseResultDefinition::setResultVariable( val );
 
-    this->changeLegendConfig( val );
+    changeLegendConfig( val );
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/RimEclipseContourMapProjection.cpp

@@ -165,10 +165,10 @@ double RimEclipseContourMapProjection::sampleSpacing() const
 //--------------------------------------------------------------------------------------------------
 void RimEclipseContourMapProjection::clearGridMappingAndRedraw()
 {
-    this->clearGridMapping();
-    this->updateConnectedEditors();
-    this->generateResultsIfNecessary( view()->currentTimeStep() );
-    this->updateLegend();
+    clearGridMapping();
+    updateConnectedEditors();
+    generateResultsIfNecessary( view()->currentTimeStep() );
+    updateLegend();
 
     RimEclipseView* parentView = firstAncestorOrThisOfTypeAsserted<RimEclipseView>();
     parentView->scheduleCreateDisplayModelAndRedraw();

ApplicationLibCode/ProjectDataModel/RimEclipseContourMapView.cpp

@@ -191,15 +191,15 @@ void RimEclipseContourMapView::onCreateDisplayModel()
 {
     RimEclipseView::onCreateDisplayModel();
 
-    if ( !this->isTimeStepDependentDataVisible() )
+    if ( !isTimeStepDependentDataVisible() )
     {
         // Need to add geometry even if it hasn't happened during dynamic time step update.
         updateGeometry();
     }
 
-    if ( this->viewer()->mainCamera()->viewMatrix() == sm_defaultViewMatrix )
+    if ( viewer()->mainCamera()->viewMatrix() == sm_defaultViewMatrix )
     {
-        this->zoomAll();
+        zoomAll();
     }
 }
 
@@ -209,8 +209,8 @@ void RimEclipseContourMapView::onCreateDisplayModel()
 void RimEclipseContourMapView::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
 {
     caf::PdmUiGroup* viewGroup = uiOrdering.addNewGroup( "Viewer" );
-    viewGroup->add( this->userDescriptionField() );
-    viewGroup->add( this->backgroundColorField() );
+    viewGroup->add( userDescriptionField() );
+    viewGroup->add( backgroundColorField() );
     viewGroup->add( &m_showAxisLines );
     viewGroup->add( &m_showScaleLegend );
 
@@ -325,7 +325,7 @@ void RimEclipseContourMapView::appendContourMapProjectionToModel()
             cvf::ref<cvf::ModelBasicList> contourMapProjectionModelBasicList = new cvf::ModelBasicList;
             contourMapProjectionModelBasicList->setName( name );
 
-            cvf::ref<caf::DisplayCoordTransform> transForm = this->displayCoordTransform();
+            cvf::ref<caf::DisplayCoordTransform> transForm = displayCoordTransform();
 
             m_contourMapProjectionPartMgr->appendProjectionToModel( contourMapProjectionModelBasicList.p(), transForm.p() );
             contourMapProjectionModelBasicList->updateBoundingBoxesRecursive();
@@ -350,7 +350,7 @@ void RimEclipseContourMapView::appendContourLinesToModel()
             cvf::ref<cvf::ModelBasicList> contourMapLabelModelBasicList = new cvf::ModelBasicList;
             contourMapLabelModelBasicList->setName( name );
 
-            cvf::ref<caf::DisplayCoordTransform> transForm = this->displayCoordTransform();
+            cvf::ref<caf::DisplayCoordTransform> transForm = displayCoordTransform();
 
             m_contourMapProjectionPartMgr->appendContourLinesToModel( viewer()->mainCamera(), contourMapLabelModelBasicList.p(), transForm.p() );
             contourMapLabelModelBasicList->updateBoundingBoxesRecursive();
@@ -375,7 +375,7 @@ void RimEclipseContourMapView::appendPickPointVisToModel()
             cvf::ref<cvf::ModelBasicList> contourMapProjectionModelBasicList = new cvf::ModelBasicList;
             contourMapProjectionModelBasicList->setName( name );
 
-            cvf::ref<caf::DisplayCoordTransform> transForm = this->displayCoordTransform();
+            cvf::ref<caf::DisplayCoordTransform> transForm = displayCoordTransform();
 
             m_contourMapProjectionPartMgr->appendPickPointVisToModel( contourMapProjectionModelBasicList.p(), transForm.p() );
             contourMapProjectionModelBasicList->updateBoundingBoxesRecursive();

ApplicationLibCode/ProjectDataModel/RimEclipseFaultColors.cpp

@@ -69,7 +69,7 @@ void RimEclipseFaultColors::setReservoirView( RimEclipseView* ownerReservoirView
 //--------------------------------------------------------------------------------------------------
 void RimEclipseFaultColors::fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue )
 {
-    this->updateUiIconFromToggleField();
+    updateUiIconFromToggleField();
 
     if ( m_reservoirView ) m_reservoirView->scheduleCreateDisplayModelAndRedraw();
 }
@@ -81,7 +81,7 @@ void RimEclipseFaultColors::initAfterRead()
 {
     m_customFaultResultColors->initAfterRead();
 
-    this->updateUiIconFromToggleField();
+    updateUiIconFromToggleField();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -89,7 +89,7 @@ void RimEclipseFaultColors::initAfterRead()
 //--------------------------------------------------------------------------------------------------
 RimEclipseCellColors* RimEclipseFaultColors::customFaultResult()
 {
-    return this->m_customFaultResultColors();
+    return m_customFaultResultColors();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -127,7 +127,7 @@ void RimEclipseFaultColors::defineUiOrdering( QString uiConfigName, caf::PdmUiOr
 //--------------------------------------------------------------------------------------------------
 bool RimEclipseFaultColors::hasValidCustomResult()
 {
-    if ( this->showCustomFaultResult() )
+    if ( showCustomFaultResult() )
     {
         if ( m_customFaultResultColors->hasResult() || m_customFaultResultColors->isTernarySaturationSelected() )
         {

ApplicationLibCode/ProjectDataModel/RimEclipseInputCase.cpp

@@ -86,7 +86,7 @@ bool RimEclipseInputCase::openDataFileSet( const QStringList& fileNames )
 {
     if ( fileNames.contains( RiaDefines::mockModelBasicInputCase() ) )
     {
-        cvf::ref<RifReaderInterface> readerInterface = this->createMockModel( fileNames[0] );
+        cvf::ref<RifReaderInterface> readerInterface = createMockModel( fileNames[0] );
         results( RiaDefines::PorosityModelType::MATRIX_MODEL )->setReaderInterface( readerInterface.p() );
         results( RiaDefines::PorosityModelType::FRACTURE_MODEL )->setReaderInterface( readerInterface.p() );
 
@@ -95,16 +95,16 @@ bool RimEclipseInputCase::openDataFileSet( const QStringList& fileNames )
 
         QFileInfo gridFileName( fileNames[0] );
         QString   caseName = gridFileName.completeBaseName();
-        this->setCaseUserDescription( caseName );
+        setCaseUserDescription( caseName );
 
         computeCachedData();
 
         return true;
     }
 
-    if ( this->eclipseCaseData() == nullptr )
+    if ( eclipseCaseData() == nullptr )
     {
-        this->setReservoirData( new RigEclipseCaseData( this ) );
+        setReservoirData( new RigEclipseCaseData( this ) );
     }
 
     bool importFaults = RiaPreferences::current()->readerSettings()->importFaults();
@@ -114,12 +114,12 @@ bool RimEclipseInputCase::openDataFileSet( const QStringList& fileNames )
     QString gridFileName;
 
     // First find and read the grid data
-    if ( this->eclipseCaseData()->mainGrid()->gridPointDimensions() == cvf::Vec3st( 0, 0, 0 ) )
+    if ( eclipseCaseData()->mainGrid()->gridPointDimensions() == cvf::Vec3st( 0, 0, 0 ) )
     {
         for ( int i = 0; i < fileNames.size(); i++ )
         {
             QString errorMessages;
-            if ( RifEclipseInputFileTools::openGridFile( fileNames[i], this->eclipseCaseData(), importFaults, &errorMessages ) )
+            if ( RifEclipseInputFileTools::openGridFile( fileNames[i], eclipseCaseData(), importFaults, &errorMessages ) )
             {
                 setGridFileName( fileNames[i] );
                 gridFileName = fileNames[i];
@@ -127,9 +127,9 @@ bool RimEclipseInputCase::openDataFileSet( const QStringList& fileNames )
                 QFileInfo gridFileName( fileNames[i] );
                 QString   caseName = gridFileName.completeBaseName();
 
-                this->setCaseUserDescription( caseName );
+                setCaseUserDescription( caseName );
 
-                this->eclipseCaseData()->mainGrid()->setFlipAxis( m_flipXAxis, m_flipYAxis );
+                eclipseCaseData()->mainGrid()->setFlipAxis( m_flipXAxis, m_flipYAxis );
 
                 computeCachedData();
 
@@ -142,7 +142,7 @@ bool RimEclipseInputCase::openDataFileSet( const QStringList& fileNames )
         }
     }
 
-    if ( this->eclipseCaseData()->mainGrid()->gridPointDimensions() == cvf::Vec3st( 0, 0, 0 ) )
+    if ( eclipseCaseData()->mainGrid()->gridPointDimensions() == cvf::Vec3st( 0, 0, 0 ) )
     {
         for ( QString errorMessages : allErrorMessages )
         {
@@ -173,12 +173,12 @@ bool RimEclipseInputCase::openDataFileSet( const QStringList& fileNames )
 
     if ( !filesToRead.empty() )
     {
-        RifInputPropertyLoader::loadAndSynchronizeInputProperties( m_inputPropertyCollection, this->eclipseCaseData(), filesToRead, importFaults );
+        RifInputPropertyLoader::loadAndSynchronizeInputProperties( m_inputPropertyCollection, eclipseCaseData(), filesToRead, importFaults );
     }
 
     if ( importFaults )
     {
-        this->ensureFaultDataIsComputed();
+        ensureFaultDataIsComputed();
     }
 
     results( RiaDefines::PorosityModelType::MATRIX_MODEL )->createPlaceholderResultEntries();
@@ -192,13 +192,13 @@ bool RimEclipseInputCase::openDataFileSet( const QStringList& fileNames )
 bool RimEclipseInputCase::openEclipseGridFile()
 {
     // Early exit if reservoir data is created
-    if ( this->eclipseCaseData() == nullptr )
+    if ( eclipseCaseData() == nullptr )
     {
         cvf::ref<RifReaderInterface> readerInterface;
 
         if ( gridFileName().contains( RiaDefines::mockModelBasicInputCase() ) )
         {
-            readerInterface = this->createMockModel( gridFileName() );
+            readerInterface = createMockModel( gridFileName() );
         }
         else
         {
@@ -210,16 +210,16 @@ bool RimEclipseInputCase::openEclipseGridFile()
                 return false;
             }
 
-            this->setReservoirData( eclipseCase.p() );
+            setReservoirData( eclipseCase.p() );
         }
 
-        CVF_ASSERT( this->eclipseCaseData() );
+        CVF_ASSERT( eclipseCaseData() );
         CVF_ASSERT( readerInterface.notNull() );
 
         results( RiaDefines::PorosityModelType::MATRIX_MODEL )->setReaderInterface( readerInterface.p() );
         results( RiaDefines::PorosityModelType::FRACTURE_MODEL )->setReaderInterface( readerInterface.p() );
 
-        this->eclipseCaseData()->mainGrid()->setFlipAxis( m_flipXAxis, m_flipYAxis );
+        eclipseCaseData()->mainGrid()->setFlipAxis( m_flipXAxis, m_flipYAxis );
 
         loadAndSynchronizeInputProperties( true );
         computeCachedData();
@@ -286,7 +286,7 @@ cvf::ref<RifReaderInterface> RimEclipseInputCase::createMockModel( QString model
         m_inputPropertyCollection->inputProperties.push_back( inputProperty );
     }
 
-    this->setReservoirData( reservoir.p() );
+    setReservoirData( reservoir.p() );
 
     return mockFileInterface.p();
 }

ApplicationLibCode/ProjectDataModel/RimEclipseInputPropertyCollection.cpp

@@ -52,7 +52,7 @@ std::vector<RimEclipseInputProperty*> RimEclipseInputPropertyCollection::findInp
 {
     QFileInfo                             fileInfo( fileName );
     std::vector<RimEclipseInputProperty*> result;
-    for ( size_t i = 0; i < this->inputProperties.size(); ++i )
+    for ( size_t i = 0; i < inputProperties.size(); ++i )
     {
         if ( !inputProperties[i] ) continue;
 
@@ -68,7 +68,7 @@ std::vector<RimEclipseInputProperty*> RimEclipseInputPropertyCollection::findInp
 //--------------------------------------------------------------------------------------------------
 RimEclipseInputProperty* RimEclipseInputPropertyCollection::findInputProperty( QString resultName )
 {
-    for ( size_t i = 0; i < this->inputProperties.size(); i++ )
+    for ( size_t i = 0; i < inputProperties.size(); i++ )
     {
         if ( inputProperties[i] && inputProperties[i]->resultName() == resultName )
         {

ApplicationLibCode/ProjectDataModel/RimEclipseResultCase.cpp

@@ -124,7 +124,7 @@ bool RimEclipseResultCase::importGridAndResultMetaData( bool showTimeStepFilter
 
     if ( gridFileName().contains( "Result Mock Debug Model" ) )
     {
-        readerInterface = this->createMockModel( this->gridFileName() );
+        readerInterface = createMockModel( gridFileName() );
     }
     else
     {
@@ -134,7 +134,7 @@ bool RimEclipseResultCase::importGridAndResultMetaData( bool showTimeStepFilter
         }
 
         cvf::ref<RifReaderEclipseOutput> readerEclipseOutput = new RifReaderEclipseOutput;
-        readerEclipseOutput->setFilenamesWithFaults( this->filesContainingFaults() );
+        readerEclipseOutput->setFilenamesWithFaults( filesContainingFaults() );
         readerEclipseOutput->setReaderSettings( m_readerSettings );
 
         cvf::ref<RifEclipseRestartDataAccess> restartDataAccess = RifEclipseOutputFileTools::createDynamicResultAccess( gridFileName() );
@@ -182,9 +182,9 @@ bool RimEclipseResultCase::importGridAndResultMetaData( bool showTimeStepFilter
             return false;
         }
 
-        this->setFilesContainingFaults( readerEclipseOutput->filenamesWithFaults() );
+        setFilesContainingFaults( readerEclipseOutput->filenamesWithFaults() );
 
-        this->setReservoirData( eclipseCase.p() );
+        setReservoirData( eclipseCase.p() );
 
         readerInterface = readerEclipseOutput;
     }
@@ -196,7 +196,7 @@ bool RimEclipseResultCase::importGridAndResultMetaData( bool showTimeStepFilter
 
     m_flowDagSolverInterface = new RigFlowDiagSolverInterface( this );
 
-    CVF_ASSERT( this->eclipseCaseData() );
+    CVF_ASSERT( eclipseCaseData() );
     CVF_ASSERT( readerInterface.notNull() );
 
     progInfo.setProgressDescription( "Computing Case Cache" );
@@ -237,7 +237,7 @@ bool RimEclipseResultCase::importAsciiInputProperties( const QStringList& fileNa
 {
     bool importFaults = false;
     RifInputPropertyLoader::loadAndSynchronizeInputProperties( m_inputPropertyCollection,
-                                                               this->eclipseCaseData(),
+                                                               eclipseCaseData(),
                                                                std::vector<QString>( fileNames.begin(), fileNames.end() ),
                                                                importFaults );
 
@@ -266,7 +266,7 @@ bool RimEclipseResultCase::openAndReadActiveCellData( RigEclipseCaseData* mainEc
     cvf::ref<RifReaderInterface> readerInterface;
     if ( gridFileName().contains( "Result Mock Debug Model" ) )
     {
-        readerInterface = this->createMockModel( this->gridFileName() );
+        readerInterface = createMockModel( gridFileName() );
     }
     else
     {
@@ -287,7 +287,7 @@ bool RimEclipseResultCase::openAndReadActiveCellData( RigEclipseCaseData* mainEc
             return false;
         }
 
-        this->setReservoirData( eclipseCase.p() );
+        setReservoirData( eclipseCase.p() );
 
         readerInterface = readerEclipseOutput;
     }
@@ -295,7 +295,7 @@ bool RimEclipseResultCase::openAndReadActiveCellData( RigEclipseCaseData* mainEc
     results( RiaDefines::PorosityModelType::MATRIX_MODEL )->setReaderInterface( readerInterface.p() );
     results( RiaDefines::PorosityModelType::FRACTURE_MODEL )->setReaderInterface( readerInterface.p() );
 
-    CVF_ASSERT( this->eclipseCaseData() );
+    CVF_ASSERT( eclipseCaseData() );
     CVF_ASSERT( readerInterface.notNull() );
 
     eclipseCaseData()->computeActiveCellBoundingBoxes();
@@ -468,7 +468,7 @@ cvf::ref<RifReaderInterface> RimEclipseResultCase::createMockModel( QString mode
         QApplication::restoreOverrideCursor();
     }
 
-    this->setReservoirData( reservoir.p() );
+    setReservoirData( reservoir.p() );
 
     return mockFileInterface.p();
 }
@@ -551,7 +551,7 @@ RifReaderRftInterface* RimEclipseResultCase::rftReader()
 //--------------------------------------------------------------------------------------------------
 void RimEclipseResultCase::setCaseInfo( const QString& userDescription, const QString& fileName )
 {
-    this->setCaseUserDescription( userDescription );
+    setCaseUserDescription( userDescription );
     setGridFileName( fileName );
 
     RimProject* proj = RimProject::current();

ApplicationLibCode/ProjectDataModel/RimEclipseResultDefinition.cpp

@@ -188,13 +188,13 @@ RimEclipseResultDefinition::~RimEclipseResultDefinition()
 //--------------------------------------------------------------------------------------------------
 void RimEclipseResultDefinition::simpleCopy( const RimEclipseResultDefinition* other )
 {
-    this->setResultVariable( other->resultVariable() );
-    this->setPorosityModel( other->porosityModel() );
-    this->setResultType( other->resultType() );
-    this->setFlowSolution( other->m_flowSolution() );
-    this->setSelectedInjectorTracers( other->m_selectedInjectorTracers() );
-    this->setSelectedProducerTracers( other->m_selectedProducerTracers() );
-    this->setSelectedSouringTracers( other->m_selectedSouringTracers() );
+    setResultVariable( other->resultVariable() );
+    setPorosityModel( other->porosityModel() );
+    setResultType( other->resultType() );
+    setFlowSolution( other->m_flowSolution() );
+    setSelectedInjectorTracers( other->m_selectedInjectorTracers() );
+    setSelectedProducerTracers( other->m_selectedProducerTracers() );
+    setSelectedSouringTracers( other->m_selectedSouringTracers() );
     m_flowTracerSelectionMode = other->m_flowTracerSelectionMode();
     m_phaseSelection          = other->m_phaseSelection;
 
@@ -249,8 +249,7 @@ void RimEclipseResultDefinition::fieldChangedByUi( const caf::PdmFieldHandle* ch
         // If the user are seeing the list with the actually selected result,
         // select that result in the list. Otherwise select nothing.
 
-        QStringList varList =
-            RimEclipseResultDefinitionTools::getResultNamesForResultType( m_resultTypeUiField(), this->currentGridCellResults() );
+        QStringList varList = RimEclipseResultDefinitionTools::getResultNamesForResultType( m_resultTypeUiField(), currentGridCellResults() );
 
         bool isFlowDiagFieldsRelevant = ( m_resultType() == RiaDefines::ResultCatType::FLOW_DIAGNOSTICS );
 
@@ -545,7 +544,7 @@ void RimEclipseResultDefinition::loadDataAndUpdate()
     RimEclipseCellColors* cellColors = firstAncestorOrThisOfType<RimEclipseCellColors>();
     if ( cellColors )
     {
-        this->updateLegendCategorySettings();
+        updateLegendCategorySettings();
 
         if ( view )
         {
@@ -633,7 +632,7 @@ QList<caf::PdmOptionItemInfo> RimEclipseResultDefinition::calculateValueOptions(
 #ifdef USE_HDF5
         if ( m_eclipseCase.notNull() )
         {
-            RigCaseCellResultsData* cellResultsData = m_eclipseCase->results( this->porosityModel() );
+            RigCaseCellResultsData* cellResultsData = m_eclipseCase->results( porosityModel() );
 
             if ( cellResultsData && cellResultsData->hasFlowDiagUsableFluxes() )
             {
@@ -761,7 +760,7 @@ QList<caf::PdmOptionItemInfo> RimEclipseResultDefinition::calculateValueOptions(
         if ( fieldNeedingOptions == &m_resultVariableUiField )
         {
             options = calcOptionsForVariableUiFieldStandard( m_resultTypeUiField(),
-                                                             this->currentGridCellResults(),
+                                                             currentGridCellResults(),
                                                              showDerivedResultsFirstInVariableUiField(),
                                                              addPerCellFaceOptionsForVariableUiField(),
                                                              m_ternaryEnabled );
@@ -825,7 +824,7 @@ RigEclipseResultAddress RimEclipseResultDefinition::eclipseResultAddress() const
     if ( !isChecked() ) return RigEclipseResultAddress();
     if ( isFlowDiagOrInjectionFlooding() ) return RigEclipseResultAddress();
 
-    const RigCaseCellResultsData* gridCellResults = this->currentGridCellResults();
+    const RigCaseCellResultsData* gridCellResults = currentGridCellResults();
     if ( gridCellResults )
     {
         int timelapseTimeStep = RigEclipseResultAddress::noTimeLapseValue();
@@ -856,7 +855,7 @@ void RimEclipseResultDefinition::setFromEclipseResultAddress( const RigEclipseRe
 {
     RigEclipseResultAddress canonizedAddress = address;
 
-    const RigCaseCellResultsData* gridCellResults = this->currentGridCellResults();
+    const RigCaseCellResultsData* gridCellResults = currentGridCellResults();
     if ( gridCellResults )
     {
         auto rinfo = gridCellResults->resultInfo( address );
@@ -880,7 +879,7 @@ void RimEclipseResultDefinition::setFromEclipseResultAddress( const RigEclipseRe
         }
     }
 
-    this->updateUiFieldsFromActiveResult();
+    updateUiFieldsFromActiveResult();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -1017,7 +1016,7 @@ QString RimEclipseResultDefinition::additionalResultText() const
     if ( isDeltaTimeStepActive() )
     {
         std::vector<QDateTime>        stepDates;
-        const RigCaseCellResultsData* gridCellResults = this->currentGridCellResults();
+        const RigCaseCellResultsData* gridCellResults = currentGridCellResults();
         if ( gridCellResults )
         {
             stepDates = gridCellResults->timeStepDates();
@@ -1101,12 +1100,12 @@ void RimEclipseResultDefinition::loadResult()
         }
     }
 
-    RigCaseCellResultsData* gridCellResults = this->currentGridCellResults();
+    RigCaseCellResultsData* gridCellResults = currentGridCellResults();
     if ( gridCellResults )
     {
         if ( isDeltaTimeStepActive() || isDeltaCaseActive() || isDivideByCellFaceAreaActive() )
         {
-            gridCellResults->createResultEntry( this->eclipseResultAddress(), false );
+            gridCellResults->createResultEntry( eclipseResultAddress(), false );
         }
 
         QString           resultName                    = m_resultVariable();
@@ -1122,7 +1121,7 @@ void RimEclipseResultDefinition::loadResult()
             }
         }
 
-        gridCellResults->ensureKnownResultLoaded( this->eclipseResultAddress() );
+        gridCellResults->ensureKnownResultLoaded( eclipseResultAddress() );
     }
 }
 
@@ -1134,8 +1133,8 @@ bool RimEclipseResultDefinition::hasStaticResult() const
 {
     if ( isFlowDiagOrInjectionFlooding() ) return false;
 
-    const RigCaseCellResultsData* gridCellResults       = this->currentGridCellResults();
-    RigEclipseResultAddress       gridScalarResultIndex = this->eclipseResultAddress();
+    const RigCaseCellResultsData* gridCellResults       = currentGridCellResults();
+    RigEclipseResultAddress       gridScalarResultIndex = eclipseResultAddress();
 
     return hasResult() && gridCellResults->timeStepCount( gridScalarResultIndex ) == 1;
 }
@@ -1149,11 +1148,11 @@ bool RimEclipseResultDefinition::hasResult() const
     {
         if ( m_flowSolution() && !m_resultVariable().isEmpty() ) return true;
     }
-    else if ( this->currentGridCellResults() )
+    else if ( currentGridCellResults() )
     {
-        const RigCaseCellResultsData* gridCellResults = this->currentGridCellResults();
+        const RigCaseCellResultsData* gridCellResults = currentGridCellResults();
 
-        return gridCellResults->hasResultEntry( this->eclipseResultAddress() );
+        return gridCellResults->hasResultEntry( eclipseResultAddress() );
     }
 
     return false;
@@ -1184,10 +1183,10 @@ bool RimEclipseResultDefinition::hasDynamicResult() const
             return true;
         }
 
-        if ( this->currentGridCellResults() )
+        if ( currentGridCellResults() )
         {
-            const RigCaseCellResultsData* gridCellResults       = this->currentGridCellResults();
-            RigEclipseResultAddress       gridScalarResultIndex = this->eclipseResultAddress();
+            const RigCaseCellResultsData* gridCellResults       = currentGridCellResults();
+            RigEclipseResultAddress       gridScalarResultIndex = eclipseResultAddress();
             if ( gridCellResults->timeStepCount( gridScalarResultIndex ) > 1 )
             {
                 return true;
@@ -1226,7 +1225,7 @@ void RimEclipseResultDefinition::initAfterRead()
     m_flowSolutionUiField            = m_flowSolution();
     m_selectedInjectorTracersUiField = m_selectedInjectorTracers;
 
-    this->updateUiIconFromToggleField();
+    updateUiIconFromToggleField();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -1308,8 +1307,8 @@ RimFlowDiagSolution* RimEclipseResultDefinition::flowDiagSolution() const
 //--------------------------------------------------------------------------------------------------
 void RimEclipseResultDefinition::setFlowSolution( RimFlowDiagSolution* flowSol )
 {
-    this->m_flowSolution        = flowSol;
-    this->m_flowSolutionUiField = flowSol;
+    m_flowSolution        = flowSol;
+    m_flowSolutionUiField = flowSol;
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -1353,8 +1352,8 @@ void RimEclipseResultDefinition::setSelectedTracers( const std::vector<QString>&
 //--------------------------------------------------------------------------------------------------
 void RimEclipseResultDefinition::setSelectedInjectorTracers( const std::vector<QString>& selectedTracers )
 {
-    this->m_selectedInjectorTracers        = selectedTracers;
-    this->m_selectedInjectorTracersUiField = selectedTracers;
+    m_selectedInjectorTracers        = selectedTracers;
+    m_selectedInjectorTracersUiField = selectedTracers;
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -1362,8 +1361,8 @@ void RimEclipseResultDefinition::setSelectedInjectorTracers( const std::vector<Q
 //--------------------------------------------------------------------------------------------------
 void RimEclipseResultDefinition::setSelectedProducerTracers( const std::vector<QString>& selectedTracers )
 {
-    this->m_selectedProducerTracers        = selectedTracers;
-    this->m_selectedProducerTracersUiField = selectedTracers;
+    m_selectedProducerTracers        = selectedTracers;
+    m_selectedProducerTracersUiField = selectedTracers;
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -1371,8 +1370,8 @@ void RimEclipseResultDefinition::setSelectedProducerTracers( const std::vector<Q
 //--------------------------------------------------------------------------------------------------
 void RimEclipseResultDefinition::setSelectedSouringTracers( const std::vector<QString>& selectedTracers )
 {
-    this->m_selectedSouringTracers        = selectedTracers;
-    this->m_selectedSouringTracersUiField = selectedTracers;
+    m_selectedSouringTracers        = selectedTracers;
+    m_selectedSouringTracersUiField = selectedTracers;
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -1433,19 +1432,17 @@ bool RimEclipseResultDefinition::hasCategoryResult() const
         }
     }
 
-    if ( this->m_resultType() == RiaDefines::ResultCatType::FORMATION_NAMES && m_eclipseCase && m_eclipseCase->eclipseCaseData() &&
+    if ( m_resultType() == RiaDefines::ResultCatType::FORMATION_NAMES && m_eclipseCase && m_eclipseCase->eclipseCaseData() &&
          !m_eclipseCase->eclipseCaseData()->formationNames().empty() )
         return true;
 
-    if ( this->m_resultType() == RiaDefines::ResultCatType::DYNAMIC_NATIVE &&
-         this->resultVariable() == RiaResultNames::completionTypeResultName() )
+    if ( m_resultType() == RiaDefines::ResultCatType::DYNAMIC_NATIVE && resultVariable() == RiaResultNames::completionTypeResultName() )
         return true;
 
-    if ( this->m_resultType() == RiaDefines::ResultCatType::FLOW_DIAGNOSTICS && m_resultVariable() == RIG_FLD_MAX_FRACTION_TRACER_RESNAME )
+    if ( m_resultType() == RiaDefines::ResultCatType::FLOW_DIAGNOSTICS && m_resultVariable() == RIG_FLD_MAX_FRACTION_TRACER_RESNAME )
         return true;
 
-    if ( this->resultVariable() == RiaResultNames::formationAllanResultName() ||
-         this->resultVariable() == RiaResultNames::formationBinaryAllanResultName() )
+    if ( resultVariable() == RiaResultNames::formationAllanResultName() || resultVariable() == RiaResultNames::formationBinaryAllanResultName() )
     {
         return true;
     }
@@ -1458,8 +1455,7 @@ bool RimEclipseResultDefinition::hasCategoryResult() const
 //--------------------------------------------------------------------------------------------------
 bool RimEclipseResultDefinition::isFlowDiagOrInjectionFlooding() const
 {
-    return this->m_resultType() == RiaDefines::ResultCatType::FLOW_DIAGNOSTICS ||
-           this->m_resultType() == RiaDefines::ResultCatType::INJECTION_FLOODING;
+    return m_resultType() == RiaDefines::ResultCatType::FLOW_DIAGNOSTICS || m_resultType() == RiaDefines::ResultCatType::INJECTION_FLOODING;
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -1535,7 +1531,7 @@ void RimEclipseResultDefinition::defineUiOrdering( QString uiConfigName, caf::Pd
 
         if ( eclView )
         {
-            if ( eclView->cellResult() == this && this->hasCategoryResult() ) showOnlyVisibleCategoriesOption = true;
+            if ( eclView->cellResult() == this && hasCategoryResult() ) showOnlyVisibleCategoriesOption = true;
         }
 
         if ( m_resultTypeUiField() == RiaDefines::ResultCatType::FLOW_DIAGNOSTICS &&
@@ -1600,7 +1596,7 @@ void RimEclipseResultDefinition::assignFlowSolutionFromCase()
     {
         defaultFlowDiagSolution = eclCase->defaultFlowDiagSolution();
     }
-    this->setFlowSolution( defaultFlowDiagSolution );
+    setFlowSolution( defaultFlowDiagSolution );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -1678,9 +1674,9 @@ void RimEclipseResultDefinition::updateRangesForExplicitLegends( RimRegularLegen
                                                                  int                     currentTimeStep )
 
 {
-    if ( this->hasResult() )
+    if ( hasResult() )
     {
-        if ( this->isFlowDiagOrInjectionFlooding() )
+        if ( isFlowDiagOrInjectionFlooding() )
         {
             if ( currentTimeStep >= 0 )
             {
@@ -1704,15 +1700,15 @@ void RimEclipseResultDefinition::updateRangesForExplicitLegends( RimRegularLegen
 //--------------------------------------------------------------------------------------------------
 void RimEclipseResultDefinition::updateLegendTitle( RimRegularLegendConfig* legendConfig, const QString& legendHeading )
 {
-    QString title = legendHeading + this->resultVariableUiName();
-    if ( !this->additionalResultTextShort().isEmpty() )
+    QString title = legendHeading + resultVariableUiName();
+    if ( !additionalResultTextShort().isEmpty() )
     {
         title += additionalResultTextShort();
     }
 
-    if ( this->hasDualPorFractureResult() )
+    if ( hasDualPorFractureResult() )
     {
-        QString porosityModelText = caf::AppEnum<RiaDefines::PorosityModelType>::uiText( this->porosityModel() );
+        QString porosityModelText = caf::AppEnum<RiaDefines::PorosityModelType>::uiText( porosityModel() );
 
         title += QString( "\nDual Por : %1" ).arg( porosityModelText );
     }

ApplicationLibCode/ProjectDataModel/RimEclipseStatisticsCase.cpp

@@ -135,7 +135,7 @@ RimEclipseStatisticsCase::~RimEclipseStatisticsCase()
 void RimEclipseStatisticsCase::setMainGrid( RigMainGrid* mainGrid )
 {
     CVF_ASSERT( mainGrid );
-    CVF_ASSERT( this->eclipseCaseData() );
+    CVF_ASSERT( eclipseCaseData() );
 
     eclipseCaseData()->setMainGrid( mainGrid );
 }
@@ -145,7 +145,7 @@ void RimEclipseStatisticsCase::setMainGrid( RigMainGrid* mainGrid )
 //--------------------------------------------------------------------------------------------------
 bool RimEclipseStatisticsCase::openEclipseGridFile()
 {
-    if ( this->eclipseCaseData() ) return true;
+    if ( eclipseCaseData() ) return true;
 
     cvf::ref<RigEclipseCaseData> eclipseCase = new RigEclipseCaseData( this );
 
@@ -163,13 +163,13 @@ bool RimEclipseStatisticsCase::openEclipseGridFile()
     eclipseCase->setActiveCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL,
                                     gridCaseGroup->unionOfActiveCells( RiaDefines::PorosityModelType::FRACTURE_MODEL ) );
 
-    this->setReservoirData( eclipseCase.p() );
+    setReservoirData( eclipseCase.p() );
 
     loadSimulationWellDataFromSourceCase();
 
     if ( m_populateSelectionAfterLoadingGrid )
     {
-        this->populateResultSelection();
+        populateResultSelection();
 
         m_populateSelectionAfterLoadingGrid = false;
     }
@@ -191,7 +191,7 @@ void RimEclipseStatisticsCase::reloadEclipseGridFile()
 //--------------------------------------------------------------------------------------------------
 RimCaseCollection* RimEclipseStatisticsCase::parentStatisticsCaseCollection() const
 {
-    return dynamic_cast<RimCaseCollection*>( this->parentField()->ownerObject() );
+    return dynamic_cast<RimCaseCollection*>( parentField()->ownerObject() );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -245,7 +245,7 @@ void RimEclipseStatisticsCase::setSourceProperties( RiaDefines::ResultCatType pr
 //--------------------------------------------------------------------------------------------------
 void RimEclipseStatisticsCase::computeStatistics()
 {
-    if ( this->eclipseCaseData() == nullptr )
+    if ( eclipseCaseData() == nullptr )
     {
         openEclipseGridFile();
     }
@@ -606,13 +606,13 @@ void RimEclipseStatisticsCase::loadSimulationWellDataFromSourceCase()
         {
             const cvf::Collection<RigSimWellData>& sourceCaseSimWellData = sourceResultCase->eclipseCaseData()->wellResults();
 
-            this->eclipseCaseData()->setSimWellData( sourceCaseSimWellData );
+            eclipseCaseData()->setSimWellData( sourceCaseSimWellData );
         }
     }
     else
     {
         cvf::Collection<RigSimWellData> sourceCaseWellResults;
-        this->eclipseCaseData()->setSimWellData( sourceCaseWellResults );
+        eclipseCaseData()->setSimWellData( sourceCaseWellResults );
     }
 }
 
@@ -774,7 +774,7 @@ void RimEclipseStatisticsCase::updateConnectedEditorsAndReservoirViews()
         }
     }
 
-    this->updateConnectedEditors();
+    updateConnectedEditors();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/RimEclipseStatisticsCaseCollection.cpp

@@ -50,6 +50,6 @@ RimEclipseStatisticsCaseCollection::~RimEclipseStatisticsCaseCollection()
 //--------------------------------------------------------------------------------------------------
 RimIdenticalGridCaseGroup* RimEclipseStatisticsCaseCollection::parentCaseGroup()
 {
-    RimIdenticalGridCaseGroup* parentObject = dynamic_cast<RimIdenticalGridCaseGroup*>( this->parentField()->ownerObject() );
+    RimIdenticalGridCaseGroup* parentObject = dynamic_cast<RimIdenticalGridCaseGroup*>( parentField()->ownerObject() );
     return parentObject;
 }

ApplicationLibCode/ProjectDataModel/RimEclipseView.cpp

@@ -193,12 +193,12 @@ RimEclipseView::RimEclipseView()
     m_cellResultData.registerGetMethod( this, &RimEclipseView::currentCellResultData );
     m_cellResultData.registerSetMethod( this, &RimEclipseView::setCurrentCellResultData );
 
-    this->cellResult()->setReservoirView( this );
-    this->cellEdgeResult()->setReservoirView( this );
-    this->cellEdgeResult()->legendConfig()->setColorLegend(
+    cellResult()->setReservoirView( this );
+    cellEdgeResult()->setReservoirView( this );
+    cellEdgeResult()->legendConfig()->setColorLegend(
         RimRegularLegendConfig::mapToColorLegend( RimRegularLegendConfig::ColorRangesType::PINK_WHITE ) );
 
-    this->faultResultSettings()->setReservoirView( this );
+    faultResultSettings()->setReservoirView( this );
 
     m_reservoirGridPartManager = new RivReservoirViewPartMgr( this );
     m_simWellsPartManager      = new RivReservoirSimWellsPartMgr( this );
@@ -219,7 +219,7 @@ RimEclipseView::RimEclipseView()
 
     setDeletable( true );
 
-    this->updateAnimations.connect( this, &RimEclipseView::onAnimationsUpdate );
+    updateAnimations.connect( this, &RimEclipseView::onAnimationsUpdate );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -227,10 +227,10 @@ RimEclipseView::RimEclipseView()
 //--------------------------------------------------------------------------------------------------
 RimEclipseView::~RimEclipseView()
 {
-    delete this->faultResultSettings();
-    delete this->cellResult();
-    delete this->cellEdgeResult();
-    delete this->elementVectorResult();
+    delete faultResultSettings();
+    delete cellResult();
+    delete cellEdgeResult();
+    delete elementVectorResult();
 
     delete m_propertyFilterCollection;
     delete wellCollection();
@@ -319,11 +319,11 @@ RimVirtualPerforationResults* RimEclipseView::virtualPerforationResult() const
 //--------------------------------------------------------------------------------------------------
 void RimEclipseView::onClampCurrentTimestep()
 {
-    if ( this->currentGridCellResults() )
+    if ( currentGridCellResults() )
     {
-        if ( m_currentTimeStep() >= static_cast<int>( this->currentGridCellResults()->maxTimeStepCount() ) )
+        if ( m_currentTimeStep() >= static_cast<int>( currentGridCellResults()->maxTimeStepCount() ) )
         {
-            m_currentTimeStep = static_cast<int>( this->currentGridCellResults()->maxTimeStepCount() ) - 1;
+            m_currentTimeStep = static_cast<int>( currentGridCellResults()->maxTimeStepCount() ) - 1;
         }
     }
 
@@ -335,9 +335,9 @@ void RimEclipseView::onClampCurrentTimestep()
 //--------------------------------------------------------------------------------------------------
 size_t RimEclipseView::onTimeStepCountRequested()
 {
-    if ( this->currentGridCellResults() )
+    if ( currentGridCellResults() )
     {
-        return this->currentGridCellResults()->maxTimeStepCount();
+        return currentGridCellResults()->maxTimeStepCount();
     }
 
     return 0;
@@ -371,30 +371,30 @@ void RimEclipseView::fieldChangedByUi( const caf::PdmFieldHandle* changedField,
 
     if ( changedField == &m_showInvalidCells )
     {
-        this->scheduleGeometryRegen( INACTIVE );
-        this->scheduleGeometryRegen( RANGE_FILTERED_INACTIVE );
+        scheduleGeometryRegen( INACTIVE );
+        scheduleGeometryRegen( RANGE_FILTERED_INACTIVE );
 
         scheduleCreateDisplayModelAndRedraw();
     }
     else if ( changedField == &m_showInactiveCells )
     {
-        this->updateGridBoxData();
+        updateGridBoxData();
 
-        this->scheduleGeometryRegen( INACTIVE );
-        this->scheduleGeometryRegen( RANGE_FILTERED_INACTIVE );
+        scheduleGeometryRegen( INACTIVE );
+        scheduleGeometryRegen( RANGE_FILTERED_INACTIVE );
 
         scheduleCreateDisplayModelAndRedraw();
     }
     else if ( changedField == &m_cellFilterCollection )
     {
-        this->scheduleGeometryRegen( RANGE_FILTERED );
-        this->scheduleGeometryRegen( RANGE_FILTERED_INACTIVE );
+        scheduleGeometryRegen( RANGE_FILTERED );
+        scheduleGeometryRegen( RANGE_FILTERED_INACTIVE );
 
         scheduleCreateDisplayModelAndRedraw();
     }
     else if ( changedField == &m_propertyFilterCollection )
     {
-        this->scheduleGeometryRegen( PROPERTY_FILTERED );
+        scheduleGeometryRegen( PROPERTY_FILTERED );
 
         scheduleCreateDisplayModelAndRedraw();
     }
@@ -414,8 +414,8 @@ void RimEclipseView::onUpdateScaleTransform()
     cvf::Mat4d scale = cvf::Mat4d::IDENTITY;
     scale( 2, 2 )    = scaleZ();
 
-    this->scaleTransform()->setLocalTransform( scale );
-    m_simWellsPartManager->setScaleTransform( this->scaleTransform() );
+    scaleTransform()->setLocalTransform( scale );
+    m_simWellsPartManager->setScaleTransform( scaleTransform() );
 
     if ( nativeOrOverrideViewer() ) nativeOrOverrideViewer()->updateCachedValuesInScene();
 }
@@ -741,14 +741,14 @@ void RimEclipseView::onUpdateDisplayModelForCurrentTimeStep()
 //--------------------------------------------------------------------------------------------------
 void RimEclipseView::updateVisibleGeometries()
 {
-    if ( this->viewController() && this->viewController()->isVisibleCellsOveridden() ) return;
+    if ( viewController() && viewController()->isVisibleCellsOveridden() ) return;
 
-    if ( this->eclipsePropertyFilterCollection()->hasActiveFilters() )
+    if ( eclipsePropertyFilterCollection()->hasActiveFilters() )
     {
         cvf::ref<cvf::ModelBasicList> frameParts = new cvf::ModelBasicList;
         frameParts->setName( "GridModel" );
 
-        std::vector<size_t> gridIndices = this->indicesToVisibleGrids();
+        std::vector<size_t> gridIndices = indicesToVisibleGrids();
 
         if ( isGridVisualizationMode() )
         {
@@ -797,15 +797,15 @@ void RimEclipseView::updateVisibleGeometries()
         }
 
         // Set the transparency on all the Wellcell parts before setting the result color
-        float opacity = static_cast<float>( 1 - std::clamp( this->wellCollection()->wellCellTransparencyLevel(), 0.0, 1.0 ) );
+        float opacity = static_cast<float>( 1 - std::clamp( wellCollection()->wellCellTransparencyLevel(), 0.0, 1.0 ) );
         m_reservoirGridPartManager->updateCellColor( PROPERTY_FILTERED_WELL_CELLS,
                                                      m_currentTimeStep,
                                                      cvf::Color4f( cvf::Color3f( cvf::Color3::WHITE ), opacity ) );
 
-        if ( this->showInactiveCells() )
+        if ( showInactiveCells() )
         {
-            if ( this->cellFilterCollection()->hasActiveFilters() ) // Wells not considered, because we do not have a
-                                                                    // INACTIVE_WELL_CELLS group yet.
+            if ( cellFilterCollection()->hasActiveFilters() ) // Wells not considered, because we do not have a
+                                                              // INACTIVE_WELL_CELLS group yet.
             {
                 m_reservoirGridPartManager->appendStaticGeometryPartsToModel( frameParts.p(), RANGE_FILTERED_INACTIVE, gridIndices );
 
@@ -845,28 +845,28 @@ void RimEclipseView::updateVisibleCellColors()
 {
     std::vector<RivCellSetEnum> geometriesToRecolor;
 
-    if ( this->viewController() && this->viewController()->isVisibleCellsOveridden() )
+    if ( viewController() && viewController()->isVisibleCellsOveridden() )
     {
         geometriesToRecolor.push_back( OVERRIDDEN_CELL_VISIBILITY );
     }
-    else if ( this->eclipsePropertyFilterCollection()->hasActiveFilters() )
+    else if ( eclipsePropertyFilterCollection()->hasActiveFilters() )
     {
         geometriesToRecolor.push_back( PROPERTY_FILTERED );
         geometriesToRecolor.push_back( PROPERTY_FILTERED_WELL_CELLS );
     }
-    else if ( this->cellFilterCollection()->hasActiveFilters() && this->wellCollection()->hasVisibleWellCells() )
+    else if ( cellFilterCollection()->hasActiveFilters() && wellCollection()->hasVisibleWellCells() )
     {
         geometriesToRecolor.push_back( RANGE_FILTERED );
         geometriesToRecolor.push_back( RANGE_FILTERED_WELL_CELLS );
         geometriesToRecolor.push_back( VISIBLE_WELL_CELLS_OUTSIDE_RANGE_FILTER );
         geometriesToRecolor.push_back( VISIBLE_WELL_FENCE_CELLS_OUTSIDE_RANGE_FILTER );
     }
-    else if ( !this->cellFilterCollection()->hasActiveFilters() && this->wellCollection()->hasVisibleWellCells() )
+    else if ( !cellFilterCollection()->hasActiveFilters() && wellCollection()->hasVisibleWellCells() )
     {
         geometriesToRecolor.push_back( VISIBLE_WELL_CELLS );
         geometriesToRecolor.push_back( VISIBLE_WELL_FENCE_CELLS );
     }
-    else if ( this->cellFilterCollection()->hasActiveFilters() && !this->wellCollection()->hasVisibleWellCells() )
+    else if ( cellFilterCollection()->hasActiveFilters() && !wellCollection()->hasVisibleWellCells() )
     {
         geometriesToRecolor.push_back( RANGE_FILTERED );
         geometriesToRecolor.push_back( RANGE_FILTERED_WELL_CELLS );
@@ -879,26 +879,23 @@ void RimEclipseView::updateVisibleCellColors()
 
     for ( size_t i = 0; i < geometriesToRecolor.size(); ++i )
     {
-        if ( this->cellEdgeResult()->hasResult() )
+        if ( cellEdgeResult()->hasResult() )
         {
-            m_reservoirGridPartManager->updateCellEdgeResultColor( geometriesToRecolor[i],
-                                                                   m_currentTimeStep,
-                                                                   this->cellResult(),
-                                                                   this->cellEdgeResult() );
+            m_reservoirGridPartManager->updateCellEdgeResultColor( geometriesToRecolor[i], m_currentTimeStep, cellResult(), cellEdgeResult() );
         }
-        else if ( this->cellResult()->hasResult() || this->cellResult()->isTernarySaturationSelected() )
+        else if ( cellResult()->hasResult() || cellResult()->isTernarySaturationSelected() )
         {
-            m_reservoirGridPartManager->updateCellResultColor( geometriesToRecolor[i], m_currentTimeStep, this->cellResult() );
+            m_reservoirGridPartManager->updateCellResultColor( geometriesToRecolor[i], m_currentTimeStep, cellResult() );
         }
         else
         {
-            this->updateStaticCellColors( geometriesToRecolor[i] );
+            updateStaticCellColors( geometriesToRecolor[i] );
         }
     }
 
-    this->updateFaultColors();
+    updateFaultColors();
 
-    bool hasGeneralCellResult = this->cellResult()->hasResult() || this->cellResult()->isTernarySaturationSelected();
+    bool hasGeneralCellResult = cellResult()->hasResult() || cellResult()->isTernarySaturationSelected();
 
     m_intersectionCollection->updateCellResultColor( hasGeneralCellResult, m_currentTimeStep );
     if ( surfaceInViewCollection() ) surfaceInViewCollection()->updateCellResultColor( hasGeneralCellResult, m_currentTimeStep );
@@ -952,9 +949,9 @@ void RimEclipseView::appendWellsAndFracturesToModel()
                 cvf::ref<cvf::ModelBasicList> simWellFracturesModelBasicList = new cvf::ModelBasicList;
                 simWellFracturesModelBasicList->setName( name );
 
-                cvf::ref<caf::DisplayCoordTransform> transForm = this->displayCoordTransform();
+                cvf::ref<caf::DisplayCoordTransform> transForm = displayCoordTransform();
 
-                std::vector<RimFracture*> fractures = this->descendantsIncludingThisOfType<RimFracture>();
+                std::vector<RimFracture*> fractures = descendantsIncludingThisOfType<RimFracture>();
                 for ( RimFracture* f : fractures )
                 {
                     RimSimWellInView* simWell = f->firstAncestorOrThisOfType<RimSimWellInView>();
@@ -1037,7 +1034,7 @@ void RimEclipseView::appendStreamlinesToModel()
 //--------------------------------------------------------------------------------------------------
 void RimEclipseView::onLoadDataAndUpdate()
 {
-    this->updateSurfacesInViewTreeItems();
+    updateSurfacesInViewTreeItems();
 
     onUpdateScaleTransform();
 
@@ -1046,29 +1043,29 @@ void RimEclipseView::onLoadDataAndUpdate()
         if ( !m_eclipseCase->openReserviorCase() )
         {
             RiaLogging::warning( "Could not open the Eclipse Grid file: \n" + m_eclipseCase->gridFileName() );
-            this->setEclipseCase( nullptr );
+            setEclipseCase( nullptr );
             return;
         }
     }
 
-    CVF_ASSERT( this->cellResult() != nullptr );
-    this->cellResult()->loadResult();
+    CVF_ASSERT( cellResult() != nullptr );
+    cellResult()->loadResult();
 
-    CVF_ASSERT( this->cellEdgeResult() != nullptr );
-    this->cellEdgeResult()->loadResult();
+    CVF_ASSERT( cellEdgeResult() != nullptr );
+    cellEdgeResult()->loadResult();
 
-    this->faultResultSettings()->customFaultResult()->loadResult();
-    this->fractureColors()->loadDataAndUpdate();
+    faultResultSettings()->customFaultResult()->loadResult();
+    fractureColors()->loadDataAndUpdate();
 
     updateMdiWindowVisibility();
 
-    this->m_propertyFilterCollection()->loadAndInitializePropertyFilters();
+    m_propertyFilterCollection()->loadAndInitializePropertyFilters();
 
-    this->faultCollection()->syncronizeFaults();
+    faultCollection()->syncronizeFaults();
 
-    this->m_wellCollection->scaleWellDisks();
+    m_wellCollection->scaleWellDisks();
 
-    if ( this->m_surfaceCollection ) this->m_surfaceCollection->loadData();
+    if ( m_surfaceCollection ) m_surfaceCollection->loadData();
 
     scheduleReservoirGridGeometryRegen();
     m_simWellsPartManager->clearGeometryCache();
@@ -1087,14 +1084,14 @@ void RimEclipseView::onLoadDataAndUpdate()
         }
     }
 
-    if ( this->isVirtualConnectionFactorGeometryVisible() )
+    if ( isVirtualConnectionFactorGeometryVisible() )
     {
         m_virtualPerforationResult->loadData();
     }
 
     m_wellMeasurementCollection->syncWithChangesInWellMeasurementCollection();
 
-    this->scheduleCreateDisplayModelAndRedraw();
+    scheduleCreateDisplayModelAndRedraw();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -1112,11 +1109,11 @@ void RimEclipseView::initAfterRead()
 {
     RimGridView::initAfterRead();
 
-    this->faultResultSettings()->setReservoirView( this );
-    this->cellResult()->setReservoirView( this );
-    this->cellEdgeResult()->setReservoirView( this );
+    faultResultSettings()->setReservoirView( this );
+    cellResult()->setReservoirView( this );
+    cellEdgeResult()->setReservoirView( this );
 
-    this->updateUiIconFromToggleField();
+    updateUiIconFromToggleField();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -1161,7 +1158,7 @@ void RimEclipseView::updateStaticCellColors( RivCellSetEnum geometryType )
 //--------------------------------------------------------------------------------------------------
 cvf::Color4f RimEclipseView::colorFromCellCategory( RivCellSetEnum geometryType ) const
 {
-    float        opacity = static_cast<float>( 1 - std::clamp( this->wellCollection()->wellCellTransparencyLevel(), 0.0, 1.0 ) );
+    float        opacity = static_cast<float>( 1 - std::clamp( wellCollection()->wellCellTransparencyLevel(), 0.0, 1.0 ) );
     cvf::Color4f color( cvf::Color3::ORANGE );
 
     switch ( geometryType )
@@ -1283,9 +1280,9 @@ void RimEclipseView::scheduleGeometryRegen( RivCellSetEnum geometryType )
 {
     m_reservoirGridPartManager->scheduleGeometryRegen( geometryType );
 
-    if ( this->isMasterView() )
+    if ( isMasterView() )
     {
-        RimViewLinker* viewLinker = this->assosiatedViewLinker();
+        RimViewLinker* viewLinker = assosiatedViewLinker();
         if ( viewLinker )
         {
             viewLinker->scheduleGeometryRegenForDepViews( geometryType );
@@ -1335,7 +1332,7 @@ void RimEclipseView::onUpdateLegends()
         }
         else
         {
-            std::vector<RimLegendConfig*> legendConfs = this->legendConfigs();
+            std::vector<RimLegendConfig*> legendConfs = legendConfigs();
 
             for ( auto legendConf : legendConfs )
             {
@@ -1355,66 +1352,65 @@ void RimEclipseView::onUpdateLegends()
     RigCaseCellResultsData* results = eclipseCase->results( cellResult()->porosityModel() );
     CVF_ASSERT( results );
 
-    updateLegendRangesTextAndVisibility( this->cellResult()->legendConfig(),
-                                         this->cellResult()->ternaryLegendConfig(),
+    updateLegendRangesTextAndVisibility( cellResult()->legendConfig(),
+                                         cellResult()->ternaryLegendConfig(),
                                          QString( "Cell Results: \n" ),
-                                         this->cellResult(),
+                                         cellResult(),
                                          m_currentTimeStep );
 
-    if ( this->faultResultSettings()->showCustomFaultResult() && this->faultResultSettings()->hasValidCustomResult() )
+    if ( faultResultSettings()->showCustomFaultResult() && faultResultSettings()->hasValidCustomResult() )
     {
         updateLegendRangesTextAndVisibility( currentFaultResultColors()->legendConfig(),
                                              currentFaultResultColors()->ternaryLegendConfig(),
                                              QString( "Fault Results: \n" ),
-                                             this->currentFaultResultColors(),
+                                             currentFaultResultColors(),
                                              m_currentTimeStep );
     }
 
-    for ( RimIntersectionResultDefinition* sepInterResDef : this->separateIntersectionResultsCollection()->intersectionResultsDefinitions() )
+    for ( RimIntersectionResultDefinition* sepInterResDef : separateIntersectionResultsCollection()->intersectionResultsDefinitions() )
     {
         sepInterResDef->updateLegendRangesTextAndVisibility( "Intersection Results:\n", nativeOrOverrideViewer(), isUsingOverrideViewer() );
     }
 
-    for ( RimIntersectionResultDefinition* sepInterResDef : this->separateSurfaceResultsCollection()->intersectionResultsDefinitions() )
+    for ( RimIntersectionResultDefinition* sepInterResDef : separateSurfaceResultsCollection()->intersectionResultsDefinitions() )
     {
         sepInterResDef->updateLegendRangesTextAndVisibility( "Surface Results:\n", nativeOrOverrideViewer(), isUsingOverrideViewer() );
     }
 
-    if ( this->cellEdgeResult()->legendConfig()->showLegend() )
+    if ( cellEdgeResult()->legendConfig()->showLegend() )
     {
-        if ( this->cellEdgeResult()->hasResult() )
+        if ( cellEdgeResult()->hasResult() )
         {
             {
                 double globalMin, globalMax;
                 double globalPosClosestToZero, globalNegClosestToZero;
-                this->cellEdgeResult()->minMaxCellEdgeValues( globalMin, globalMax );
-                this->cellEdgeResult()->posNegClosestToZero( globalPosClosestToZero, globalNegClosestToZero );
+                cellEdgeResult()->minMaxCellEdgeValues( globalMin, globalMax );
+                cellEdgeResult()->posNegClosestToZero( globalPosClosestToZero, globalNegClosestToZero );
 
-                this->cellEdgeResult()->legendConfig()->setClosestToZeroValues( globalPosClosestToZero,
-                                                                                globalNegClosestToZero,
-                                                                                globalPosClosestToZero,
-                                                                                globalNegClosestToZero );
-                this->cellEdgeResult()->legendConfig()->setAutomaticRanges( globalMin, globalMax, globalMin, globalMax );
+                cellEdgeResult()->legendConfig()->setClosestToZeroValues( globalPosClosestToZero,
+                                                                          globalNegClosestToZero,
+                                                                          globalPosClosestToZero,
+                                                                          globalNegClosestToZero );
+                cellEdgeResult()->legendConfig()->setAutomaticRanges( globalMin, globalMax, globalMin, globalMax );
             }
 
-            this->cellEdgeResult()->legendConfig()->setTitle( QString( "Edge Results: \n" ) +
-                                                              this->cellEdgeResult()->resultVariableUiShortName() );
-            nativeOrOverrideViewer()->addColorLegendToBottomLeftCorner( this->cellEdgeResult()->legendConfig()->titledOverlayFrame(),
+            cellEdgeResult()->legendConfig()->setTitle( QString( "Edge Results: \n" ) + cellEdgeResult()->resultVariableUiShortName() );
+            nativeOrOverrideViewer()->addColorLegendToBottomLeftCorner( cellEdgeResult()->legendConfig()->titledOverlayFrame(),
                                                                         isUsingOverrideViewer() );
         }
         else
         {
-            this->cellEdgeResult()->legendConfig()->setClosestToZeroValues( 0, 0, 0, 0 );
-            this->cellEdgeResult()->legendConfig()->setAutomaticRanges( cvf::UNDEFINED_DOUBLE,
-                                                                        cvf::UNDEFINED_DOUBLE,
-                                                                        cvf::UNDEFINED_DOUBLE,
-                                                                        cvf::UNDEFINED_DOUBLE );
+            cellEdgeResult()->legendConfig()->setClosestToZeroValues( 0, 0, 0, 0 );
+            cellEdgeResult()->legendConfig()->setAutomaticRanges( cvf::UNDEFINED_DOUBLE,
+                                                                  cvf::UNDEFINED_DOUBLE,
+                                                                  cvf::UNDEFINED_DOUBLE,
+                                                                  cvf::UNDEFINED_DOUBLE );
         }
     }
 
-    if ( this->elementVectorResult()->showResult() )
+    if ( elementVectorResult()->showResult() )
     {
-        this->elementVectorResult()->updateLegendRangesTextAndVisibility( nativeOrOverrideViewer(), isUsingOverrideViewer() );
+        elementVectorResult()->updateLegendRangesTextAndVisibility( nativeOrOverrideViewer(), isUsingOverrideViewer() );
     }
 
     {
@@ -1549,9 +1545,9 @@ void RimEclipseView::syncronizeWellsWithResults()
     std::vector<caf::PdmPointer<RimSimWellInView>> newWells;
 
     // Clear the possible well results data present
-    for ( size_t wIdx = 0; wIdx < this->wellCollection()->wells().size(); ++wIdx )
+    for ( size_t wIdx = 0; wIdx < wellCollection()->wells().size(); ++wIdx )
     {
-        RimSimWellInView* well = this->wellCollection()->wells()[wIdx];
+        RimSimWellInView* well = wellCollection()->wells()[wIdx];
         well->setSimWellData( nullptr, -1 );
     }
 
@@ -1561,7 +1557,7 @@ void RimEclipseView::syncronizeWellsWithResults()
 
     for ( size_t wIdx = 0; wIdx < wellResults.size(); ++wIdx )
     {
-        RimSimWellInView* well = this->wellCollection()->findWell( wellResults[wIdx]->m_wellName );
+        RimSimWellInView* well = wellCollection()->findWell( wellResults[wIdx]->m_wellName );
 
         if ( !well )
         {
@@ -1577,29 +1573,29 @@ void RimEclipseView::syncronizeWellsWithResults()
 
     // Delete all wells that does not have a result
 
-    for ( size_t wIdx = 0; wIdx < this->wellCollection()->wells().size(); ++wIdx )
+    for ( size_t wIdx = 0; wIdx < wellCollection()->wells().size(); ++wIdx )
     {
-        RimSimWellInView* well        = this->wellCollection()->wells()[wIdx];
+        RimSimWellInView* well        = wellCollection()->wells()[wIdx];
         RigSimWellData*   simWellData = well->simWellData();
         if ( simWellData == nullptr )
         {
             delete well;
         }
     }
-    this->wellCollection()->wells().clearWithoutDelete();
+    wellCollection()->wells().clearWithoutDelete();
 
     // Set the new wells into the field.
-    this->wellCollection()->wells().insert( 0, newWells );
+    wellCollection()->wells().insert( 0, newWells );
 
     // Make sure all the wells have their reservoirView ptr setup correctly
-    this->wellCollection()->setReservoirView( this );
+    wellCollection()->setReservoirView( this );
 
     // Sort wells before assigning colors, as the colors are distributed based on sorting
-    this->wellCollection()->sortWellsByName();
+    wellCollection()->sortWellsByName();
 
     if ( isAnyWellCreated )
     {
-        this->wellCollection()->assignDefaultWellColors();
+        wellCollection()->assignDefaultWellColors();
     }
 }
 
@@ -1665,14 +1661,14 @@ void RimEclipseView::calculateVisibleWellCellsIncFence( cvf::UByteArray* visible
     }
     visibleCells->setAll( false );
 
-    const RigActiveCellInfo* activeCellInfo = this->currentActiveCellInfo();
+    const RigActiveCellInfo* activeCellInfo = currentActiveCellInfo();
 
     CVF_ASSERT( activeCellInfo );
 
     // Loop over the wells and find their contribution
-    for ( size_t wIdx = 0; wIdx < this->wellCollection()->wells().size(); ++wIdx )
+    for ( size_t wIdx = 0; wIdx < wellCollection()->wells().size(); ++wIdx )
     {
-        RimSimWellInView* well = this->wellCollection()->wells()[wIdx];
+        RimSimWellInView* well = wellCollection()->wells()[wIdx];
         if ( well->isWellCellsVisible() )
         {
             RigSimWellData* simWellData = well->simWellData();
@@ -1708,17 +1704,17 @@ void RimEclipseView::calculateVisibleWellCellsIncFence( cvf::UByteArray* visible
                                 size_t  cellCountFenceDirection = 0;
                                 size_t  fIdx                    = 0;
 
-                                if ( this->wellCollection()->wellCellFenceType == RimSimWellInViewCollection::K_DIRECTION )
+                                if ( wellCollection()->wellCellFenceType == RimSimWellInViewCollection::K_DIRECTION )
                                 {
                                     cellCountFenceDirection = grid->cellCountK();
                                     pK                      = &fIdx;
                                 }
-                                else if ( this->wellCollection()->wellCellFenceType == RimSimWellInViewCollection::J_DIRECTION )
+                                else if ( wellCollection()->wellCellFenceType == RimSimWellInViewCollection::J_DIRECTION )
                                 {
                                     cellCountFenceDirection = grid->cellCountJ();
                                     pJ                      = &fIdx;
                                 }
-                                else if ( this->wellCollection()->wellCellFenceType == RimSimWellInViewCollection::I_DIRECTION )
+                                else if ( wellCollection()->wellCellFenceType == RimSimWellInViewCollection::I_DIRECTION )
                                 {
                                     cellCountFenceDirection = grid->cellCountI();
                                     pI                      = &fIdx;
@@ -1804,7 +1800,7 @@ void RimEclipseView::calculateCompletionTypeAndRedrawIfRequired()
 
     if ( isDependingOnCompletionType )
     {
-        this->loadDataAndUpdate();
+        loadDataAndUpdate();
 
         std::vector<RimExtrudedCurveIntersection*> intersections = m_intersectionCollection->intersections();
         for ( auto intersection : intersections )
@@ -1849,7 +1845,7 @@ bool RimEclipseView::isMainGridVisible() const
 
     if ( !isMainGridVisible ) return false;
 
-    return this->m_gridCollection->isActive();
+    return m_gridCollection->isActive();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -1958,9 +1954,9 @@ void RimEclipseView::updateFaultColors()
 
     for ( RivCellSetEnum cellSetType : faultGeometriesToRecolor )
     {
-        if ( this->cellEdgeResult()->hasResult() )
+        if ( cellEdgeResult()->hasResult() )
         {
-            m_reservoirGridPartManager->updateFaultCellEdgeResultColor( cellSetType, m_currentTimeStep, faultResultColors, this->cellEdgeResult() );
+            m_reservoirGridPartManager->updateFaultCellEdgeResultColor( cellSetType, m_currentTimeStep, faultResultColors, cellEdgeResult() );
         }
         else
         {
@@ -1974,36 +1970,36 @@ void RimEclipseView::updateFaultColors()
 //--------------------------------------------------------------------------------------------------
 bool RimEclipseView::isTimeStepDependentDataVisible() const
 {
-    if ( this->cellResult()->hasDynamicResult() ) return true;
+    if ( cellResult()->hasDynamicResult() ) return true;
 
-    if ( this->eclipsePropertyFilterCollection()->hasActiveDynamicFilters() ) return true;
+    if ( eclipsePropertyFilterCollection()->hasActiveDynamicFilters() ) return true;
 
-    if ( this->wellCollection()->hasVisibleWellPipes() ) return true;
+    if ( wellCollection()->hasVisibleWellPipes() ) return true;
 
-    if ( this->cellResult()->isTernarySaturationSelected() ) return true;
+    if ( cellResult()->isTernarySaturationSelected() ) return true;
 
-    if ( this->faultResultSettings()->showCustomFaultResult() )
+    if ( faultResultSettings()->showCustomFaultResult() )
     {
-        if ( this->faultResultSettings()->customFaultResult()->hasDynamicResult() ) return true;
+        if ( faultResultSettings()->customFaultResult()->hasDynamicResult() ) return true;
 
-        if ( this->faultResultSettings()->customFaultResult()->isTernarySaturationSelected() ) return true;
+        if ( faultResultSettings()->customFaultResult()->isTernarySaturationSelected() ) return true;
     }
 
-    if ( this->intersectionCollection()->hasAnyActiveSeparateResults() )
+    if ( intersectionCollection()->hasAnyActiveSeparateResults() )
     {
         return true;
     }
 
-    if ( this->surfaceInViewCollection() && this->surfaceInViewCollection()->hasAnyActiveSeparateResults() )
+    if ( surfaceInViewCollection() && surfaceInViewCollection()->hasAnyActiveSeparateResults() )
     {
         return true;
     }
 
-    if ( this->wellPathCollection() && this->wellPathCollection()->anyWellsContainingPerforationIntervals() ) return true;
+    if ( wellPathCollection() && wellPathCollection()->anyWellsContainingPerforationIntervals() ) return true;
 
-    if ( this->hasVisibleTimeStepDependent3dWellLogCurves() ) return true;
+    if ( hasVisibleTimeStepDependent3dWellLogCurves() ) return true;
 
-    if ( this->wellPathCollection() && this->wellCollection()->isWellDisksVisible() ) return true;
+    if ( wellPathCollection() && wellCollection()->isWellDisksVisible() ) return true;
 
     return false;
 }
@@ -2013,11 +2009,11 @@ bool RimEclipseView::isTimeStepDependentDataVisible() const
 //--------------------------------------------------------------------------------------------------
 RimEclipseCellColors* RimEclipseView::currentFaultResultColors()
 {
-    RimEclipseCellColors* faultResultColors = this->cellResult();
+    RimEclipseCellColors* faultResultColors = cellResult();
 
-    if ( this->faultResultSettings()->showCustomFaultResult() )
+    if ( faultResultSettings()->showCustomFaultResult() )
     {
-        faultResultColors = this->faultResultSettings()->customFaultResult();
+        faultResultColors = faultResultSettings()->customFaultResult();
     }
 
     return faultResultColors;
@@ -2036,7 +2032,7 @@ std::vector<double> RimEclipseView::currentCellResultData() const
         int timeStep = 0;
         if ( cellResult()->hasDynamicResult() )
         {
-            timeStep = this->currentTimeStep();
+            timeStep = currentTimeStep();
         }
         resultData = currentGridCellResults()->cellScalarResults( cellResult()->eclipseResultAddress() )[timeStep];
     }
@@ -2053,7 +2049,7 @@ void RimEclipseView::setCurrentCellResultData( const std::vector<double>& values
         int timeStep = 0;
         if ( cellResult()->hasDynamicResult() )
         {
-            timeStep = this->currentTimeStep();
+            timeStep = currentTimeStep();
         }
         std::vector<double>* modResult = currentGridCellResults()->modifiableCellScalarResult( cellResult()->eclipseResultAddress(), timeStep );
         if ( modResult->size() == values.size() )
@@ -2174,8 +2170,8 @@ void RimEclipseView::setOverridePropertyFilterCollection( RimEclipsePropertyFilt
         m_propertyFilterCollection->isActive = m_overridePropertyFilterCollection->isActive;
     }
     uiCapability()->updateConnectedEditors();
-    this->scheduleGeometryRegen( PROPERTY_FILTERED );
-    this->scheduleCreateDisplayModelAndRedraw();
+    scheduleGeometryRegen( PROPERTY_FILTERED );
+    scheduleCreateDisplayModelAndRedraw();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -2183,16 +2179,16 @@ void RimEclipseView::setOverridePropertyFilterCollection( RimEclipsePropertyFilt
 //--------------------------------------------------------------------------------------------------
 void RimEclipseView::calculateCurrentTotalCellVisibility( cvf::UByteArray* totalVisibility, int timeStep )
 {
-    size_t cellCount = this->mainGrid()->globalCellArray().size();
+    size_t cellCount = mainGrid()->globalCellArray().size();
 
     totalVisibility->resize( cellCount );
     totalVisibility->setAll( false );
 
-    std::vector<size_t> gridIndices = this->indicesToVisibleGrids();
+    std::vector<size_t> gridIndices = indicesToVisibleGrids();
 
     for ( auto gridIdx : gridIndices )
     {
-        RigGridBase* grid          = this->eclipseCase()->eclipseCaseData()->grid( gridIdx );
+        RigGridBase* grid          = eclipseCase()->eclipseCaseData()->grid( gridIdx );
         int          gridCellCount = static_cast<int>( grid->cellCount() );
 
         for ( size_t gpIdx = 0; gpIdx < m_visibleGridParts.size(); ++gpIdx )
@@ -2212,18 +2208,18 @@ void RimEclipseView::calculateCurrentTotalCellVisibility( cvf::UByteArray* total
 //--------------------------------------------------------------------------------------------------
 void RimEclipseView::calculateCellVisibility( cvf::UByteArray* visibility, std::vector<RivCellSetEnum> geomTypes, int timeStep )
 {
-    size_t cellCount = this->mainGrid()->globalCellArray().size();
+    size_t cellCount = mainGrid()->globalCellArray().size();
 
     visibility->resize( cellCount );
     visibility->setAll( false );
 
-    std::vector<size_t> gridIndices = this->indicesToVisibleGrids();
+    std::vector<size_t> gridIndices = indicesToVisibleGrids();
 
-    const auto gridCount = this->eclipseCase()->eclipseCaseData()->gridCount();
+    const auto gridCount = eclipseCase()->eclipseCaseData()->gridCount();
 
     for ( size_t gridIdx = 0; gridIdx < gridCount; gridIdx++ )
     {
-        RigGridBase* grid          = this->eclipseCase()->eclipseCaseData()->grid( gridIdx );
+        RigGridBase* grid          = eclipseCase()->eclipseCaseData()->grid( gridIdx );
         int          gridCellCount = static_cast<int>( grid->cellCount() );
 
         for ( auto vizType : geomTypes )
@@ -2253,13 +2249,13 @@ std::vector<RimLegendConfig*> RimEclipseView::legendConfigs() const
     absLegends.push_back( fractureColors()->activeLegend() );
     absLegends.push_back( virtualPerforationResult()->legendConfig() );
 
-    for ( RimIntersectionResultDefinition* sepInterResDef : this->separateIntersectionResultsCollection()->intersectionResultsDefinitions() )
+    for ( RimIntersectionResultDefinition* sepInterResDef : separateIntersectionResultsCollection()->intersectionResultsDefinitions() )
     {
         absLegends.push_back( sepInterResDef->regularLegendConfig() );
         absLegends.push_back( sepInterResDef->ternaryLegendConfig() );
     }
 
-    for ( RimIntersectionResultDefinition* sepInterResDef : this->separateSurfaceResultsCollection()->intersectionResultsDefinitions() )
+    for ( RimIntersectionResultDefinition* sepInterResDef : separateSurfaceResultsCollection()->intersectionResultsDefinitions() )
     {
         absLegends.push_back( sepInterResDef->regularLegendConfig() );
         absLegends.push_back( sepInterResDef->ternaryLegendConfig() );

ApplicationLibCode/ProjectDataModel/RimFormationNames.cpp

@@ -159,5 +159,5 @@ QString RimFormationNames::layerZoneTableFileName()
 //--------------------------------------------------------------------------------------------------
 void RimFormationNames::updateUiTreeName()
 {
-    this->uiCapability()->setUiName( fileNameWoPath() );
+    uiCapability()->setUiName( fileNameWoPath() );
 }

ApplicationLibCode/ProjectDataModel/RimGridCollection.cpp

@@ -360,7 +360,7 @@ caf::PdmFieldHandle* RimGridCollection::objectToggleField()
 //--------------------------------------------------------------------------------------------------
 void RimGridCollection::syncFromMainEclipseGrid()
 {
-    auto mainGrid = this->mainEclipseGrid();
+    auto mainGrid = mainEclipseGrid();
     if ( mainGrid )
     {
         m_mainGrid->setName( "Main Grid" );
@@ -490,7 +490,7 @@ const RigMainGrid* RimGridCollection::mainEclipseGrid() const
 //--------------------------------------------------------------------------------------------------
 bool RimGridCollection::hasPersistentLgrs() const
 {
-    auto mainGrid = this->mainEclipseGrid();
+    auto mainGrid = mainEclipseGrid();
     if ( !mainGrid ) return false;
 
     for ( size_t i = 1; i < mainGrid->gridCount(); i++ )
@@ -506,7 +506,7 @@ bool RimGridCollection::hasPersistentLgrs() const
 //--------------------------------------------------------------------------------------------------
 bool RimGridCollection::hasTemporaryLgrs() const
 {
-    auto mainGrid = this->mainEclipseGrid();
+    auto mainGrid = mainEclipseGrid();
     if ( !mainGrid ) return false;
 
     for ( size_t i = 1; i < mainGrid->gridCount(); i++ )

ApplicationLibCode/ProjectDataModel/RimGridTimeHistoryCurve.cpp

@@ -379,7 +379,7 @@ void RimGridTimeHistoryCurve::updateZoomInParentPlot()
 //--------------------------------------------------------------------------------------------------
 void RimGridTimeHistoryCurve::onLoadDataAndUpdate( bool updateParentPlot )
 {
-    this->RimPlotCurve::updateCurvePresentation( updateParentPlot );
+    RimPlotCurve::updateCurvePresentation( updateParentPlot );
 
     if ( isChecked() && m_plotCurve )
     {

ApplicationLibCode/ProjectDataModel/RimGridView.cpp

@@ -142,8 +142,8 @@ cvf::ref<cvf::UByteArray> RimGridView::currentTotalCellVisibility()
     if ( m_currentReservoirCellVisibility.isNull() )
     {
         m_currentReservoirCellVisibility = new cvf::UByteArray;
-        this->calculateCurrentTotalCellVisibility( m_currentReservoirCellVisibility.p(), m_currentTimeStep() );
-        this->cellVisibilityChanged.send();
+        calculateCurrentTotalCellVisibility( m_currentReservoirCellVisibility.p(), m_currentTimeStep() );
+        cellVisibilityChanged.send();
     }
 
     return m_currentReservoirCellVisibility;
@@ -210,7 +210,7 @@ void RimGridView::cellFiltersUpdated()
 //--------------------------------------------------------------------------------------------------
 RimCellFilterCollection* RimGridView::cellFilterCollection()
 {
-    if ( this->viewController() && this->viewController()->isCellFiltersControlled() && m_overrideCellFilterCollection )
+    if ( viewController() && viewController()->isCellFiltersControlled() && m_overrideCellFilterCollection )
     {
         return m_overrideCellFilterCollection;
     }
@@ -225,7 +225,7 @@ RimCellFilterCollection* RimGridView::cellFilterCollection()
 //--------------------------------------------------------------------------------------------------
 const RimCellFilterCollection* RimGridView::cellFilterCollection() const
 {
-    if ( this->viewController() && this->viewController()->isCellFiltersControlled() && m_overrideCellFilterCollection )
+    if ( viewController() && viewController()->isCellFiltersControlled() && m_overrideCellFilterCollection )
     {
         return m_overrideCellFilterCollection;
     }
@@ -266,10 +266,10 @@ void RimGridView::setOverrideCellFilterCollection( RimCellFilterCollection* rfc
         m_cellFilterCollection()->uiCapability()->updateConnectedEditors();
     }
 
-    this->scheduleGeometryRegen( RANGE_FILTERED );
-    this->scheduleGeometryRegen( RANGE_FILTERED_INACTIVE );
+    scheduleGeometryRegen( RANGE_FILTERED );
+    scheduleGeometryRegen( RANGE_FILTERED_INACTIVE );
 
-    this->scheduleCreateDisplayModelAndRedraw();
+    scheduleCreateDisplayModelAndRedraw();
 }
 //--------------------------------------------------------------------------------------------------
 ///
@@ -291,7 +291,7 @@ void RimGridView::replaceCellFilterCollectionWithOverride()
 
     m_cellFilterCollection = overrideRfc;
 
-    this->uiCapability()->updateConnectedEditors();
+    uiCapability()->updateConnectedEditors();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -299,7 +299,7 @@ void RimGridView::replaceCellFilterCollectionWithOverride()
 //--------------------------------------------------------------------------------------------------
 bool RimGridView::isGridVisualizationMode() const
 {
-    return this->m_gridCollection->isActive();
+    return m_gridCollection->isActive();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -368,10 +368,10 @@ void RimGridView::onCreatePartCollectionFromSelection( cvf::Collection<cvf::Part
                 RivSingleCellPartGenerator partGen( geomSelItem->m_resultDefinition->geoMechCase(),
                                                     geomSelItem->m_gridIndex,
                                                     geomSelItem->m_cellIndex,
-                                                    this->ownerCase()->displayModelOffset() );
+                                                    ownerCase()->displayModelOffset() );
 
                 cvf::ref<cvf::Part> part = partGen.createPart( geomSelItem->m_color );
-                part->setTransform( this->scaleTransform() );
+                part->setTransform( scaleTransform() );
 
                 parts->push_back( part.p() );
             }
@@ -389,10 +389,10 @@ void RimGridView::onCreatePartCollectionFromSelection( cvf::Collection<cvf::Part
                 RivSingleCellPartGenerator partGen( eclipseSelItem->m_resultDefinition->eclipseCase()->eclipseCaseData(),
                                                     eclipseSelItem->m_gridIndex,
                                                     eclipseSelItem->m_gridLocalCellIndex,
-                                                    this->ownerCase()->displayModelOffset() );
+                                                    ownerCase()->displayModelOffset() );
 
                 cvf::ref<cvf::Part> part = partGen.createPart( eclipseSelItem->m_color );
-                part->setTransform( this->scaleTransform() );
+                part->setTransform( scaleTransform() );
 
                 parts->push_back( part.p() );
             }
@@ -405,7 +405,7 @@ void RimGridView::onCreatePartCollectionFromSelection( cvf::Collection<cvf::Part
 //--------------------------------------------------------------------------------------------------
 void RimGridView::onClearReservoirCellVisibilitiesIfNecessary()
 {
-    if ( this->propertyFilterCollection() && this->propertyFilterCollection()->hasActiveDynamicFilters() )
+    if ( propertyFilterCollection() && propertyFilterCollection()->hasActiveDynamicFilters() )
     {
         m_currentReservoirCellVisibility = nullptr;
     }
@@ -495,7 +495,7 @@ void RimGridView::updateSurfacesInViewTreeItems()
         delete m_surfaceCollection;
     }
 
-    this->updateConnectedEditors();
+    updateConnectedEditors();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/RimHistogramCalculator.cpp

@@ -343,7 +343,7 @@ RigHistogramData
             }
             else if ( cellRange == StatisticsCellRangeType::VISIBLE_CELLS )
             {
-                this->updateVisCellStatsIfNeeded( geoMechView );
+                updateVisCellStatsIfNeeded( geoMechView );
 
                 if ( timeRange == StatisticsTimeRangeType::ALL_TIMESTEPS )
                 {

ApplicationLibCode/ProjectDataModel/RimIdenticalGridCaseGroup.cpp

@@ -264,7 +264,7 @@ void RimIdenticalGridCaseGroup::computeUnionOfActiveCells()
 
     if ( caseCollection->reservoirs.size() == 0 || !m_mainGrid )
     {
-        this->clearActiveCellUnions();
+        clearActiveCellUnions();
 
         return;
     }
@@ -371,7 +371,7 @@ void RimIdenticalGridCaseGroup::updateMainGridAndActiveCellsForStatisticsCases()
 
         if ( rimStaticsCase->eclipseCaseData() )
         {
-            rimStaticsCase->eclipseCaseData()->setMainGrid( this->mainGrid() );
+            rimStaticsCase->eclipseCaseData()->setMainGrid( mainGrid() );
 
             if ( i == 0 )
             {

ApplicationLibCode/ProjectDataModel/RimMdiWindowController.cpp

@@ -139,7 +139,7 @@ void RimMdiWindowController::setupBeforeSave()
 {
     if ( viewWidget() && getMainWindow() )
     {
-        this->setMdiWindowGeometry( getMainWindow()->windowGeometryForViewer( viewWidget() ) );
+        setMdiWindowGeometry( getMainWindow()->windowGeometryForViewer( viewWidget() ) );
     }
 }
 
@@ -157,7 +157,7 @@ void RimMdiWindowController::updateViewerWidget()
         {
             QMdiSubWindow* viewWindow = mainWindow->createViewWindow();
             QWidget*       viewWidget = viewPdmObject()->createViewWidget( viewWindow );
-            mainWindow->initializeViewer( viewWindow, viewWidget, this->mdiWindowGeometry() );
+            mainWindow->initializeViewer( viewWindow, viewWidget, mdiWindowGeometry() );
 
             viewPdmObject()->updateViewWidgetAfterCreation();
         }
@@ -168,7 +168,7 @@ void RimMdiWindowController::updateViewerWidget()
     {
         if ( viewWidget() )
         {
-            this->setMdiWindowGeometry( mainWindow->windowGeometryForViewer( viewWidget() ) );
+            setMdiWindowGeometry( mainWindow->windowGeometryForViewer( viewWidget() ) );
 
             mainWindow->removeViewer( viewWidget() );
 

ApplicationLibCode/ProjectDataModel/RimMultiPlot.cpp

@@ -269,16 +269,16 @@ void RimMultiPlot::movePlotsToThis( const std::vector<RimPlot*>& plotsToMove, in
     {
         if ( insertAtPosition >= 0 )
         {
-            this->insertPlot( plotsToMove[tIdx], (size_t)insertAtPosition + tIdx );
+            insertPlot( plotsToMove[tIdx], (size_t)insertAtPosition + tIdx );
         }
         else
         {
-            this->addPlot( plotsToMove[tIdx] );
+            addPlot( plotsToMove[tIdx] );
         }
     }
 
-    this->updateLayout();
-    this->updateAllRequiredEditors();
+    updateLayout();
+    updateAllRequiredEditors();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -841,7 +841,7 @@ void RimMultiPlot::updatePlots()
         {
             plot->loadDataAndUpdate();
         }
-        this->updateZoom();
+        updateZoom();
     }
 }
 

ApplicationLibCode/ProjectDataModel/RimObservedDataCollection.cpp

@@ -164,7 +164,7 @@ RimObservedSummaryData* RimObservedDataCollection::createAndAddRsmObservedSummar
     RimObservedEclipseUserData* columnBasedUserData = new RimObservedEclipseUserData();
     observedData                                    = columnBasedUserData;
 
-    this->m_observedDataArray.push_back( observedData );
+    m_observedDataArray.push_back( observedData );
     observedData->setSummaryHeaderFileName( fileName );
     observedData->createSummaryReaderInterface();
     observedData->updateMetaData();
@@ -177,7 +177,7 @@ RimObservedSummaryData* RimObservedDataCollection::createAndAddRsmObservedSummar
     RimProject::current()->assignCaseIdToSummaryCase( observedData );
     updateNewObservedDataCreated( observedData );
 
-    this->updateConnectedEditors();
+    updateConnectedEditors();
 
     return observedData;
 }
@@ -231,7 +231,7 @@ RimObservedSummaryData* RimObservedDataCollection::createAndAddCvsObservedSummar
 
     if ( userData->summaryReader() )
     {
-        this->m_observedDataArray.push_back( userData );
+        m_observedDataArray.push_back( userData );
         observedData = userData;
     }
     else
@@ -243,7 +243,7 @@ RimObservedSummaryData* RimObservedDataCollection::createAndAddCvsObservedSummar
     RimProject::current()->assignCaseIdToSummaryCase( observedData );
     updateNewObservedDataCreated( observedData );
 
-    this->updateConnectedEditors();
+    updateConnectedEditors();
 
     return observedData;
 }
@@ -262,7 +262,7 @@ RimObservedFmuRftData* RimObservedDataCollection::createAndAddFmuRftDataFromPath
     m_observedFmuRftArray.push_back( fmuRftData );
 
     updateNewObservedDataCreated( fmuRftData );
-    this->updateConnectedEditors();
+    updateConnectedEditors();
 
     return fmuRftData;
 }
@@ -281,7 +281,7 @@ RimPressureDepthData* RimObservedDataCollection::createAndAddPressureDepthDataFr
     m_observedPressureDepthArray.push_back( data );
 
     updateNewObservedDataCreated( data );
-    this->updateConnectedEditors();
+    updateConnectedEditors();
 
     return data;
 }

ApplicationLibCode/ProjectDataModel/RimPlotAxisProperties.cpp

@@ -270,10 +270,10 @@ void RimPlotAxisProperties::setNameAndAxis( const QString& objectName, const QSt
     m_plotAxis      = axis;
     m_plotAxisIndex = axisIndex;
 
-    if ( axis == RiaDefines::PlotAxis::PLOT_AXIS_LEFT ) this->setUiIconFromResourceString( ":/LeftAxis16x16.png" );
-    if ( axis == RiaDefines::PlotAxis::PLOT_AXIS_RIGHT ) this->setUiIconFromResourceString( ":/RightAxis16x16.png" );
-    if ( axis == RiaDefines::PlotAxis::PLOT_AXIS_BOTTOM ) this->setUiIconFromResourceString( ":/BottomAxis16x16.png" );
-    if ( axis == RiaDefines::PlotAxis::PLOT_AXIS_TOP ) this->setUiIconFromResourceString( ":/TopAxis16x16.png" );
+    if ( axis == RiaDefines::PlotAxis::PLOT_AXIS_LEFT ) setUiIconFromResourceString( ":/LeftAxis16x16.png" );
+    if ( axis == RiaDefines::PlotAxis::PLOT_AXIS_RIGHT ) setUiIconFromResourceString( ":/RightAxis16x16.png" );
+    if ( axis == RiaDefines::PlotAxis::PLOT_AXIS_BOTTOM ) setUiIconFromResourceString( ":/BottomAxis16x16.png" );
+    if ( axis == RiaDefines::PlotAxis::PLOT_AXIS_TOP ) setUiIconFromResourceString( ":/TopAxis16x16.png" );
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/RimPlotCurve.cpp

@@ -162,7 +162,7 @@ void RimPlotCurve::fieldChangedByUi( const caf::PdmFieldHandle* changedField, co
 {
     if ( changedField == &m_showCurve )
     {
-        this->updateCurveVisibility();
+        updateCurveVisibility();
         if ( m_showCurve() ) loadDataAndUpdate( false );
         visibilityChanged.send( m_showCurve() );
     }
@@ -282,16 +282,16 @@ void RimPlotCurve::initAfterRead()
 //--------------------------------------------------------------------------------------------------
 void RimPlotCurve::updateCurvePresentation( bool updatePlotLegendAndTitle )
 {
-    this->updateCurveVisibility();
+    updateCurveVisibility();
 
     if ( updatePlotLegendAndTitle )
     {
-        this->updateCurveNameAndUpdatePlotLegendAndTitle();
-        this->updatePlotTitle();
+        updateCurveNameAndUpdatePlotLegendAndTitle();
+        updatePlotTitle();
     }
     else
     {
-        this->updateCurveNameNoLegendUpdate();
+        updateCurveNameNoLegendUpdate();
     }
 
     updateCurveAppearance();
@@ -330,7 +330,7 @@ QList<caf::PdmOptionItemInfo> RimPlotCurve::calculateValueOptions( const caf::Pd
     {
         // Find all plot windows above this object upwards in the object hierarchy. Use the top most plot window as the
         // root to find all plot curves.
-        auto parentPlots = this->allAncestorsOfType<RimPlotWindow>();
+        auto parentPlots = allAncestorsOfType<RimPlotWindow>();
 
         if ( !parentPlots.empty() )
         {
@@ -405,11 +405,11 @@ void RimPlotCurve::updateCurveName()
 {
     if ( m_namingMethod == RiaDefines::ObjectNamingMethod::AUTO )
     {
-        m_curveName = this->createCurveAutoName();
+        m_curveName = createCurveAutoName();
     }
     else if ( m_namingMethod == RiaDefines::ObjectNamingMethod::TEMPLATE )
     {
-        m_curveName = this->createCurveNameFromTemplate( m_curveNameTemplateText );
+        m_curveName = createCurveNameFromTemplate( m_curveNameTemplateText );
     }
 
     if ( !m_legendEntryText().isEmpty() )
@@ -588,7 +588,7 @@ bool RimPlotCurve::isCrossPlotCurve() const
 //--------------------------------------------------------------------------------------------------
 void RimPlotCurve::loadDataAndUpdate( bool updateParentPlot )
 {
-    this->onLoadDataAndUpdate( updateParentPlot );
+    onLoadDataAndUpdate( updateParentPlot );
     if ( updateParentPlot )
     {
         dataChanged.send();

ApplicationLibCode/ProjectDataModel/RimPlotWindow.cpp

@@ -410,7 +410,7 @@ void RimPlotWindow::setId( int id )
 {
     m_id                  = id;
     QString viewIdTooltip = QString( "Plot id: %1" ).arg( m_id );
-    this->setUiToolTip( viewIdTooltip );
+    setUiToolTip( viewIdTooltip );
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/RimProject.cpp

@@ -234,7 +234,7 @@ RimProject::RimProject()
     // For now, create a default first oilfield that contains the rest of the project
     oilFields.push_back( new RimOilField );
 
-    this->setUiHidden( true );
+    setUiHidden( true );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -305,7 +305,7 @@ void RimProject::close()
 //--------------------------------------------------------------------------------------------------
 void RimProject::beforeInitAfterRead()
 {
-    this->distributePathsFromGlobalPathList();
+    distributePathsFromGlobalPathList();
 
     // Create an empty oil field in case the project did not contain one
     if ( oilFields.size() < 1 )
@@ -406,9 +406,9 @@ RimMainPlotCollection* RimProject::mainPlotCollection() const
 //--------------------------------------------------------------------------------------------------
 bool RimProject::writeProjectFile()
 {
-    this->transferPathsToGlobalPathList();
-    bool couldOpenFile = this->writeFile();
-    this->distributePathsFromGlobalPathList();
+    transferPathsToGlobalPathList();
+    bool couldOpenFile = writeFile();
+    distributePathsFromGlobalPathList();
 
     return couldOpenFile;
 }
@@ -475,9 +475,9 @@ bool RimProject::isProjectFileVersionEqualOrOlderThan( const QString& otherProje
 void RimProject::setProjectFileNameAndUpdateDependencies( const QString& projectFileName )
 {
     // Extract the filename of the project file when it was saved
-    QString oldProjectFileName = this->fileName;
+    QString oldProjectFileName = fileName;
     // Replace with the new actual filename
-    this->fileName = projectFileName;
+    fileName = projectFileName;
 
     QFileInfo fileInfo( projectFileName );
     QString   newProjectPath = fileInfo.path();
@@ -565,7 +565,7 @@ void RimProject::assignCaseIdToCase( RimCase* reservoirCase )
 {
     if ( reservoirCase )
     {
-        std::vector<RimCase*> cases = this->descendantsIncludingThisOfType<RimCase>();
+        std::vector<RimCase*> cases = descendantsIncludingThisOfType<RimCase>();
         for ( RimCase* rimCase : cases )
         {
             m_nextValidCaseId = std::max( m_nextValidCaseId, rimCase->caseId() + 1 );
@@ -582,7 +582,7 @@ void RimProject::assignIdToCaseGroup( RimIdenticalGridCaseGroup* caseGroup )
 {
     if ( caseGroup )
     {
-        std::vector<RimIdenticalGridCaseGroup*> identicalCaseGroups = this->descendantsIncludingThisOfType<RimIdenticalGridCaseGroup>();
+        std::vector<RimIdenticalGridCaseGroup*> identicalCaseGroups = descendantsIncludingThisOfType<RimIdenticalGridCaseGroup>();
 
         for ( RimIdenticalGridCaseGroup* existingCaseGroup : identicalCaseGroups )
         {
@@ -602,7 +602,7 @@ void RimProject::assignViewIdToView( Rim3dView* view )
     {
         if ( m_nextValidViewId < 0 )
         {
-            std::vector<Rim3dView*> views = this->descendantsIncludingThisOfType<Rim3dView>();
+            std::vector<Rim3dView*> views = descendantsIncludingThisOfType<Rim3dView>();
 
             for ( Rim3dView* existingView : views )
             {
@@ -623,7 +623,7 @@ void RimProject::assignPlotIdToPlotWindow( RimPlotWindow* plotWindow )
     {
         if ( m_nextValidPlotId < 0 )
         {
-            std::vector<RimPlotWindow*> plotWindows = this->descendantsIncludingThisOfType<RimPlotWindow>();
+            std::vector<RimPlotWindow*> plotWindows = descendantsIncludingThisOfType<RimPlotWindow>();
 
             for ( RimPlotWindow* existingPlotWindow : plotWindows )
             {
@@ -843,7 +843,7 @@ void RimProject::allVisibleViews( std::vector<Rim3dView*>& views ) const
 void RimProject::allVisibleGridViews( std::vector<RimGridView*>& views ) const
 {
     std::vector<Rim3dView*> visibleViews;
-    this->allVisibleViews( visibleViews );
+    allVisibleViews( visibleViews );
     for ( Rim3dView* view : visibleViews )
     {
         RimGridView* gridView = dynamic_cast<RimGridView*>( view );
@@ -877,7 +877,7 @@ void RimProject::scheduleCreateDisplayModelAndRedrawAllViews()
 void RimProject::allOilFields( std::vector<RimOilField*>& allOilFields ) const
 {
     allOilFields.clear();
-    for ( const auto& oilField : this->oilFields )
+    for ( const auto& oilField : oilFields )
     {
         allOilFields.push_back( oilField );
     }

ApplicationLibCode/ProjectDataModel/RimRegularLegendConfig.cpp

@@ -337,7 +337,7 @@ void RimRegularLegendConfig::fieldChangedByUi( const caf::PdmFieldHandle* change
         rftPlot->onLegendDefinitionChanged();
     }
 
-    this->updateUiIconFromToggleField();
+    updateUiIconFromToggleField();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -667,7 +667,7 @@ void RimRegularLegendConfig::initAfterRead()
 
     updateFieldVisibility();
 
-    this->updateUiIconFromToggleField();
+    updateUiIconFromToggleField();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -755,7 +755,7 @@ void RimRegularLegendConfig::onRecreateLegend()
     // has been removed, (and thus the opengl resources has been deleted) The text in
     // the legend disappeared because of this, so workaround: recreate the legend when needed:
 
-    cvf::Font* font      = RiaApplication::instance()->sceneFont( this->fontSize() );
+    cvf::Font* font      = RiaApplication::instance()->sceneFont( fontSize() );
     m_scalarMapperLegend = new caf::OverlayScalarMapperLegend( font );
     m_categoryLegend     = new caf::CategoryLegend( font, m_categoryMapper.p() );
 
@@ -1068,9 +1068,9 @@ RimLegendConfig::RangeModeType RimRegularLegendConfig::rangeMode() const
 void RimRegularLegendConfig::setUiValuesFromLegendConfig( const RimRegularLegendConfig* otherLegendConfig )
 {
     QString serializedObjectString = otherLegendConfig->writeObjectToXmlString();
-    this->readObjectFromXmlString( serializedObjectString, caf::PdmDefaultObjectFactory::instance() );
-    this->resolveReferencesRecursively();
-    this->updateLegend();
+    readObjectFromXmlString( serializedObjectString, caf::PdmDefaultObjectFactory::instance() );
+    resolveReferencesRecursively();
+    updateLegend();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -1143,7 +1143,7 @@ RimColorLegend* RimRegularLegendConfig::mapToColorLegend( ColorRangesType colorT
 //--------------------------------------------------------------------------------------------------
 void RimRegularLegendConfig::updateFonts()
 {
-    int  pointSize = this->fontSize();
+    int  pointSize = fontSize();
     auto font      = RiaApplication::instance()->sceneFont( pointSize );
 
     m_scalarMapperLegend = new caf::OverlayScalarMapperLegend( font );

ApplicationLibCode/ProjectDataModel/RimRoffCase.cpp

@@ -75,7 +75,7 @@ bool RimRoffCase::openEclipseGridFile()
     if ( eclipseCaseData()->mainGrid()->gridPointDimensions() == cvf::Vec3st( 0, 0, 0 ) )
     {
         QString errorMessages;
-        if ( RifRoffFileTools::openGridFile( fileName, this->eclipseCaseData(), &errorMessages ) )
+        if ( RifRoffFileTools::openGridFile( fileName, eclipseCaseData(), &errorMessages ) )
         {
             QFileInfo gridFileInfo( fileName );
             QString   caseName = gridFileInfo.completeBaseName();
@@ -153,7 +153,7 @@ bool RimRoffCase::importAsciiInputProperties( const QStringList& fileNames )
 {
     bool importFaults = false;
     RifInputPropertyLoader::loadAndSynchronizeInputProperties( m_inputPropertyCollection,
-                                                               this->eclipseCaseData(),
+                                                               eclipseCaseData(),
                                                                std::vector<QString>( fileNames.begin(), fileNames.end() ),
                                                                importFaults );
 

ApplicationLibCode/ProjectDataModel/RimScriptCollection.cpp

@@ -76,7 +76,7 @@ void RimScriptCollection::readContentFromDisc( int folderLevelsLeft )
         return;
     }
 
-    QDir myDir( this->directory() );
+    QDir myDir( directory() );
     if ( !myDir.isReadable() )
     {
         return;

ApplicationLibCode/ProjectDataModel/RimSimWellInView.cpp

@@ -179,11 +179,11 @@ std::vector<const RigWellPath*> RimSimWellInView::wellPipeBranches() const
     {
         RigEclipseCaseData* caseData = eclipseCase->eclipseCaseData();
 
-        bool includeCellCenters = this->isUsingCellCenterForPipe();
+        bool includeCellCenters = isUsingCellCenterForPipe();
         auto simWellCollection  = firstAncestorOrThisOfTypeAsserted<RimSimWellInViewCollection>();
         bool detectBrances      = simWellCollection->isAutoDetectingBranches;
 
-        return caseData->simulationWellBranches( this->name(), includeCellCenters, detectBrances );
+        return caseData->simulationWellBranches( name(), includeCellCenters, detectBrances );
     }
     return std::vector<const RigWellPath*>();
 }
@@ -207,14 +207,14 @@ void RimSimWellInView::wellHeadTopBottomPosition( int frameIndex, cvf::Vec3d* to
 
     if ( frameIndex >= 0 )
     {
-        if ( !this->simWellData()->hasAnyValidCells( frameIndex ) ) return;
+        if ( !simWellData()->hasAnyValidCells( frameIndex ) ) return;
 
-        wellResultFramePtr = this->simWellData()->wellResultFrame( frameIndex );
+        wellResultFramePtr = simWellData()->wellResultFrame( frameIndex );
         whCellPtr          = &( rigReservoir->cellFromWellResultCell( wellResultFramePtr->wellHeadOrStartCell() ) );
     }
     else
     {
-        wellResultFramePtr = this->simWellData()->staticWellResultFrame();
+        wellResultFramePtr = simWellData()->staticWellResultFrame();
         whCellPtr          = &( rigReservoir->cellFromWellResultCell( wellResultFramePtr->wellHeadOrStartCell() ) );
     }
 
@@ -273,7 +273,7 @@ double RimSimWellInView::pipeRadius()
 
     double characteristicCellSize = rigReservoir->mainGrid()->characteristicIJCellSize();
 
-    double pipeRadius = reservoirView->wellCollection()->pipeScaleFactor() * this->pipeScaleFactor() * characteristicCellSize;
+    double pipeRadius = reservoirView->wellCollection()->pipeScaleFactor() * pipeScaleFactor() * characteristicCellSize;
 
     return pipeRadius;
 }
@@ -292,11 +292,11 @@ int RimSimWellInView::pipeCrossSectionVertexCount()
 //--------------------------------------------------------------------------------------------------
 bool RimSimWellInView::intersectsDynamicWellCellsFilteredCells( size_t frameIndex ) const
 {
-    if ( this->simWellData() == nullptr ) return false;
+    if ( simWellData() == nullptr ) return false;
 
     if ( !simWellData()->hasWellResult( frameIndex ) ) return false;
 
-    const RigWellResultFrame* wrsf = this->simWellData()->wellResultFrame( frameIndex );
+    const RigWellResultFrame* wrsf = simWellData()->wellResultFrame( frameIndex );
 
     return intersectsWellCellsFilteredCells( wrsf, frameIndex );
 }
@@ -377,10 +377,10 @@ void RimSimWellInView::schedule2dIntersectionViewUpdate()
 //--------------------------------------------------------------------------------------------------
 bool RimSimWellInView::intersectsStaticWellCellsFilteredCells() const
 {
-    if ( this->simWellData() == nullptr ) return false;
+    if ( simWellData() == nullptr ) return false;
 
     // NOTE: Read out static well cells, union of well cells across all time steps
-    const RigWellResultFrame* wrsf = this->simWellData()->staticWellResultFrame();
+    const RigWellResultFrame* wrsf = simWellData()->staticWellResultFrame();
 
     // NOTE: Use first time step for visibility evaluation
     size_t frameIndex = 0;
@@ -432,7 +432,7 @@ void RimSimWellInView::defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeOrder
 
     if ( reservoirView->cellFilterCollection() && !reservoirView->cellFilterCollection()->hasActiveFilters() )
     {
-        this->uiCapability()->setUiReadOnly( false );
+        uiCapability()->setUiReadOnly( false );
 
         return;
     }
@@ -441,15 +441,15 @@ void RimSimWellInView::defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeOrder
     if ( !wellColl ) return;
 
     if ( wellColl->showWellsIntersectingVisibleCells() &&
-         !this->intersectsDynamicWellCellsFilteredCells( static_cast<size_t>( reservoirView->currentTimeStep() ) ) )
+         !intersectsDynamicWellCellsFilteredCells( static_cast<size_t>( reservoirView->currentTimeStep() ) ) )
     {
         // Mark well as read only if well is not intersecting visible cells
 
-        this->uiCapability()->setUiReadOnly( true );
+        uiCapability()->setUiReadOnly( true );
     }
     else
     {
-        this->uiCapability()->setUiReadOnly( false );
+        uiCapability()->setUiReadOnly( false );
     }
 }
 
@@ -461,13 +461,13 @@ bool RimSimWellInView::isWellCellsVisible() const
     const auto reservoirView = firstAncestorOrThisOfType<RimEclipseView>();
 
     if ( reservoirView == nullptr ) return false;
-    if ( this->simWellData() == nullptr ) return false;
+    if ( simWellData() == nullptr ) return false;
 
     if ( !reservoirView->wellCollection()->isActive() ) return false;
 
-    if ( !this->showWell() ) return false;
+    if ( !showWell() ) return false;
 
-    if ( !this->showWellCells() ) return false;
+    if ( !showWellCells() ) return false;
 
     if ( reservoirView->intersectionCollection()->hasActiveIntersectionForSimulationWell( this ) ) return true;
 
@@ -489,14 +489,14 @@ bool RimSimWellInView::isWellPipeVisible( size_t frameIndex ) const
     const auto reservoirView = firstAncestorOrThisOfType<RimEclipseView>();
 
     if ( reservoirView == nullptr ) return false;
-    if ( this->simWellData() == nullptr ) return false;
+    if ( simWellData() == nullptr ) return false;
 
-    if ( frameIndex >= this->simWellData()->m_resultTimeStepIndexToWellTimeStepIndex.size() )
+    if ( frameIndex >= simWellData()->m_resultTimeStepIndexToWellTimeStepIndex.size() )
     {
         return false;
     }
 
-    size_t wellTimeStepIndex = this->simWellData()->m_resultTimeStepIndexToWellTimeStepIndex[frameIndex];
+    size_t wellTimeStepIndex = simWellData()->m_resultTimeStepIndexToWellTimeStepIndex[frameIndex];
     if ( wellTimeStepIndex == cvf::UNDEFINED_SIZE_T )
     {
         return false;
@@ -504,9 +504,9 @@ bool RimSimWellInView::isWellPipeVisible( size_t frameIndex ) const
 
     if ( !reservoirView->wellCollection()->isActive() ) return false;
 
-    if ( !this->showWell() ) return false;
+    if ( !showWell() ) return false;
 
-    if ( !this->showWellPipe() ) return false;
+    if ( !showWellPipe() ) return false;
 
     if ( reservoirView->intersectionCollection()->hasActiveIntersectionForSimulationWell( this ) ) return true;
 
@@ -529,14 +529,14 @@ bool RimSimWellInView::isWellSpheresVisible( size_t frameIndex ) const
     const auto reservoirView = firstAncestorOrThisOfType<RimEclipseView>();
 
     if ( reservoirView == nullptr ) return false;
-    if ( this->simWellData() == nullptr ) return false;
+    if ( simWellData() == nullptr ) return false;
 
-    if ( frameIndex >= this->simWellData()->m_resultTimeStepIndexToWellTimeStepIndex.size() )
+    if ( frameIndex >= simWellData()->m_resultTimeStepIndexToWellTimeStepIndex.size() )
     {
         return false;
     }
 
-    size_t wellTimeStepIndex = this->simWellData()->m_resultTimeStepIndexToWellTimeStepIndex[frameIndex];
+    size_t wellTimeStepIndex = simWellData()->m_resultTimeStepIndexToWellTimeStepIndex[frameIndex];
     if ( wellTimeStepIndex == cvf::UNDEFINED_SIZE_T )
     {
         return false;
@@ -544,9 +544,9 @@ bool RimSimWellInView::isWellSpheresVisible( size_t frameIndex ) const
 
     if ( !reservoirView->wellCollection()->isActive() ) return false;
 
-    if ( !this->showWell() ) return false;
+    if ( !showWell() ) return false;
 
-    if ( !this->showWellSpheres() ) return false;
+    if ( !showWellSpheres() ) return false;
 
     if ( reservoirView->intersectionCollection()->hasActiveIntersectionForSimulationWell( this ) ) return true;
 
@@ -568,20 +568,20 @@ bool RimSimWellInView::isWellValvesVisible( size_t frameIndex ) const
     const auto reservoirView = firstAncestorOrThisOfType<RimEclipseView>();
 
     if ( reservoirView == nullptr ) return false;
-    if ( this->simWellData() == nullptr ) return false;
+    if ( simWellData() == nullptr ) return false;
 
-    if ( frameIndex >= this->simWellData()->m_resultTimeStepIndexToWellTimeStepIndex.size() )
+    if ( frameIndex >= simWellData()->m_resultTimeStepIndexToWellTimeStepIndex.size() )
     {
         return false;
     }
 
-    size_t wellTimeStepIndex = this->simWellData()->m_resultTimeStepIndexToWellTimeStepIndex[frameIndex];
+    size_t wellTimeStepIndex = simWellData()->m_resultTimeStepIndexToWellTimeStepIndex[frameIndex];
     if ( wellTimeStepIndex == cvf::UNDEFINED_SIZE_T )
     {
         return false;
     }
 
-    if ( !this->showWell() ) return false;
+    if ( !showWell() ) return false;
 
     if ( !reservoirView->wellCollection()->isActive() ) return false;
     if ( !reservoirView->wellCollection()->showValves() ) return false;
@@ -655,14 +655,14 @@ bool RimSimWellInView::isWellDiskVisible() const
     const auto reservoirView = firstAncestorOrThisOfType<RimEclipseView>();
 
     if ( reservoirView == nullptr ) return false;
-    if ( this->simWellData() == nullptr ) return false;
+    if ( simWellData() == nullptr ) return false;
 
     if ( !reservoirView->wellCollection()->isActive() ) return false;
     if ( !reservoirView->wellCollection()->isWellDisksVisible() ) return false;
 
-    if ( !this->showWell() ) return false;
+    if ( !showWell() ) return false;
 
-    if ( !this->showWellDisks() ) return false;
+    if ( !showWellDisks() ) return false;
 
     return true;
 }

ApplicationLibCode/ProjectDataModel/RimSimWellInViewCollection.cpp

@@ -274,11 +274,11 @@ bool RimSimWellInViewCollection::showWellCells()
 //--------------------------------------------------------------------------------------------------
 RimSimWellInView* RimSimWellInViewCollection::findWell( QString name )
 {
-    for ( size_t i = 0; i < this->wells().size(); ++i )
+    for ( size_t i = 0; i < wells().size(); ++i )
     {
-        if ( this->wells()[i]->name() == name )
+        if ( wells()[i]->name() == name )
         {
-            return this->wells()[i];
+            return wells()[i];
         }
     }
     return nullptr;
@@ -289,13 +289,13 @@ RimSimWellInView* RimSimWellInViewCollection::findWell( QString name )
 //--------------------------------------------------------------------------------------------------
 bool RimSimWellInViewCollection::hasVisibleWellCells()
 {
-    if ( !this->isActive() ) return false;
-    if ( this->wells().size() == 0 ) return false;
+    if ( !isActive() ) return false;
+    if ( wells().size() == 0 ) return false;
 
     bool hasCells = false;
-    for ( size_t i = 0; !hasCells && i < this->wells().size(); ++i )
+    for ( size_t i = 0; !hasCells && i < wells().size(); ++i )
     {
-        RimSimWellInView* well = this->wells()[i];
+        RimSimWellInView* well = wells()[i];
         if ( well && well->simWellData() && ( ( well->showWell() && well->showWellCells() ) ) )
         {
             for ( size_t tIdx = 0; !hasCells && tIdx < well->simWellData()->m_wellCellsTimeSteps.size(); ++tIdx )
@@ -321,8 +321,8 @@ bool RimSimWellInViewCollection::hasVisibleWellCells()
 //--------------------------------------------------------------------------------------------------
 bool RimSimWellInViewCollection::hasVisibleWellPipes()
 {
-    if ( !this->isActive() ) return false;
-    if ( this->wells().size() == 0 ) return false;
+    if ( !isActive() ) return false;
+    if ( wells().size() == 0 ) return false;
 
     return true;
 }
@@ -334,7 +334,7 @@ void RimSimWellInViewCollection::fieldChangedByUi( const caf::PdmFieldHandle* ch
 {
     if ( &isActive == changedField )
     {
-        this->updateUiIconFromToggleField();
+        updateUiIconFromToggleField();
     }
 
     if ( &m_showWellLabel == changedField )