Merged branch maintenance-enhancements into dev

ApplicationCode/Commands/RicExportToLasFileFeature.cpp

@@ -24,6 +24,8 @@
 #include "RigLasFileExporter.h"
 #include "RimWellLogCurve.h"
 
+#include "WellLogCommands/RicWellLogPlotCurveFeatureImpl.h"
+
 #include "cafPdmUiPropertyViewDialog.h"
 #include "cafSelectionManager.h"
   
@@ -39,7 +41,7 @@ CAF_CMD_SOURCE_INIT(RicExportToLasFileFeature, "RicExportToLasFileFeature");
 //--------------------------------------------------------------------------------------------------
 bool RicExportToLasFileFeature::isCommandEnabled()
 {
-    return selectedWellLogCurves().size() > 0;
+    return RicWellLogPlotCurveFeatureImpl::selectedWellLogCurves().size() > 0;
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -47,7 +49,7 @@ bool RicExportToLasFileFeature::isCommandEnabled()
 //--------------------------------------------------------------------------------------------------
 void RicExportToLasFileFeature::onActionTriggered(bool isChecked)
 {
-    std::vector<RimWellLogCurve*> curves = selectedWellLogCurves();
+    std::vector<RimWellLogCurve*> curves = RicWellLogPlotCurveFeatureImpl::selectedWellLogCurves();
     if (curves.size() == 0) return;
 
     RiaApplication* app = RiaApplication::instance();
@@ -103,39 +105,3 @@ void RicExportToLasFileFeature::setupActionLook(QAction* actionToSetup)
     actionToSetup->setText("Export To LAS Files...");
 }
 
-//--------------------------------------------------------------------------------------------------
-/// 
-//--------------------------------------------------------------------------------------------------
-std::vector<RimWellLogCurve*> RicExportToLasFileFeature::selectedWellLogCurves() const
-{
-    std::set<RimWellLogCurve*> curveSet;
-
-    {
-        std::vector<caf::PdmUiItem*> selectedItems;
-        caf::SelectionManager::instance()->selectedItems(selectedItems);
-
-        for (auto selectedItem : selectedItems)
-        {
-            caf::PdmObjectHandle* objHandle = dynamic_cast<caf::PdmObjectHandle*>(selectedItem);
-            if (objHandle)
-            {
-                std::vector<RimWellLogCurve*> childCurves;
-                objHandle->descendantsIncludingThisOfType(childCurves);
-
-                for (auto curve : childCurves)
-                {
-                    curveSet.insert(curve);
-                }
-            }
-        }
-    }
-
-    std::vector<RimWellLogCurve*> allCurves;
-    for (auto curve : curveSet)
-    {
-        allCurves.push_back(curve);
-    }
-
-    return allCurves;
-}
-

ApplicationCode/Commands/RicExportToLasFileFeature.h

@@ -37,8 +37,5 @@ protected:
     virtual bool isCommandEnabled();
     virtual void onActionTriggered( bool isChecked );
     virtual void setupActionLook( QAction* actionToSetup );
-
-private:
-    std::vector<RimWellLogCurve*> selectedWellLogCurves() const;
 };
 

ApplicationCode/Commands/WellLogCommands/CMakeLists_files.cmake

@@ -18,6 +18,8 @@ ${CEE_CURRENT_LIST_DIR}RicWellLogPlotTrackFeatureImpl.h
 ${CEE_CURRENT_LIST_DIR}RicPasteWellLogCurveFeature.h
 ${CEE_CURRENT_LIST_DIR}RicPasteWellLogTrackFeature.h
 ${CEE_CURRENT_LIST_DIR}RicPasteWellLogPlotFeature.h
+${CEE_CURRENT_LIST_DIR}RicChangeDataSourceFeature.h
+${CEE_CURRENT_LIST_DIR}RicChangeDataSourceFeatureUi.h
 )
 
 set (SOURCE_GROUP_SOURCE_FILES
@@ -34,6 +36,8 @@ ${CEE_CURRENT_LIST_DIR}RicWellLogPlotTrackFeatureImpl.cpp
 ${CEE_CURRENT_LIST_DIR}RicPasteWellLogCurveFeature.cpp
 ${CEE_CURRENT_LIST_DIR}RicPasteWellLogTrackFeature.cpp
 ${CEE_CURRENT_LIST_DIR}RicPasteWellLogPlotFeature.cpp
+${CEE_CURRENT_LIST_DIR}RicChangeDataSourceFeature.cpp
+${CEE_CURRENT_LIST_DIR}RicChangeDataSourceFeatureUi.cpp
 )
 
 list(APPEND CODE_HEADER_FILES

ApplicationCode/Commands/WellLogCommands/RicChangeDataSourceFeature.cpp

@@ -0,0 +1,98 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2016      Statoil ASA
+// 
+//  ResInsight is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+// 
+//  ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
+//  WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//  FITNESS FOR A PARTICULAR PURPOSE.
+// 
+//  See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html> 
+//  for more details.
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+#include "RicChangeDataSourceFeature.h"
+
+#include "RicChangeDataSourceFeatureUi.h"
+#include "RicWellLogPlotCurveFeatureImpl.h"
+
+#include "RimCase.h"
+#include "RimWellLogCurve.h"
+#include "RimWellLogExtractionCurve.h"
+#include "RimWellPath.h"
+
+#include "cafPdmUiPropertyViewDialog.h"
+
+#include <QAction>
+
+CAF_CMD_SOURCE_INIT(RicChangeDataSourceFeature, "RicChangeDataSourceFeature");
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+bool RicChangeDataSourceFeature::isCommandEnabled()
+{
+    std::vector<RimWellLogExtractionCurve*> extrCurves = extractionCurves();
+
+    return extrCurves.size() > 0;
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RicChangeDataSourceFeature::onActionTriggered(bool isChecked)
+{
+    std::vector<RimWellLogExtractionCurve*> extrCurves = extractionCurves();
+    if (extrCurves.size() == 0) return;
+
+    RicChangeDataSourceFeatureUi featureUi;
+    featureUi.wellPathToApply = extrCurves[0]->wellPath();
+    featureUi.caseToApply = extrCurves[0]->rimCase();
+
+    caf::PdmUiPropertyViewDialog propertyDialog(nullptr, &featureUi, "Change Data Source for Selected Curves", "");
+    propertyDialog.resize(QSize(500, 200));
+    if (propertyDialog.exec() == QDialog::Accepted)
+    {
+        for (RimWellLogExtractionCurve* extractionCurve : extrCurves)
+        {
+            extractionCurve->setWellPath(featureUi.wellPathToApply);
+            extractionCurve->setCase(featureUi.caseToApply);
+
+            extractionCurve->loadDataAndUpdate();
+        }
+    }
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RicChangeDataSourceFeature::setupActionLook(QAction* actionToSetup)
+{
+    actionToSetup->setText("Change Data Source");
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+std::vector<RimWellLogExtractionCurve*> RicChangeDataSourceFeature::extractionCurves()
+{
+    std::vector<RimWellLogExtractionCurve*> extrCurves;
+
+    std::vector<RimWellLogCurve*> curves = RicWellLogPlotCurveFeatureImpl::selectedWellLogCurves();
+
+    for (RimWellLogCurve* c : curves)
+    {
+        if (dynamic_cast<RimWellLogExtractionCurve*>(c))
+        {
+            extrCurves.push_back(dynamic_cast<RimWellLogExtractionCurve*>(c));
+        }
+    }
+
+    return extrCurves;
+}
+

ApplicationCode/Commands/WellLogCommands/RicChangeDataSourceFeature.h

@@ -0,0 +1,41 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2016      Statoil ASA
+// 
+//  ResInsight is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+// 
+//  ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
+//  WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//  FITNESS FOR A PARTICULAR PURPOSE.
+// 
+//  See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html> 
+//  for more details.
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "cafCmdFeature.h"
+
+#include <vector>
+
+class RimWellLogExtractionCurve;
+
+//==================================================================================================
+/// 
+//==================================================================================================
+class RicChangeDataSourceFeature : public caf::CmdFeature
+{
+    CAF_CMD_HEADER_INIT;
+
+protected:
+    virtual bool isCommandEnabled() override;
+    virtual void onActionTriggered( bool isChecked ) override;
+    virtual void setupActionLook(QAction* actionToSetup) override;
+
+private:
+    static std::vector<RimWellLogExtractionCurve*> extractionCurves();
+};

ApplicationCode/Commands/WellLogCommands/RicChangeDataSourceFeatureUi.cpp

@@ -0,0 +1,87 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2016      Statoil ASA
+// 
+//  ResInsight is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+// 
+//  ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
+//  WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//  FITNESS FOR A PARTICULAR PURPOSE.
+// 
+//  See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html> 
+//  for more details.
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+#include "RicChangeDataSourceFeatureUi.h"
+
+#include "RimCase.h"
+#include "RimOilField.h"
+#include "RimProject.h"
+#include "RimWellPath.h"
+#include "RimWellPathCollection.h"
+
+#include "RiaApplication.h"
+
+CAF_PDM_SOURCE_INIT(RicChangeDataSourceFeatureUi, "ChangeDataSourceFeatureUi");
+
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+RicChangeDataSourceFeatureUi::RicChangeDataSourceFeatureUi()
+{
+    CAF_PDM_InitObject("Change Data Source", "", "", "");
+
+    CAF_PDM_InitFieldNoDefault(&wellPathToApply,  "CurveWellPath",  "Well Path", "", "", "");
+    CAF_PDM_InitFieldNoDefault(&caseToApply,      "CurveCase",      "Case", "", "", "");
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+QList<caf::PdmOptionItemInfo> RicChangeDataSourceFeatureUi::calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool * useOptionsOnly)
+{
+    QList<caf::PdmOptionItemInfo> optionList;
+
+    if (fieldNeedingOptions == &caseToApply)
+    {
+        RimProject* proj = RiaApplication::instance()->project();
+        
+        std::vector<RimCase*> cases;
+        proj->allCases(cases);
+
+        for (RimCase* c : cases)
+        {
+            optionList.push_back(caf::PdmOptionItemInfo(c->caseUserDescription(), c));
+        }
+    }
+    else if (fieldNeedingOptions == &wellPathToApply)
+    {
+        RimProject* proj = RiaApplication::instance()->project();
+
+        if (proj->activeOilField()->wellPathCollection())
+        {
+            for (RimWellPath* wellPath : proj->activeOilField()->wellPathCollection()->wellPaths)
+            {
+                optionList.push_back(caf::PdmOptionItemInfo(wellPath->name(), wellPath));
+            }
+        }
+    }
+
+    return optionList;
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RicChangeDataSourceFeatureUi::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
+{
+    caf::PdmUiGroup* group = uiOrdering.addNewGroup("Apply the following for all selected curves");
+
+    group->add(&caseToApply);
+    group->add(&wellPathToApply);
+}

ApplicationCode/Commands/WellLogCommands/RicChangeDataSourceFeatureUi.h

@@ -0,0 +1,46 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2016      Statoil ASA
+// 
+//  ResInsight is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+// 
+//  ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
+//  WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//  FITNESS FOR A PARTICULAR PURPOSE.
+// 
+//  See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html> 
+//  for more details.
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "cafPdmObject.h"
+#include "cafPdmPtrField.h"
+#include "cafPdmUiOrdering.h"
+
+class RimCase;
+class RimWellPath;
+
+
+//==================================================================================================
+/// 
+//==================================================================================================
+class RicChangeDataSourceFeatureUi : public caf::PdmObject
+{
+    CAF_PDM_HEADER_INIT;
+
+public:
+    RicChangeDataSourceFeatureUi();
+
+    caf::PdmPtrField<RimCase*>     caseToApply;
+    caf::PdmPtrField<RimWellPath*> wellPathToApply;
+
+protected:
+    virtual QList<caf::PdmOptionItemInfo> calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool * useOptionsOnly) override;
+
+    virtual void defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering) override;
+};

ApplicationCode/Commands/WellLogCommands/RicWellLogPlotCurveFeatureImpl.cpp

@@ -19,6 +19,10 @@
 
 #include "RicWellLogPlotCurveFeatureImpl.h"
 
+#include "RimWellLogCurve.h"
+
+#include "cafSelectionManager.h"
+
 #include <QColor>
 
 static const int RI_LOGPLOT_CURVECOLORSCOUNT = 15;
@@ -52,3 +56,39 @@ cvf::Color3f RicWellLogPlotCurveFeatureImpl::curveColorFromTable()
     cvf::Color3f cvfColor(color.redF(), color.greenF(), color.blueF());
     return cvfColor;
 }
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+std::vector<RimWellLogCurve*> RicWellLogPlotCurveFeatureImpl::selectedWellLogCurves()
+{
+    std::set<RimWellLogCurve*> curveSet;
+
+    {
+        std::vector<caf::PdmUiItem*> selectedItems;
+        caf::SelectionManager::instance()->selectedItems(selectedItems);
+
+        for (caf::PdmUiItem* selectedItem : selectedItems)
+        {
+            caf::PdmObjectHandle* objHandle = dynamic_cast<caf::PdmObjectHandle*>(selectedItem);
+            if (objHandle)
+            {
+                std::vector<RimWellLogCurve*> childCurves;
+                objHandle->descendantsIncludingThisOfType(childCurves);
+
+                for (RimWellLogCurve* curve : childCurves)
+                {
+                    curveSet.insert(curve);
+                }
+            }
+        }
+    }
+
+    std::vector<RimWellLogCurve*> allCurves;
+    for (RimWellLogCurve* curve : curveSet)
+    {
+        allCurves.push_back(curve);
+    }
+
+    return allCurves;
+}

ApplicationCode/Commands/WellLogCommands/RicWellLogPlotCurveFeatureImpl.h

@@ -21,12 +21,14 @@
 
 #include "cafPdmFieldCvfColor.h"
 
+class RimWellLogCurve;
+
 //==================================================================================================
 /// 
 //==================================================================================================
 class RicWellLogPlotCurveFeatureImpl
 {
-
 public:
     static cvf::Color3f curveColorFromTable();
+    static std::vector<RimWellLogCurve*> selectedWellLogCurves();
 };

ApplicationCode/GeoMech/GeoMechDataModel/RigFemPart.cpp

@@ -287,16 +287,13 @@ float RigFemPart::characteristicElementSize()
 {
     if (m_characteristicElementSize != std::numeric_limits<float>::infinity()) return m_characteristicElementSize;
 
-    // take 100 elements 
-    float elmIdxJump = elementCount() / 100.0f;
-    int elmIdxIncrement = elmIdxJump < 1 ? 1: (int) elmIdxJump;
     int elmsToAverageCount = 0;
     float sumMaxEdgeLength = 0;
-    for (int elmIdx = 0; elmIdx < elementCount(); elmIdx += elmIdxIncrement)
+    for (int elmIdx = 0; elmIdx < elementCount(); elmIdx++)
     {
         RigElementType eType = this->elementType(elmIdx);
 
-        if (eType == HEX8 || eType == HEX8P)
+        if (eType == HEX8P)
         {
             const int* elmentConn = this->connectivities(elmIdx);
             cvf::Vec3f nodePos0 = this->nodes().coordinates[elmentConn[0]];

ApplicationCode/ProjectDataModel/RimContextCommandBuilder.cpp

@@ -393,6 +393,7 @@ QStringList RimContextCommandBuilder::commandsFromSelection()
         {
             commandIds << "RicCopyReferencesToClipboardFeature";
             commandIds << "RicExportToLasFileFeature";
+            commandIds << "RicChangeDataSourceFeature";
         }
         else if (dynamic_cast<RimWellLogPlotCollection*>(uiItem))
         {

ApplicationCode/ProjectDataModel/RimViewController.cpp

@@ -67,6 +67,7 @@ RimViewController::RimViewController(void)
     m_managedView.uiCapability()->setUiTreeChildrenHidden(true);
 
     CAF_PDM_InitField(&m_syncCamera,            "SyncCamera", true,             "Camera", "", "", "");
+    CAF_PDM_InitField(&m_showCursor,            "ShowCursor", true,             "   Show Cursor", "", "", "");
     CAF_PDM_InitField(&m_syncTimeStep,          "SyncTimeStep", true,           "Time Step", "", "", "");
     CAF_PDM_InitField(&m_syncCellResult,        "SyncCellResult", false,        "Cell Result", "", "", "");
     CAF_PDM_InitField(&m_syncLegendDefinitions, "SyncLegendDefinitions", true,  "   Legend Definition", "", "", "");
@@ -174,6 +175,13 @@ void RimViewController::fieldChangedByUi(const caf::PdmFieldHandle* changedField
     {
         updateTimeStepLink();
     }
+    else if (changedField == &m_showCursor)
+    {
+        if (!m_showCursor && m_managedView && m_managedView->viewer())
+        {
+            m_managedView->viewer()->setCursorPosition(cvf::Vec3d::UNDEFINED);
+        }
+    }
     else if (changedField == &m_syncCellResult)
     {
         updateResultColorsControl();
@@ -223,7 +231,7 @@ void RimViewController::fieldChangedByUi(const caf::PdmFieldHandle* changedField
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RimEclipseView* RimViewController::managedEclipseView()
+RimEclipseView* RimViewController::managedEclipseView() const
 {
     RimView* rimView = m_managedView;
 
@@ -233,7 +241,7 @@ RimEclipseView* RimViewController::managedEclipseView()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RimGeoMechView* RimViewController::managedGeoView()
+RimGeoMechView* RimViewController::managedGeoView() const
 {
     RimView* rimView = m_managedView;
 
@@ -418,13 +426,23 @@ void RimViewController::updateOptionSensitivity()
         this->m_syncRangeFilters = false;
     }
 
+    if (m_syncCamera)
+    {
+        this->m_showCursor.uiCapability()->setUiReadOnly(false);
+    }
+    else
+    {
+        this->m_showCursor.uiCapability()->setUiReadOnly(true);
+        this->m_showCursor = false;
+    }
+
     m_syncVisibleCells.uiCapability()->setUiReadOnly(!this->isMasterAndDepViewDifferentType());
 }
 
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RimView* RimViewController::managedView()
+RimView* RimViewController::managedView() const
 {
     return m_managedView;
 }
@@ -455,6 +473,7 @@ void RimViewController::defineUiOrdering(QString uiConfigName, caf::PdmUiOrderin
     caf::PdmUiGroup* scriptGroup = uiOrdering.addNewGroup("Link Options");
 
     scriptGroup->add(&m_syncCamera);
+    scriptGroup->add(&m_showCursor);
     scriptGroup->add(&m_syncTimeStep);
     scriptGroup->add(&m_syncCellResult);
     scriptGroup->add(&m_syncLegendDefinitions);
@@ -530,7 +549,7 @@ void RimViewController::updateLegendDefinitions()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RimViewLinker* RimViewController::ownerViewLinker()
+RimViewLinker* RimViewController::ownerViewLinker() const
 {
     RimViewLinker* viewLinker = NULL;
     this->firstAncestorOrThisOfType(viewLinker);
@@ -609,7 +628,7 @@ const RigCaseToCaseCellMapper* RimViewController::cellMapper()
         }
          else if (masterFemPart && dependEclGrid)
         {
-             m_caseToCaseCellMapper = new RigCaseToCaseCellMapper(masterFemPart, dependEclGrid);
+            m_caseToCaseCellMapper = new RigCaseToCaseCellMapper(masterFemPart, dependEclGrid);
         }
     }
 
@@ -619,7 +638,7 @@ const RigCaseToCaseCellMapper* RimViewController::cellMapper()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RimView* RimViewController::masterView()
+RimView* RimViewController::masterView() const
 {
     return ownerViewLinker()->masterView();
 }
@@ -627,7 +646,7 @@ RimView* RimViewController::masterView()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RimViewController::isMasterAndDepViewDifferentType()
+bool RimViewController::isMasterAndDepViewDifferentType() const
 {
     RimEclipseView* eclipseMasterView = dynamic_cast<RimEclipseView*>(masterView());
     RimGeoMechView* geoMasterView = dynamic_cast<RimGeoMechView*>(masterView());
@@ -648,7 +667,7 @@ bool RimViewController::isMasterAndDepViewDifferentType()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimViewController::scheduleCreateDisplayModelAndRedrawForDependentView()
+void RimViewController::scheduleCreateDisplayModelAndRedrawForDependentView() const
 {
     if (!this->isActive()) return;
 
@@ -668,7 +687,7 @@ void RimViewController::scheduleCreateDisplayModelAndRedrawForDependentView()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimViewController::scheduleGeometryRegenForDepViews(RivCellSetEnum geometryType)
+void RimViewController::scheduleGeometryRegenForDepViews(RivCellSetEnum geometryType) const
 {
     if (!this->isActive()) return;
 
@@ -693,7 +712,7 @@ void RimViewController::scheduleGeometryRegenForDepViews(RivCellSetEnum geometry
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RimViewController::isActive()
+bool RimViewController::isActive() const
 {
     return ownerViewLinker()->isActive() && this->m_isActive();
 }
@@ -701,7 +720,7 @@ bool RimViewController::isActive()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RimViewController::isCameraLinked()
+bool RimViewController::isCameraLinked() const
 {
     if (ownerViewLinker()->isActive() && this->m_isActive())
     {
@@ -716,7 +735,15 @@ bool RimViewController::isCameraLinked()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RimViewController::isTimeStepLinked()
+bool RimViewController::showCursor() const
+{
+    return m_showCursor;
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+bool RimViewController::isTimeStepLinked() const
 {
     if (ownerViewLinker()->isActive() && this->m_isActive())
     {
@@ -731,7 +758,7 @@ bool RimViewController::isTimeStepLinked()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RimViewController::isResultColorControlled()
+bool RimViewController::isResultColorControlled() const
 {
    if (ownerViewLinker()->isActive() && this->m_isActive())
     {
@@ -746,7 +773,7 @@ bool RimViewController::isResultColorControlled()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RimViewController::isLegendDefinitionsControlled()
+bool RimViewController::isLegendDefinitionsControlled() const
 {
     if (ownerViewLinker()->isActive() && this->m_isActive())
     {
@@ -761,7 +788,7 @@ bool RimViewController::isLegendDefinitionsControlled()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RimViewController::isVisibleCellsOveridden()
+bool RimViewController::isVisibleCellsOveridden() const
 {
     if (isMasterAndDepViewDifferentType())
     {
@@ -783,7 +810,7 @@ bool RimViewController::isVisibleCellsOveridden()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RimViewController::isRangeFilterControlPossible()
+bool RimViewController::isRangeFilterControlPossible() const
 {
     return true;
     #if 0
@@ -817,7 +844,7 @@ bool RimViewController::isRangeFilterControlPossible()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RimViewController::isRangeFilterMappingApliccable()
+bool RimViewController::isRangeFilterMappingApliccable() const
 {
     if (!isMasterAndDepViewDifferentType()) return false;
 
@@ -850,7 +877,7 @@ bool RimViewController::isRangeFilterMappingApliccable()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RimViewController::isRangeFiltersControlled()
+bool RimViewController::isRangeFiltersControlled() const
 {
     if (!isRangeFilterControlPossible()) return false;
 
@@ -866,7 +893,7 @@ bool RimViewController::isRangeFiltersControlled()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RimViewController::isPropertyFilterControlPossible()
+bool RimViewController::isPropertyFilterControlPossible() const
 {
     // The cases need to be the same 
     RimGeoMechView* geomView = dynamic_cast<RimGeoMechView*>(masterView());
@@ -898,7 +925,7 @@ bool RimViewController::isPropertyFilterControlPossible()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RimViewController::isPropertyFilterOveridden()
+bool RimViewController::isPropertyFilterOveridden() const
 {
    if (!isPropertyFilterControlPossible()) return false;
 

ApplicationCode/ProjectDataModel/RimViewController.h

@@ -47,28 +47,29 @@ public:
     RimViewController(void);
     virtual ~RimViewController(void);
 
-    bool                                    isActive();
+    bool                                    isActive() const;
 
-    RimView*                                managedView();
+    RimView*                                managedView() const;
     void                                    setManagedView(RimView* view);
 
-    RimView*                                masterView();
+    RimView*                                masterView() const;
-    RimViewLinker*                          ownerViewLinker();
+    RimViewLinker*                          ownerViewLinker() const;
 
     const RigCaseToCaseCellMapper*          cellMapper();
     
-    bool                                    isCameraLinked();
+    bool                                    isCameraLinked() const;
-    bool                                    isTimeStepLinked();
+    bool                                    showCursor() const;
+    bool                                    isTimeStepLinked() const;
 
-    bool                                    isResultColorControlled();
+    bool                                    isResultColorControlled() const;
-    bool                                    isLegendDefinitionsControlled();
+    bool                                    isLegendDefinitionsControlled() const;
-    bool                                    isRangeFiltersControlled();
+    bool                                    isRangeFiltersControlled() const;
     
-    bool                                    isVisibleCellsOveridden();
+    bool                                    isVisibleCellsOveridden() const;
-    bool                                    isPropertyFilterOveridden();
+    bool                                    isPropertyFilterOveridden() const;
 
-    void                                    scheduleCreateDisplayModelAndRedrawForDependentView();
+    void                                    scheduleCreateDisplayModelAndRedrawForDependentView() const;
-    void                                    scheduleGeometryRegenForDepViews(RivCellSetEnum geometryType);
+    void                                    scheduleGeometryRegenForDepViews(RivCellSetEnum geometryType) const;
     void                                    updateOverrides();
     void                                    updateOptionSensitivity();
     void                                    removeOverrides();
@@ -93,24 +94,27 @@ private:
     void                                    updateResultColorsControl();
     void                                    updateLegendDefinitions();
 
-    bool                                    isMasterAndDepViewDifferentType();
+    bool                                    isMasterAndDepViewDifferentType() const;
-    bool                                    isRangeFilterControlPossible();
+    bool                                    isRangeFilterControlPossible() const;
-    bool                                    isPropertyFilterControlPossible();
+    bool                                    isPropertyFilterControlPossible() const;
-    bool                                    isRangeFilterMappingApliccable();
+    bool                                    isRangeFilterMappingApliccable() const;
 
-    RimEclipseView*                         managedEclipseView();
+    RimEclipseView*                         managedEclipseView() const;
-    RimGeoMechView*                         managedGeoView();
+    RimGeoMechView*                         managedGeoView() const;
+    
     static void                             removeOverrides(RimView* view);
-
     static bool                             askUserToRestoreOriginalRangeFilterCollection(const QString& viewName);
+
 private:
     caf::PdmField<QString>                  m_name;
     caf::PdmPtrField<RimView*>              m_managedView;
 
     caf::PdmField<bool>                     m_isActive;
     caf::PdmField<bool>                     m_syncCamera;
+    caf::PdmField<bool>                     m_showCursor;
     caf::PdmField<bool>                     m_syncTimeStep;
 
+
     // Overridden properties
     caf::PdmField<bool>                     m_syncCellResult;
     caf::PdmField<bool>                     m_syncLegendDefinitions;

ApplicationCode/ProjectDataModel/RimViewLinker.cpp

@@ -247,7 +247,7 @@ void RimViewLinker::removeOverrides()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimViewLinker::allViewsForCameraSync(RimView* source, std::vector<RimView*>& views)
+void RimViewLinker::allViewsForCameraSync(const RimView* source, std::vector<RimView*>& views) const
 {
     if (!isActive()) return;
 
@@ -322,7 +322,7 @@ void RimViewLinker::setMasterView(RimView* view)
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RimView* RimViewLinker::masterView()
+RimView* RimViewLinker::masterView() const
 {
     return m_masterView;
 }
@@ -330,7 +330,7 @@ RimView* RimViewLinker::masterView()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimViewLinker::allViews(std::vector<RimView*>& views)
+void RimViewLinker::allViews(std::vector<RimView*>& views) const
 {
     views.push_back(m_masterView());
 
@@ -382,7 +382,7 @@ void RimViewLinker::updateScaleZ(RimView* sourceView, double scaleZ)
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RimViewLinker::isActive()
+bool RimViewLinker::isActive() const
 {
     RimViewLinkerCollection* viewLinkerCollection = NULL;
     this->firstAncestorOrThisOfType(viewLinkerCollection);
@@ -482,6 +482,40 @@ void RimViewLinker::findNameAndIconFromView(QString* name, QIcon* icon, RimView*
     }
 }
 
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RimViewLinker::updateCursorPosition(const RimView* sourceView, const cvf::Vec3d& domainCoord)
+{
+    RimViewController* sourceViewLink = sourceView->viewController();
+    if (sourceViewLink && !sourceViewLink->showCursor())
+    {
+        return;
+    }
+
+    std::vector<RimView*> viewsToUpdate;
+    allViewsForCameraSync(sourceView, viewsToUpdate);
+
+    for (RimView* destinationView : viewsToUpdate)
+    {
+        if (destinationView == sourceView) continue;
+
+        if (destinationView != m_masterView)
+        {
+            RimViewController* viewLink = destinationView->viewController();
+            if (!viewLink) continue;
+
+            if (!viewLink->showCursor()) continue;
+        }
+
+        RiuViewer* destinationViewer = destinationView->viewer();
+        if (destinationViewer)
+        {
+            destinationViewer->setCursorPosition(domainCoord);
+        }
+    }
+}
+
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
@@ -626,18 +660,16 @@ void RimViewLinker::addDependentView(RimView* view)
     this->m_viewControllers.push_back(viewContr);
 
     viewContr->setManagedView(view);
-
-
 }
 
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimViewLinker::addViewControllers(caf::PdmUiTreeOrdering& uiTreeOrdering)
+void RimViewLinker::addViewControllers(caf::PdmUiTreeOrdering& uiTreeOrdering) const
 {
     for (size_t j = 0; j < m_viewControllers.size(); j++)
     {
-        uiTreeOrdering.add(m_viewControllers()[j]);
+        uiTreeOrdering.add(m_viewControllers[j]);
     }
 }
 

ApplicationCode/ProjectDataModel/RimViewLinker.h

@@ -28,6 +28,9 @@
 #include "cafPdmObject.h"
 #include "cafPdmPtrField.h"
 
+#include "cvfBase.h"
+#include "cvfVector3.h"
+
 namespace cvf
 {
     class BoundingBox;
@@ -50,10 +53,10 @@ public:
     RimViewLinker(void);
     virtual ~RimViewLinker(void);
     
-    bool                                    isActive();
+    bool                                    isActive() const;
 
     void                                    setMasterView(RimView* view);
-    RimView*                                masterView();
+    RimView*                                masterView() const;
 
     void                                    addDependentView(RimView* view);
     void                                    updateDependentViews();
@@ -73,15 +76,17 @@ public:
     void                                    scheduleGeometryRegenForDepViews(RivCellSetEnum geometryType);
     void                                    scheduleCreateDisplayModelAndRedrawForDependentViews();
 
-    void                                    allViews(std::vector<RimView*>& views);
+    void                                    allViews(std::vector<RimView*>& views) const;
 
     void                                    updateUiNameAndIcon();
 
-    void                                    addViewControllers(caf::PdmUiTreeOrdering& uiTreeOrdering);
+    void                                    addViewControllers(caf::PdmUiTreeOrdering& uiTreeOrdering) const;
 
     static void                             applyIconEnabledState(caf::PdmObject* obj, const QIcon& icon, bool disable);
     static void                             findNameAndIconFromView(QString* name, QIcon* icon, RimView* view);
 
+    void                                    updateCursorPosition(const RimView* sourceView, const cvf::Vec3d& domainCoord);
+
 public:
     static QString                          displayNameForView(RimView* view);
 
@@ -90,7 +95,7 @@ protected:
     virtual void                            initAfterRead();
 
 private:
-    void                                    allViewsForCameraSync(RimView* source, std::vector<RimView*>& views);
+    void                                    allViewsForCameraSync(const RimView* source, std::vector<RimView*>& views) const;
     
     void                                    removeOverrides();
 

ApplicationCode/ProjectDataModel/RimWellLogExtractionCurve.cpp

@@ -113,6 +113,30 @@ void RimWellLogExtractionCurve::setWellPath(RimWellPath* wellPath)
     m_wellPath = wellPath;
 }
 
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+RimWellPath* RimWellLogExtractionCurve::wellPath() const
+{
+    return m_wellPath;
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RimWellLogExtractionCurve::setCase(RimCase* rimCase)
+{
+    m_case = rimCase;
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+RimCase* RimWellLogExtractionCurve::rimCase() const
+{
+    return m_case;
+}
+
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/ProjectDataModel/RimWellLogExtractionCurve.h

@@ -41,8 +41,12 @@ public:
     RimWellLogExtractionCurve();
     virtual ~RimWellLogExtractionCurve();
     
-    
     void setWellPath(RimWellPath* wellPath);
+    RimWellPath* wellPath() const;
+
+    void setCase(RimCase* rimCase);
+    RimCase* rimCase() const;
+
     void setPropertiesFromView(RimView* view);
 
     virtual QString wellName() const;

ApplicationCode/UserInterface/RiuViewer.cpp

@@ -39,6 +39,7 @@
 
 #include "cafCategoryLegend.h"
 #include "cafCeetronPlusNavigation.h"
+#include "cafDisplayCoordTransform.h"
 #include "cafEffectGenerator.h"
 #include "cafFrameAnimationControl.h"
 
@@ -170,8 +171,9 @@ RiuViewer::RiuViewer(const QGLFormat& format, QWidget* parent)
     setContextMenuPolicy(Qt::PreventContextMenu);
 
     m_gridBoxGenerator = new RivGridBoxGenerator;
-}
 
+    m_cursorPositionDomainCoords = cvf::Vec3d::UNDEFINED;
+}
 
 //--------------------------------------------------------------------------------------------------
 /// 
@@ -408,6 +410,29 @@ void RiuViewer::paintOverlayItems(QPainter* painter)
         m_versionInfoLabel->render(painter, pos);
         yPos +=  size.height() + margin;
     }
+
+    if (!m_cursorPositionDomainCoords.isUndefined())
+    {
+        if (mainCamera())
+        {
+            cvf::ref<caf::DisplayCoordTransform> trans = m_rimView->displayCoordTransform();
+
+            cvf::Vec3d displayCoord = trans->transformToDisplayCoord(m_cursorPositionDomainCoords);
+
+            cvf::Vec3d screenCoords;
+            if (mainCamera()->project(displayCoord, &screenCoords))
+            {
+                int translatedMousePosY = height() - screenCoords.y();
+                QPoint centerPos(screenCoords.x(), translatedMousePosY);
+
+                // Draw a cross hair marker
+                int markerHalfLength = 6;
+
+                painter->drawLine(centerPos.x(), centerPos.y() - markerHalfLength, centerPos.x(), centerPos.y() + markerHalfLength);
+                painter->drawLine(centerPos.x() - markerHalfLength, centerPos.y(), centerPos.x() + markerHalfLength, centerPos.y());
+            }
+        }
+    }
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -658,6 +683,54 @@ void RiuViewer::resizeGL(int width, int height)
     }
 }
 
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RiuViewer::mouseMoveEvent(QMouseEvent* mouseEvent)
+{
+    if (m_rimView)
+    {
+        RimViewLinker* viewLinker = m_rimView->assosiatedViewLinker();
+        if (viewLinker)
+        {
+            int translatedMousePosX = mouseEvent->pos().x();
+            int translatedMousePosY = height() - mouseEvent->pos().y();
+
+            cvf::Vec3d displayCoord(0, 0, 0);
+            if (mainCamera()->unproject(cvf::Vec3d(static_cast<double>(translatedMousePosX), static_cast<double>(translatedMousePosY), 0), &displayCoord))
+            {
+                if (m_cursorPositionDomainCoords != cvf::Vec3d::UNDEFINED)
+                {
+                    // Reset the extra cursor if the view currently is receiving mouse cursor events
+                    // Set undefined and redraw to remove the previously displayed cursor
+                    m_cursorPositionDomainCoords = cvf::Vec3d::UNDEFINED;
+
+                    update();
+                }
+
+                cvf::ref<caf::DisplayCoordTransform> trans = m_rimView->displayCoordTransform();
+                cvf::Vec3d domainCoord = trans->transformToDomainCoord(displayCoord);
+
+                viewLinker->updateCursorPosition(m_rimView, domainCoord);
+            }
+        }
+    }
+
+    caf::Viewer::mouseMoveEvent(mouseEvent);
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RiuViewer::leaveEvent(QEvent *)
+{
+    if (m_rimView && m_rimView->assosiatedViewLinker())
+    {
+        RimViewLinker* viewLinker = m_rimView->assosiatedViewLinker();
+        viewLinker->updateCursorPosition(m_rimView, cvf::Vec3d::UNDEFINED);
+    }
+}
+
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
@@ -755,6 +828,19 @@ void RiuViewer::updateParallelProjectionSettings(RiuViewer* sourceViewer)
     this->updateParallelProjectionCameraPosFromPointOfInterestMove(poi);
 }
 
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RiuViewer::setCursorPosition(const cvf::Vec3d& domainCoord)
+{
+    if (m_cursorPositionDomainCoords != domainCoord)
+    {
+        m_cursorPositionDomainCoords = domainCoord;
+
+        update();
+    }
+}
+
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/UserInterface/RiuViewer.h

@@ -96,6 +96,8 @@ public:
 
     void            updateParallelProjectionSettings(RiuViewer* sourceViewer);
 
+    void            setCursorPosition(const cvf::Vec3d& domainCoord);
+
 public slots:
     virtual void    slotSetCurrentFrame(int frameIndex);
     virtual void    slotEndAnimation();
@@ -103,6 +105,8 @@ public slots:
 protected:
     virtual void    optimizeClippingPlanes();
     virtual void    resizeGL(int width, int height);
+    virtual void    mouseMoveEvent(QMouseEvent* e) override;
+    virtual void    leaveEvent(QEvent *) override;
 
 private:
     void            updateTextAndTickMarkColorForOverlayItems();
@@ -140,5 +144,7 @@ private:
     RiuViewerCommands*          m_viewerCommands;
 
     RivGridBoxGenerator*        m_gridBoxGenerator;
+
+    cvf::Vec3d                  m_cursorPositionDomainCoords;
 };