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

#1929. Remove all parts of summary curve filter which is not needed for backward compatibility

Browse Source
This commit is contained in:
Bjørn Erik Jensen
2017-11-30 11:05:30 +01:00
parent c5cc7ed842
commit 1eb4c4d3e6
17 changed files with 71 additions and 1208 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
ApplicationCode/Application/Tools/RiaImportEclipseCaseTools.cpp
View File

@@ -148,37 +148,10 @@ bool RiaImportEclipseCaseTools::openEclipseCaseShowTimeStepFilterImpl(const QStr
std::vector<caf::PdmObjectHandle*> referringObjects;
existingFileSummaryCase->objectsWithReferringPtrFields(referringObjects);
std::set<RimSummaryCurveFilter*> curveFilters;
for (caf::PdmObjectHandle* objHandle : referringObjects)
{
RimSummaryCurve* summaryCurve = dynamic_cast<RimSummaryCurve*>(objHandle);
if (summaryCurve)
{
//TODO: When removing curve filter functionality, move this to summaryCurveCollection
//loop and update "if (parentCollection)"-block
summaryCurve->setSummaryCaseY(newSumCase);
summaryCurve->updateConnectedEditors();
RimSummaryCurveFilter* parentFilter = nullptr;
summaryCurve->firstAncestorOrThisOfType(parentFilter);
if (parentFilter)
{
curveFilters.insert(parentFilter);
}
}
}
// UI settings of a curve filter is updated based
// on the new case association for the curves in the curve filter
// UI is updated by loadDataAndUpdate()
for (RimSummaryCurveFilter* curveFilter : curveFilters)
{
curveFilter->loadDataAndUpdate();
curveFilter->updateConnectedEditors();
}
for (caf::PdmObjectHandle* objHandle : referringObjects)
{
RimSummaryCurve* summaryCurve = dynamic_cast<RimSummaryCurve*>(objHandle);

4
ApplicationCode/Commands/OperationsUsingObjReferences/RicCopyReferencesToClipboardFeature.cpp
View File

@@ -144,10 +144,6 @@ bool RicCopyReferencesToClipboardFeature::isCopyOfObjectSupported(caf::PdmObject
{
if(!rftPlot) return true;
}
else if (dynamic_cast<RimSummaryCurveFilter*>(pdmObject))
{
return true;
}
else if (dynamic_cast<RimWellLogTrack*>(pdmObject))
{
if (!wellAllocPlot && !rftPlot) return true;

1
ApplicationCode/Commands/RicDeleteItemFeature.cpp
View File

@@ -105,7 +105,6 @@ bool isDeletable(caf::PdmUiItem* uiItem)
if (dynamic_cast<RimSummaryPlot*>(uiItem)) return true;
if (dynamic_cast<RimSummaryCurve*>(uiItem)) return true;
if (dynamic_cast<RimGridTimeHistoryCurve*>(uiItem)) return true;
if (dynamic_cast<RimSummaryCurveFilter*>(uiItem)) return true;
if (dynamic_cast<RimIntersection*>(uiItem)) return true;
if (dynamic_cast<RimIntersectionBox*>(uiItem)) return true;
if (dynamic_cast<RimFormationNames*>(uiItem)) return true;

2
ApplicationCode/Commands/SummaryPlotCommands/CMakeLists_files.cmake
View File

@@ -9,7 +9,6 @@ set (SOURCE_GROUP_HEADER_FILES
${CEE_CURRENT_LIST_DIR}RicNewSummaryPlotFeature.h
${CEE_CURRENT_LIST_DIR}RicNewSummaryCrossPlotFeature.h
${CEE_CURRENT_LIST_DIR}RicNewSummaryCurveFeature.h
${CEE_CURRENT_LIST_DIR}RicNewSummaryCurveFilterFeature.h
${CEE_CURRENT_LIST_DIR}RicPasteAsciiDataToSummaryPlotFeature.h
${CEE_CURRENT_LIST_DIR}RicPasteAsciiDataToSummaryPlotFeatureUi.h
${CEE_CURRENT_LIST_DIR}RicViewZoomAllFeature.h
@@ -39,7 +38,6 @@ set (SOURCE_GROUP_SOURCE_FILES
${CEE_CURRENT_LIST_DIR}RicNewSummaryPlotFeature.cpp
${CEE_CURRENT_LIST_DIR}RicNewSummaryCrossPlotFeature.cpp
${CEE_CURRENT_LIST_DIR}RicNewSummaryCurveFeature.cpp
${CEE_CURRENT_LIST_DIR}RicNewSummaryCurveFilterFeature.cpp
${CEE_CURRENT_LIST_DIR}RicPasteAsciiDataToSummaryPlotFeature.cpp
${CEE_CURRENT_LIST_DIR}RicPasteAsciiDataToSummaryPlotFeatureUi.cpp
${CEE_CURRENT_LIST_DIR}RicViewZoomAllFeature.cpp

93
ApplicationCode/Commands/SummaryPlotCommands/RicNewSummaryCurveFilterFeature.cpp
View File

@@ -1,93 +0,0 @@
/////////////////////////////////////////////////////////////////////////////////
//
// 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 "RicNewSummaryCurveFilterFeature.h"
#include "RiaApplication.h"
#include "RiaSummaryTools.h"
#include "RimMainPlotCollection.h"
#include "RimOilField.h"
#include "RimProject.h"
#include "RimSummaryCurve.h"
#include "RimSummaryCurveFilter.h"
#include "RimSummaryPlot.h"
#include "RimSummaryPlotCollection.h"
#include "RiuMainPlotWindow.h"
#include "WellLogCommands/RicWellLogPlotCurveFeatureImpl.h"
#include "cafSelectionManager.h"
#include "cvfAssert.h"
#include <QAction>
CAF_CMD_SOURCE_INIT(RicNewSummaryCurveFilterFeature, "RicNewSummaryCurveFilterFeature");
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RicNewSummaryCurveFilterFeature::isCommandEnabled()
{
return (selectedSummaryPlot());
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicNewSummaryCurveFilterFeature::onActionTriggered(bool isChecked)
{
RimProject* project = RiaApplication::instance()->project();
CVF_ASSERT(project);
RimSummaryPlot* plot = selectedSummaryPlot();
if (plot)
{
RimSummaryCurveFilter* newCurveFilter = new RimSummaryCurveFilter();
plot->addCurveFilter(newCurveFilter);
plot->updateConnectedEditors();
RiaApplication::instance()->getOrCreateAndShowMainPlotWindow()->selectAsCurrentItem(newCurveFilter);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicNewSummaryCurveFilterFeature::setupActionLook(QAction* actionToSetup)
{
actionToSetup->setText("New Summary Curve Filter");
actionToSetup->setIcon(QIcon(":/SummaryCurveFilter16x16.png"));
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimSummaryPlot* RicNewSummaryCurveFilterFeature::selectedSummaryPlot() const
{
caf::PdmObject* selObj = dynamic_cast<caf::PdmObject*>(caf::SelectionManager::instance()->selectedItem());
RimSummaryPlot * sumPlot;
selObj->firstAncestorOrThisOfType(sumPlot);
return sumPlot;
}

41
ApplicationCode/Commands/SummaryPlotCommands/RicNewSummaryCurveFilterFeature.h
View File

@@ -1,41 +0,0 @@
/////////////////////////////////////////////////////////////////////////////////
//
// 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 RimSummaryPlot;
//==================================================================================================
///
//==================================================================================================
class RicNewSummaryCurveFilterFeature : public caf::CmdFeature
{
CAF_CMD_HEADER_INIT;
protected:
// Overrides
virtual bool isCommandEnabled();
virtual void onActionTriggered( bool isChecked );
virtual void setupActionLook( QAction* actionToSetup );
private:
RimSummaryPlot* selectedSummaryPlot() const;
};

81
ApplicationCode/Commands/SummaryPlotCommands/RicPasteSummaryCurveFeature.cpp
View File

@@ -115,84 +115,3 @@ std::vector<caf::PdmPointer<RimSummaryCurve> > RicPasteSummaryCurveFeature::summ
return typedObjects;
}
CAF_CMD_SOURCE_INIT(RicPasteSummaryCurveFilterFeature, "RicPasteSummaryCurveFilterFeature");
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RicPasteSummaryCurveFilterFeature::isCommandEnabled()
{
caf::PdmObjectHandle* destinationObject = dynamic_cast<caf::PdmObjectHandle*>(caf::SelectionManager::instance()->selectedItem());
RimSummaryPlot* summaryPlot = nullptr;
destinationObject->firstAncestorOrThisOfType(summaryPlot);
if (!summaryPlot)
{
return false;
}
return RicPasteSummaryCurveFilterFeature::summaryCurveFilters().size() > 0;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicPasteSummaryCurveFilterFeature::onActionTriggered(bool isChecked)
{
caf::PdmObjectHandle* destinationObject = dynamic_cast<caf::PdmObjectHandle*>(caf::SelectionManager::instance()->selectedItem());
RimSummaryPlot* summaryPlot = nullptr;
destinationObject->firstAncestorOrThisOfType(summaryPlot);
if (!summaryPlot)
{
return;
}
std::vector<caf::PdmPointer<RimSummaryCurveFilter> > sourceObjects = RicPasteSummaryCurveFilterFeature::summaryCurveFilters();
for (size_t i = 0; i < sourceObjects.size(); i++)
{
RimSummaryCurveFilter* newObject = dynamic_cast<RimSummaryCurveFilter*>(sourceObjects[i]->xmlCapability()->copyByXmlSerialization(caf::PdmDefaultObjectFactory::instance()));
CVF_ASSERT(newObject);
summaryPlot->addCurveFilter(newObject);
// Resolve references after object has been inserted into the project data model
newObject->resolveReferencesRecursively();
newObject->initAfterReadRecursively();
newObject->loadDataAndUpdate();
newObject->updateConnectedEditors();
summaryPlot->updateConnectedEditors();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicPasteSummaryCurveFilterFeature::setupActionLook(QAction* actionToSetup)
{
actionToSetup->setText("Paste Summary Curve Filter");
RicPasteFeatureImpl::setIconAndShortcuts(actionToSetup);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<caf::PdmPointer<RimSummaryCurveFilter> > RicPasteSummaryCurveFilterFeature::summaryCurveFilters()
{
caf::PdmObjectGroup objectGroup;
RicPasteFeatureImpl::findObjectsFromClipboardRefs(&objectGroup);
std::vector<caf::PdmPointer<RimSummaryCurveFilter> > typedObjects;
objectGroup.objectsByType(&typedObjects);
return typedObjects;
}

18
ApplicationCode/Commands/SummaryPlotCommands/RicPasteSummaryCurveFeature.h
View File

@@ -42,21 +42,3 @@ protected:
private:
static std::vector<caf::PdmPointer<RimSummaryCurve> > summaryCurves();
};
//==================================================================================================
///
//==================================================================================================
class RicPasteSummaryCurveFilterFeature : public caf::CmdFeature
{
CAF_CMD_HEADER_INIT;
protected:
// Overrides
virtual bool isCommandEnabled() override;
virtual void onActionTriggered(bool isChecked) override;
virtual void setupActionLook(QAction* actionToSetup) override;
private:
static std::vector<caf::PdmPointer<RimSummaryCurveFilter> > summaryCurveFilters();
};

126
ApplicationCode/Commands/SummaryPlotCommands/RicSummaryCurveSwitchAxisFeature.cpp
View File

@@ -35,16 +35,10 @@ CAF_CMD_SOURCE_INIT(RicSummaryCurveSwitchAxisFeature, "RicSummaryCurveSwitchAxis
//--------------------------------------------------------------------------------------------------
bool RicSummaryCurveSwitchAxisFeature::isCommandEnabled()
{
std::set<RimSummaryCurveFilter*> selectedCurveFilters;
std::set<RimSummaryCurve*> selectedSoloCurves;
std::vector<RimGridTimeHistoryCurve*> gridTimeHistoryCurves;
RicSummaryCurveSwitchAxisFeature::extractSelectedCurveFiltersAndSoloCurves(&selectedCurveFilters,
&selectedSoloCurves,
&gridTimeHistoryCurves);
return ( selectedCurveFilters.size()
|| selectedSoloCurves.size()
|| gridTimeHistoryCurves.size());
RicSummaryCurveSwitchAxisFeature::extractSelectedCurveFiltersAndSoloCurves(&gridTimeHistoryCurves);
return (gridTimeHistoryCurves.size());
}
//--------------------------------------------------------------------------------------------------
@@ -52,50 +46,46 @@ bool RicSummaryCurveSwitchAxisFeature::isCommandEnabled()
//--------------------------------------------------------------------------------------------------
void RicSummaryCurveSwitchAxisFeature::onActionTriggered(bool isChecked)
{
std::set<RimSummaryCurveFilter*> selectedCurveFilters;
std::set<RimSummaryCurve*> selectedSoloCurves;
std::vector<RimGridTimeHistoryCurve*> gridTimeHistoryCurves;
RicSummaryCurveSwitchAxisFeature::extractSelectedCurveFiltersAndSoloCurves(&selectedCurveFilters,
&selectedSoloCurves,
&gridTimeHistoryCurves);
RicSummaryCurveSwitchAxisFeature::extractSelectedCurveFiltersAndSoloCurves(&gridTimeHistoryCurves);
for (RimSummaryCurveFilter* summaryCurveFilter: selectedCurveFilters)
{
RiaDefines::PlotAxis plotAxis = summaryCurveFilter->associatedPlotAxis();
//for (RimSummaryCurveFilter* summaryCurveFilter: selectedCurveFilters)
//{
// RiaDefines::PlotAxis plotAxis = summaryCurveFilter->associatedPlotAxis();
if ( plotAxis == RiaDefines::PLOT_AXIS_LEFT )
{
summaryCurveFilter->setPlotAxis(RiaDefines::PLOT_AXIS_RIGHT);
}
else
{
summaryCurveFilter->setPlotAxis(RiaDefines::PLOT_AXIS_LEFT);
}
// if ( plotAxis == RiaDefines::PLOT_AXIS_LEFT )
// {
// summaryCurveFilter->setPlotAxis(RiaDefines::PLOT_AXIS_RIGHT);
// }
// else
// {
// summaryCurveFilter->setPlotAxis(RiaDefines::PLOT_AXIS_LEFT);
// }
summaryCurveFilter->updateConnectedEditors();
}
// summaryCurveFilter->updateConnectedEditors();
//}
for (RimSummaryCurve* summaryCurve : selectedSoloCurves)
{
RiaDefines::PlotAxis plotAxis = summaryCurve->axisY();
//for (RimSummaryCurve* summaryCurve : selectedSoloCurves)
//{
// RiaDefines::PlotAxis plotAxis = summaryCurve->axisY();
if ( plotAxis == RiaDefines::PLOT_AXIS_LEFT )
{
summaryCurve->setLeftOrRightAxisY(RiaDefines::PLOT_AXIS_RIGHT);
}
else
{
summaryCurve->setLeftOrRightAxisY(RiaDefines::PLOT_AXIS_LEFT);
}
// if ( plotAxis == RiaDefines::PLOT_AXIS_LEFT )
// {
// summaryCurve->setLeftOrRightAxisY(RiaDefines::PLOT_AXIS_RIGHT);
// }
// else
// {
// summaryCurve->setLeftOrRightAxisY(RiaDefines::PLOT_AXIS_LEFT);
// }
summaryCurve->updateQwtPlotAxis();
summaryCurve->updateConnectedEditors();
// summaryCurve->updateQwtPlotAxis();
// summaryCurve->updateConnectedEditors();
RimSummaryPlot* plot = nullptr;
summaryCurve->firstAncestorOrThisOfType(plot);
if ( plot ) plot->updateAxes();
}
// RimSummaryPlot* plot = nullptr;
// summaryCurve->firstAncestorOrThisOfType(plot);
// if ( plot ) plot->updateAxes();
//}
for (RimGridTimeHistoryCurve* timeHistoryCurve : gridTimeHistoryCurves)
{
@@ -129,34 +119,32 @@ void RicSummaryCurveSwitchAxisFeature::setupActionLook(QAction* actionToSetup)
//--------------------------------------------------------------------------------------------------
/// Solo curves means selected curves that does not have a selected curve filter as parent
//--------------------------------------------------------------------------------------------------
void RicSummaryCurveSwitchAxisFeature::extractSelectedCurveFiltersAndSoloCurves(std::set<RimSummaryCurveFilter*>* selectedCurveFilters,
std::set<RimSummaryCurve*>* selectedSoloCurves,
std::vector<RimGridTimeHistoryCurve*>* gridTimeHistoryCurves)
void RicSummaryCurveSwitchAxisFeature::extractSelectedCurveFiltersAndSoloCurves(std::vector<RimGridTimeHistoryCurve*>* gridTimeHistoryCurves)
{
selectedSoloCurves->clear();
{
std::vector<RimSummaryCurve*> selection;
caf::SelectionManager::instance()->objectsByType(&selection);
for (RimSummaryCurve* curve : selection)
{
RimSummaryCurveFilter* parentCurveFilter = nullptr;
curve->firstAncestorOrThisOfType(parentCurveFilter);
if (!parentCurveFilter)
{
selectedSoloCurves->insert(curve);
}
}
}
//selectedSoloCurves->clear();
//{
// std::vector<RimSummaryCurve*> selection;
// caf::SelectionManager::instance()->objectsByType(&selection);
// for (RimSummaryCurve* curve : selection)
// {
// RimSummaryCurveFilter* parentCurveFilter = nullptr;
// curve->firstAncestorOrThisOfType(parentCurveFilter);
// if (!parentCurveFilter)
// {
// selectedSoloCurves->insert(curve);
// }
// }
//}
selectedCurveFilters->clear();
{
std::vector<RimSummaryCurveFilter*> selection;
caf::SelectionManager::instance()->objectsByType(&selection);
for (RimSummaryCurveFilter* curveFilter : selection)
{
selectedCurveFilters->insert(curveFilter);
}
}
//selectedCurveFilters->clear();
//{
// std::vector<RimSummaryCurveFilter*> selection;
// caf::SelectionManager::instance()->objectsByType(&selection);
// for (RimSummaryCurveFilter* curveFilter : selection)
// {
// selectedCurveFilters->insert(curveFilter);
// }
//}
// Read out all time history curves directly from selection manager
caf::SelectionManager::instance()->objectsByType(gridTimeHistoryCurves);

4
ApplicationCode/Commands/SummaryPlotCommands/RicSummaryCurveSwitchAxisFeature.h
View File

@@ -40,7 +40,5 @@ protected:
virtual void setupActionLook( QAction* actionToSetup ) override;
private:
static void extractSelectedCurveFiltersAndSoloCurves(std::set<RimSummaryCurveFilter*>* selectedCurveFilters,
std::set<RimSummaryCurve*>* selectedSoloCurves,
std::vector<RimGridTimeHistoryCurve*>* gridTimeHistoryCurves);
static void extractSelectedCurveFiltersAndSoloCurves(std::vector<RimGridTimeHistoryCurve*>* gridTimeHistoryCurves);
};

10
ApplicationCode/ProjectDataModel/RimContextCommandBuilder.cpp
View File

@@ -57,7 +57,6 @@
#include "RimSummaryCrossPlotCollection.h"
#include "RimSummaryCurve.h"
#include "RimSummaryCurveCollection.h"
#include "RimSummaryCurveFilter.h"
#include "RimSummaryPlot.h"
#include "RimSummaryPlotCollection.h"
#include "RimViewController.h"
@@ -356,7 +355,6 @@ caf::CmdFeatureMenuBuilder RimContextCommandBuilder::commandsFromSelection()
else if (dynamic_cast<RimSummaryPlot*>(uiItem)) // This is also the definition for RimSummaryCrossPlot
{
menuBuilder << "RicPasteSummaryCurveFeature";
menuBuilder << "RicPasteSummaryCurveFilterFeature";
menuBuilder << "RicPasteSummaryPlotFeature";
menuBuilder << "RicPasteAsciiDataToSummaryPlotFeature";
menuBuilder << "Separator";
@@ -390,14 +388,6 @@ caf::CmdFeatureMenuBuilder RimContextCommandBuilder::commandsFromSelection()
menuBuilder << "RicNewSummaryCurveFeature";
menuBuilder << "RicNewSummaryCrossPlotCurveFeature";
}
else if(dynamic_cast<RimSummaryCurveFilter*>(uiItem))
{
menuBuilder << "RicPasteSummaryCurveFilterFeature";
menuBuilder << "Separator";
menuBuilder << "RicNewSummaryCurveFeature";
menuBuilder << "Separator";
menuBuilder << "RicCopyReferencesToClipboardFeature";
}
else if (dynamic_cast<RimSummaryCase*>(uiItem))
{
if (!dynamic_cast<RimObservedData*>(uiItem))

5
ApplicationCode/ProjectDataModel/RimPlotCurve.cpp
View File

@@ -183,11 +183,6 @@ caf::PdmFieldHandle* RimPlotCurve::objectToggleField()
void RimPlotCurve::updateCurveVisibility()
{
bool isVisibleInPossibleParent = true;
{
RimSummaryCurveFilter* cFilter = nullptr;
this->firstAncestorOrThisOfType(cFilter);
if(cFilter) isVisibleInPossibleParent = cFilter->isCurvesVisible();
}
{
RimSummaryCurveCollection* summaryCurveCollection = nullptr;

634
ApplicationCode/ProjectDataModel/Summary/RimSummaryCurveFilter.cpp
View File

@@ -18,27 +18,10 @@
#include "RimSummaryCurveFilter.h"
#include "RiaApplication.h"
#include "RiaSummaryCurveDefinition.h"
#include "RifReaderEclipseSummary.h"
#include "RiaDefines.h"
#include "RimEclipseResultCase.h"
#include "RimProject.h"
#include "RimSummaryCase.h"
#include "RimSummaryCurve.h"
#include "RimSummaryCurveAppearanceCalculator.h"
#include "RimSummaryCurveAutoName.h"
#include "RimSummaryFilter.h"
#include "RimSummaryPlot.h"
#include "RimSummaryPlotCollection.h"
#include "RiuLineSegmentQwtPlotCurve.h"
#include "RiuSummaryQwtPlot.h"
#include "WellLogCommands/RicWellLogPlotCurveFeatureImpl.h"
#include "cafPdmUiListEditor.h"
#include "cafPdmUiPushButtonEditor.h"
@@ -57,12 +40,12 @@ QTextStream& operator >> (QTextStream& str, std::vector<RifEclipseSummaryAddress
}
CAF_PDM_SOURCE_INIT(RimSummaryCurveFilter, "SummaryCurveFilter");
CAF_PDM_SOURCE_INIT(RimSummaryCurveFilter_OBSOLETE, "SummaryCurveFilter");
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimSummaryCurveFilter::RimSummaryCurveFilter()
RimSummaryCurveFilter_OBSOLETE::RimSummaryCurveFilter_OBSOLETE()
{
CAF_PDM_InitObject("Curve Filter", ":/SummaryCurveFilter16x16.png", "", "");
@@ -124,365 +107,15 @@ RimSummaryCurveFilter::RimSummaryCurveFilter()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimSummaryCurveFilter::~RimSummaryCurveFilter()
RimSummaryCurveFilter_OBSOLETE::~RimSummaryCurveFilter_OBSOLETE()
{
m_curves.deleteAllChildObjects();
}
//--------------------------------------------------------------------------------------------------d
///
//--------------------------------------------------------------------------------------------------
void RimSummaryCurveFilter::createDefaultCurves(RimSummaryCase* summaryCase, const QString& defaultCurveStringFilter)
{
if (summaryCase)
{
std::vector<RimSummaryCase*> selectedCases;
selectedCases.push_back(summaryCase);
m_summaryFilter->setCompleteVarStringFilter(defaultCurveStringFilter);
std::set<RiaSummaryCurveDefinition> newCurveDefinitions;
createSetOfCasesAndResultAdresses(selectedCases, *m_summaryFilter, &newCurveDefinitions);
createCurvesFromCurveDefinitions(newCurveDefinitions);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QList<caf::PdmOptionItemInfo> RimSummaryCurveFilter::calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool* useOptionsOnly)
{
QList<caf::PdmOptionItemInfo> options;
if (fieldNeedingOptions == &m_selectedSummaryCases)
{
RimProject* proj = RiaApplication::instance()->project();
std::vector<RimSummaryCase*> cases;
proj->allSummaryCases(cases);
for (RimSummaryCase* rimCase : cases)
{
options.push_back(caf::PdmOptionItemInfo(rimCase->caseName(), rimCase));
}
}
else if(fieldNeedingOptions == &m_uiFilterResultMultiSelection)
{
std::set<RifEclipseSummaryAddress> addrUnion = findPossibleSummaryAddresses();
for(const auto& address: addrUnion)
{
std::string name = address.uiText();
QString s = QString::fromStdString(name);
options.push_back(caf::PdmOptionItemInfo(s, QVariant::fromValue(address)));
}
}
if(useOptionsOnly) *useOptionsOnly = true;
return options;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryCurveFilter::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
{
caf::PdmUiGroup* curveDataGroup = uiOrdering.addNewGroup("Cases");
curveDataGroup->add(&m_selectedSummaryCases);
caf::PdmUiGroup* curveVarSelectionGroup = uiOrdering.addNewGroup("Vector Selection");
m_summaryFilter->uiOrdering(uiConfigName, *curveVarSelectionGroup);
curveVarSelectionGroup->add(&m_uiFilterResultMultiSelection);
uiOrdering.add(&m_plotAxis);
caf::PdmUiGroup* appearanceGroup = uiOrdering.addNewGroup("Appearance Settings");
appearanceGroup->setCollapsedByDefault(true);
appearanceGroup->add(&m_useAutoAppearanceAssignment);
appearanceGroup->add(&m_caseAppearanceType);
appearanceGroup->add(&m_variableAppearanceType);
appearanceGroup->add(&m_wellAppearanceType);
appearanceGroup->add(&m_groupAppearanceType);
appearanceGroup->add(&m_regionAppearanceType);
// Appearance option sensitivity
{
m_caseAppearanceType.uiCapability()->setUiReadOnly(m_useAutoAppearanceAssignment);
m_variableAppearanceType.uiCapability()->setUiReadOnly(m_useAutoAppearanceAssignment);
m_wellAppearanceType.uiCapability()->setUiReadOnly(m_useAutoAppearanceAssignment);
m_groupAppearanceType.uiCapability()->setUiReadOnly(m_useAutoAppearanceAssignment);
m_regionAppearanceType.uiCapability()->setUiReadOnly(m_useAutoAppearanceAssignment);
}
caf::PdmUiGroup* autoNameGroup = uiOrdering.addNewGroup("Curve Name Configuration");
autoNameGroup->setCollapsedByDefault(true);
autoNameGroup->add(&m_showLegend);
m_curveNameConfig->uiOrdering(uiConfigName, *autoNameGroup);
uiOrdering.add(&m_autoApplyChangesToPlot);
uiOrdering.add(&m_applyButtonField);
m_applyButtonField.uiCapability()->setUiReadOnly(m_autoApplyChangesToPlot());
uiOrdering.skipRemainingFields(true);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryCurveFilter::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue)
{
bool plotNeedsRedraw = false;
if (changedField == &m_uiFilterResultMultiSelection)
{
plotNeedsRedraw = true;
}
else if (changedField == &m_applyButtonField)
{
m_applyButtonField = false;
loadDataAndUpdatePlot();
}
else if (changedField == &m_showCurves)
{
for(RimSummaryCurve* curve : m_curves)
{
curve->updateCurveVisibility();
}
updatePlotAxisForCurves();
}
else if (changedField == &m_plotAxis)
{
updatePlotAxisForCurves();
}
else if (changedField == &m_selectedSummaryCases)
{
if (newValue.toList().size() < 1)
{
if (m_selectionCache.size() > 0)
{
m_selectedSummaryCases.setValue(m_selectionCache);
}
}
else
{
m_selectionCache = m_selectedSummaryCases.value();
}
plotNeedsRedraw = true;
}
else if (changedField == &m_showLegend)
{
for (auto curve : m_curves)
{
curve->showLegend(m_showLegend());
}
m_parentQwtPlot->updateLegend();
}
else
{
plotNeedsRedraw = true;
}
if (plotNeedsRedraw)
{
if (m_autoApplyChangesToPlot)
{
loadDataAndUpdatePlot();
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryCurveFilter::loadDataAndUpdatePlot()
{
syncCurvesFromUiSelection();
loadDataAndUpdate();
RimSummaryPlot* plot = nullptr;
firstAncestorOrThisOfType(plot);
plot->updateAxes();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryCurveFilter::setParentQwtPlotAndReplot(QwtPlot* plot)
{
m_parentQwtPlot = plot;
for (RimSummaryCurve* curve : m_curves)
{
curve->setParentQwtPlotNoReplot(plot);
}
if (plot) plot->replot();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryCurveFilter::detachQwtCurves()
{
for(RimSummaryCurve* curve : m_curves)
{
curve->detachQwtCurve();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimSummaryCurve* RimSummaryCurveFilter::findRimCurveFromQwtCurve(const QwtPlotCurve* qwtCurve) const
{
for(RimSummaryCurve* rimCurve: m_curves)
{
if(rimCurve->qwtPlotCurve() == qwtCurve)
{
return rimCurve;
}
}
return NULL;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryCurveFilter::syncCurvesFromUiSelection()
{
// Create a search map containing whats supposed to be curves
std::set<RiaSummaryCurveDefinition> newCurveDefinitions;
// Populate the newCurveDefinitions from the Gui
std::set<RifEclipseSummaryAddress> addrUnion = findPossibleSummaryAddresses();
for (RimSummaryCase* currentCase: m_selectedSummaryCases)
{
if (!currentCase || !currentCase->summaryReader()) continue;
RifSummaryReaderInterface* reader = currentCase->summaryReader();
for(const RifEclipseSummaryAddress& addr: m_uiFilterResultMultiSelection.v())
{
if(!reader->hasAddress(addr)) continue;
if (addrUnion.count(addr) == 0 ) continue; // Wash the possible "old" ui selection with new filter
newCurveDefinitions.insert(RiaSummaryCurveDefinition(currentCase, addr));
}
}
m_curves.deleteAllChildObjects();
createCurvesFromCurveDefinitions(newCurveDefinitions);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryCurveFilter::syncUiSelectionFromCurves()
{
// Create a search map containing whats supposed to be uiSelected
std::set<RimSummaryCase*> referredCases;
std::set<RifEclipseSummaryAddress> existingCurveDefinitions;
// Populate the existingCurveDefinitions from the existing curves
for(RimSummaryCurve* curve: m_curves)
{
existingCurveDefinitions.insert(curve->summaryAddressY());
referredCases.insert(curve->summaryCaseY());
}
if (m_curves.size()) // Only sync the selected cases if we actually have some curves. To avoid user getting an empty variable list accidentally
{
m_selectedSummaryCases.clear();
for(RimSummaryCase* currCase: referredCases)
{
m_selectedSummaryCases.push_back(currCase);
}
}
m_uiFilterResultMultiSelection.v().clear();
for(const RifEclipseSummaryAddress& addr: existingCurveDefinitions)
{
m_uiFilterResultMultiSelection.v().push_back(addr);
}
updateConnectedEditors();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryCurveFilter::defineEditorAttribute(const caf::PdmFieldHandle* field, QString uiConfigName, caf::PdmUiEditorAttribute * attribute)
{
if(&m_applyButtonField == field)
{
caf::PdmUiPushButtonEditorAttribute* attrib = dynamic_cast<caf::PdmUiPushButtonEditorAttribute*> (attribute);
if (attrib)
{
attrib->m_buttonText = "Apply";
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryCurveFilter::updatePlotAxisForCurves()
{
for (RimSummaryCurve* curve : m_curves)
{
curve->setLeftOrRightAxisY(m_plotAxis());
curve->updateQwtPlotAxis();
}
RimSummaryPlot* plot = nullptr;
firstAncestorOrThisOfType(plot);
if (plot)
{
plot->updateAxes();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryCurveFilter::loadDataAndUpdate()
{
for (RimSummaryCurve* curve: m_curves)
{
curve->loadDataAndUpdate(true);
}
syncUiSelectionFromCurves();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::set<std::string> RimSummaryCurveFilter::unitNames()
{
std::set<std::string> unitNames;
for(RimSummaryCurve* curve: m_curves)
{
if (curve->isCurveVisible()) unitNames.insert( curve->unitNameY());
}
return unitNames;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimSummaryCurve*> RimSummaryCurveFilter::curves()
std::vector<RimSummaryCurve*> RimSummaryCurveFilter_OBSOLETE::curves()
{
std::vector<RimSummaryCurve*> myCurves;
for ( RimSummaryCurve* curve: m_curves)
@@ -496,264 +129,7 @@ std::vector<RimSummaryCurve*> RimSummaryCurveFilter::curves()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryCurveFilter::removeCurvesAssosiatedWithCase(RimSummaryCase* summaryCase)
{
std::vector<RimSummaryCurve*> summaryCurvesToDelete;
for (RimSummaryCurve* summaryCurve : m_curves)
{
if (!summaryCurve) continue;
if (!summaryCurve->summaryCaseY()) continue;
if (summaryCurve->summaryCaseY() == summaryCase)
{
summaryCurvesToDelete.push_back(summaryCurve);
}
}
for (RimSummaryCurve* summaryCurve : summaryCurvesToDelete)
{
m_curves.removeChildObject(summaryCurve);
delete summaryCurve;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryCurveFilter::createSetOfCasesAndResultAdresses(
const std::vector<RimSummaryCase*>& cases,
const RimSummaryFilter& filter,
std::set<RiaSummaryCurveDefinition>* curveDefinitions) const
{
for (RimSummaryCase* currentCase : cases)
{
if (!currentCase || !currentCase->summaryReader()) continue;
RifSummaryReaderInterface* reader = currentCase->summaryReader();
const std::vector<RifEclipseSummaryAddress> allAddresses = reader->allResultAddresses();
int addressCount = static_cast<int>(allAddresses.size());
for (int i = 0; i < addressCount; i++)
{
if (!filter.isIncludedByFilter(allAddresses[i])) continue;
curveDefinitions->insert(RiaSummaryCurveDefinition(currentCase, allAddresses[i]));
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryCurveFilter::createCurvesFromCurveDefinitions(const std::set<RiaSummaryCurveDefinition>& curveDefinitions)
{
RimSummaryCase* prevCase = nullptr;
RimPlotCurve::LineStyleEnum lineStyle = RimPlotCurve::STYLE_SOLID;
RimSummaryCurveAppearanceCalculator curveLookCalc(curveDefinitions, getAllSummaryCaseNames(), getAllSummaryWellNames());
if (!m_useAutoAppearanceAssignment())
{
curveLookCalc.assignDimensions( m_caseAppearanceType(),
m_variableAppearanceType(),
m_wellAppearanceType(),
m_groupAppearanceType(),
m_regionAppearanceType());
}
else
{
RimSummaryCurveAppearanceCalculator::CurveAppearanceType caseAppearance;
RimSummaryCurveAppearanceCalculator::CurveAppearanceType variAppearance;
RimSummaryCurveAppearanceCalculator::CurveAppearanceType wellAppearance;
RimSummaryCurveAppearanceCalculator::CurveAppearanceType gropAppearance;
RimSummaryCurveAppearanceCalculator::CurveAppearanceType regiAppearance;
curveLookCalc.getDimensions(&caseAppearance,
&variAppearance,
&wellAppearance,
&gropAppearance,
&regiAppearance);
m_caseAppearanceType = caseAppearance;
m_variableAppearanceType = variAppearance;
m_wellAppearanceType = wellAppearance;
m_groupAppearanceType = gropAppearance;
m_regionAppearanceType = regiAppearance;
}
for (auto& caseAddrPair : curveDefinitions)
{
RimSummaryCase* currentCase = caseAddrPair.summaryCase();
RimSummaryCurve* curve = new RimSummaryCurve();
curve->setParentQwtPlotNoReplot(m_parentQwtPlot);
curve->setSummaryCaseY(currentCase);
curve->setSummaryAddressY(caseAddrPair.summaryAddress());
curve->setLeftOrRightAxisY(m_plotAxis());
curve->applyCurveAutoNameSettings(*m_curveNameConfig());
m_curves.push_back(curve);
curveLookCalc.setupCurveLook(curve);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryCurveFilter::updateCaseNameHasChanged()
{
for (RimSummaryCurve* curve : m_curves)
{
curve->updateCurveNameAndUpdatePlotLegend();
curve->updateConnectedEditors();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaDefines::PlotAxis RimSummaryCurveFilter::associatedPlotAxis() const
{
return m_plotAxis();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryCurveFilter::setPlotAxis(RiaDefines::PlotAxis plotAxis)
{
m_plotAxis = plotAxis;
updateConnectedEditors();
updatePlotAxisForCurves();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryCurveFilter::updateCompleteVariableStringFilterChanged()
{
if (m_autoApplyChangesToPlot)
{
loadDataAndUpdatePlot();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryCurveFilter::updateCurveNames()
{
for (RimSummaryCurve* curve : m_curves)
{
curve->applyCurveAutoNameSettings(*m_curveNameConfig());
curve->updateCurveNameAndUpdatePlotLegend();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryCurveFilter::clearCurvesWithoutDelete()
void RimSummaryCurveFilter_OBSOLETE::clearCurvesWithoutDelete()
{
m_curves.clear();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimSummaryCurveFilter::isCurvesVisible()
{
return m_showCurves();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
caf::PdmFieldHandle* RimSummaryCurveFilter::objectToggleField()
{
return &m_showCurves;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::set<RifEclipseSummaryAddress> RimSummaryCurveFilter::findPossibleSummaryAddresses()
{
std::set<RifEclipseSummaryAddress> addrUnion;
for(RimSummaryCase* currCase: m_selectedSummaryCases)
{
RifSummaryReaderInterface* reader = nullptr;
if(currCase) reader = currCase->summaryReader();
if(reader)
{
const std::vector<RifEclipseSummaryAddress> allAddresses = reader->allResultAddresses();
int addressCount = static_cast<int>(allAddresses.size());
for(int i = 0; i <addressCount; i++)
{
if(!m_summaryFilter->isIncludedByFilter(allAddresses[i])) continue;
addrUnion.insert(allAddresses[i]);
}
}
}
return addrUnion;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::set<std::string> RimSummaryCurveFilter::getAllSummaryCaseNames()
{
std::set<std::string> summaryCaseHashes;
RimProject* proj = RiaApplication::instance()->project();
std::vector<RimSummaryCase*> cases;
proj->allSummaryCases(cases);
for (RimSummaryCase* rimCase : cases)
{
summaryCaseHashes.insert(rimCase->summaryHeaderFilename().toUtf8().constData());
}
return summaryCaseHashes;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::set<std::string> RimSummaryCurveFilter::getAllSummaryWellNames()
{
std::set<std::string> summaryWellNames;
RimProject* proj = RiaApplication::instance()->project();
std::vector<RimSummaryCase*> cases;
proj->allSummaryCases(cases);
for (RimSummaryCase* rimCase : cases)
{
RifSummaryReaderInterface* reader = nullptr;
if (rimCase)
{
reader = rimCase->summaryReader();
}
if (reader)
{
const std::vector<RifEclipseSummaryAddress> allAddresses = reader->allResultAddresses();
for (size_t i = 0; i < allAddresses.size(); i++)
{
if (allAddresses[i].category() == RifEclipseSummaryAddress::SUMMARY_WELL)
{
summaryWellNames.insert(allAddresses[i].wellName());
}
}
}
}
return summaryWellNames;
}

60
ApplicationCode/ProjectDataModel/Summary/RimSummaryCurveFilter.h
View File

@@ -33,78 +33,26 @@
#include "RiaDefines.h"
#include "RimSummaryCurveAppearanceCalculator.h"
class QwtPlot;
class QwtPlotCurve;
class RifReaderEclipseSummary;
class RimSummaryCase;
class RimSummaryCurve;
class RimSummaryFilter;
class RiuLineSegmentQwtPlotCurve;
class RimSummaryCurveAutoName;
class RiaSummaryCurveDefinition;
//==================================================================================================
///
///
//==================================================================================================
class RimSummaryCurveFilter : public caf::PdmObject
class RimSummaryCurveFilter_OBSOLETE : public caf::PdmObject
{
CAF_PDM_HEADER_INIT;
public:
RimSummaryCurveFilter();
virtual ~RimSummaryCurveFilter();
RimSummaryCurveFilter_OBSOLETE();
virtual ~RimSummaryCurveFilter_OBSOLETE();
void createDefaultCurves(RimSummaryCase* summaryCase, const QString& stringFilter);
bool isCurvesVisible();
void loadDataAndUpdate();
void setParentQwtPlotAndReplot(QwtPlot* plot);
void detachQwtCurves();
RimSummaryCurve* findRimCurveFromQwtCurve(const QwtPlotCurve* qwtCurve) const;
std::set<std::string> unitNames();
std::vector<RimSummaryCurve*> curves();
void removeCurvesAssosiatedWithCase(RimSummaryCase* summaryCase);
void updateCaseNameHasChanged();
RiaDefines::PlotAxis associatedPlotAxis() const;
void setPlotAxis(RiaDefines::PlotAxis plotAxis);
void updateCompleteVariableStringFilterChanged();
void updateCurveNames();
void clearCurvesWithoutDelete();
private:
void syncCurvesFromUiSelection();
void createCurvesFromCurveDefinitions(const std::set<RiaSummaryCurveDefinition>& curveDefinitions);
void syncUiSelectionFromCurves();
std::set<RifEclipseSummaryAddress> findPossibleSummaryAddresses();
void createSetOfCasesAndResultAdresses(
const std::vector<RimSummaryCase*>& cases,
const RimSummaryFilter& filter,
std::set<RiaSummaryCurveDefinition>* curveDefinitions) const;
// Overridden PDM methods
virtual caf::PdmFieldHandle* objectToggleField() override;
virtual void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue);
virtual QList<caf::PdmOptionItemInfo> calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool* useOptionsOnly);
virtual void defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering) override;
void defineEditorAttribute(const caf::PdmFieldHandle* field, QString uiConfigName, caf::PdmUiEditorAttribute * attribute) override;
void updatePlotAxisForCurves();
void loadDataAndUpdatePlot();
std::set<std::string> getAllSummaryCaseNames();
std::set<std::string> getAllSummaryWellNames();
private:
QPointer<QwtPlot> m_parentQwtPlot;
//QPointer<QwtPlot> m_parentQwtPlot;
// Fields
caf::PdmField<bool> m_showCurves;

10
ApplicationCode/ProjectDataModel/Summary/RimSummaryFilter.cpp
View File

@@ -461,16 +461,6 @@ void RimSummaryFilter::fieldChangedByUi(const caf::PdmFieldHandle* changedField,
{
parent->updateConnectedEditors();
}
if (changedField == &m_completeVarStringFilter)
{
RimSummaryCurveFilter* curveFilter = nullptr;
this->firstAncestorOrThisOfType(curveFilter);
if (curveFilter)
{
curveFilter->updateCompleteVariableStringFilterChanged();
}
}
}
//--------------------------------------------------------------------------------------------------

156
ApplicationCode/ProjectDataModel/Summary/RimSummaryPlot.cpp
View File

@@ -198,22 +198,6 @@ time_t RimSummaryPlot::firstTimeStepOfFirstCurve()
{
RimSummaryCurve * firstCurve = nullptr;
for (RimSummaryCurveFilter* curveFilter : m_curveFilters_OBSOLETE )
{
if (curveFilter)
{
std::vector<RimSummaryCurve *> curves = curveFilter->curves();
size_t i = 0;
while (firstCurve == nullptr && i < curves.size())
{
firstCurve = curves[i];
i++;
}
if (firstCurve) break;
}
}
if (m_summaryCurveCollection)
{
std::vector<RimSummaryCurve*> curves = m_summaryCurveCollection->curves();
@@ -225,13 +209,6 @@ time_t RimSummaryPlot::firstTimeStepOfFirstCurve()
}
}
size_t i = 0;
while (firstCurve == nullptr && i < m_summaryCurves_OBSOLETE.size())
{
firstCurve = m_summaryCurves_OBSOLETE[i];
++i;
}
if (firstCurve && firstCurve->timeStepsY().size() > 0)
{
return firstCurve->timeStepsY()[0];
@@ -643,28 +620,6 @@ std::vector<RimSummaryCurve*> RimSummaryPlot::visibleSummaryCurvesForAxis(RiaDef
}
else
{
for (RimSummaryCurve* curve : m_summaryCurves_OBSOLETE)
{
if (curve->isCurveVisible() && curve->axisY() == plotAxis)
{
curves.push_back(curve);
}
}
for (RimSummaryCurveFilter * curveFilter : m_curveFilters_OBSOLETE)
{
if (curveFilter->isCurvesVisible())
{
for (RimSummaryCurve* curve : curveFilter->curves())
{
if (curve->isCurveVisible() && curve->axisY() == plotAxis)
{
curves.push_back(curve);
}
}
}
}
if (m_summaryCurveCollection && m_summaryCurveCollection->isCurvesVisible())
{
for (RimSummaryCurve* curve : m_summaryCurveCollection->curves())
@@ -859,17 +814,6 @@ void RimSummaryPlot::updateBottomXAxis()
//--------------------------------------------------------------------------------------------------
void RimSummaryPlot::updateCaseNameHasChanged()
{
for (RimSummaryCurve* curve : m_summaryCurves_OBSOLETE)
{
curve->updateCurveNameAndUpdatePlotLegend();
curve->updateConnectedEditors();
}
for (RimSummaryCurveFilter* curveFilter : m_curveFilters_OBSOLETE)
{
curveFilter->updateCaseNameHasChanged();
}
if (m_summaryCurveCollection)
{
m_summaryCurveCollection->updateCaseNameHasChanged();
@@ -971,11 +915,6 @@ void RimSummaryPlot::deleteCurve(RimSummaryCurve* curve)
{
m_summaryCurveCollection->deleteCurve(curve);
}
else
{
m_summaryCurves_OBSOLETE.removeChildObject(curve);
delete curve;
}
}
}
@@ -984,57 +923,10 @@ void RimSummaryPlot::deleteCurve(RimSummaryCurve* curve)
//--------------------------------------------------------------------------------------------------
void RimSummaryPlot::deleteCurvesAssosiatedWithCase(RimSummaryCase* summaryCase)
{
for (RimSummaryCurveFilter* summaryCurveFilter : m_curveFilters_OBSOLETE)
{
if (!summaryCurveFilter) continue;
summaryCurveFilter->removeCurvesAssosiatedWithCase(summaryCase);
}
if (m_summaryCurveCollection)
{
m_summaryCurveCollection->deleteCurvesAssosiatedWithCase(summaryCase);
}
std::vector<RimSummaryCurve*> summaryCurvesToDelete;
for (RimSummaryCurve* summaryCurve : m_summaryCurves_OBSOLETE)
{
if (!summaryCurve) continue;
if (!summaryCurve->summaryCaseY()) continue;
if (summaryCurve->summaryCaseY() == summaryCase)
{
summaryCurvesToDelete.push_back(summaryCurve);
}
}
for (RimSummaryCurve* summaryCurve : summaryCurvesToDelete)
{
deleteCurve(summaryCurve);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryPlot::deleteAllTopLevelCurves()
{
m_summaryCurves_OBSOLETE.deleteAllChildObjects();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryPlot::addCurveFilter(RimSummaryCurveFilter* curveFilter)
{
if(curveFilter)
{
m_curveFilters_OBSOLETE.push_back(curveFilter);
if(m_qwtPlot)
{
curveFilter->setParentQwtPlotAndReplot(m_qwtPlot);
this->updateAxes();
}
}
}
//--------------------------------------------------------------------------------------------------
@@ -1148,9 +1040,7 @@ void RimSummaryPlot::defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTreeOrdering
axisFolder->add(&m_leftYAxisProperties);
axisFolder->add(&m_rightYAxisProperties);
uiTreeOrdering.add(&m_curveFilters_OBSOLETE);
uiTreeOrdering.add(&m_summaryCurveCollection);
uiTreeOrdering.add(&m_summaryCurves_OBSOLETE);
uiTreeOrdering.add(&m_gridTimeHistoryCurves);
uiTreeOrdering.add(&m_asciiDataCurves);
@@ -1169,20 +1059,10 @@ void RimSummaryPlot::onLoadDataAndUpdate()
updateMdiWindowVisibility();
for (RimSummaryCurveFilter* curveFilter: m_curveFilters_OBSOLETE)
{
curveFilter->loadDataAndUpdate();
}
if (m_summaryCurveCollection)
{
m_summaryCurveCollection->loadDataAndUpdate(false);
}
for (RimSummaryCurve* curve : m_summaryCurves_OBSOLETE)
{
curve->loadDataAndUpdate(true);
}
for (RimGridTimeHistoryCurve* curve : m_gridTimeHistoryCurves)
{
@@ -1330,16 +1210,6 @@ QWidget* RimSummaryPlot::createViewWidget(QWidget* mainWindowParent)
{
m_qwtPlot = new RiuSummaryQwtPlot(this, mainWindowParent);
for(RimSummaryCurveFilter* curveFilter: m_curveFilters_OBSOLETE)
{
curveFilter->setParentQwtPlotAndReplot(m_qwtPlot);
}
for (RimSummaryCurve* curve : m_summaryCurves_OBSOLETE)
{
curve->setParentQwtPlotAndReplot(m_qwtPlot);
}
for ( RimGridTimeHistoryCurve* curve : m_gridTimeHistoryCurves )
{
curve->setParentQwtPlotNoReplot(m_qwtPlot);
@@ -1436,21 +1306,11 @@ void RimSummaryPlot::updateMdiWindowTitle()
//--------------------------------------------------------------------------------------------------
void RimSummaryPlot::detachAllCurves()
{
for(RimSummaryCurveFilter* curveFilter: m_curveFilters_OBSOLETE)
{
curveFilter->detachQwtCurves();
}
if (m_summaryCurveCollection)
{
m_summaryCurveCollection->detachQwtCurves();
}
for(RimSummaryCurve* curve : m_summaryCurves_OBSOLETE)
{
curve->detachQwtCurve();
}
for (RimGridTimeHistoryCurve* curve : m_gridTimeHistoryCurves)
{
curve->detachQwtCurve();
@@ -1467,14 +1327,6 @@ void RimSummaryPlot::detachAllCurves()
//--------------------------------------------------------------------------------------------------
caf::PdmObject* RimSummaryPlot::findRimCurveFromQwtCurve(const QwtPlotCurve* qwtCurve) const
{
for(RimSummaryCurve* curve : m_summaryCurves_OBSOLETE)
{
if(curve->qwtPlotCurve() == qwtCurve)
{
return curve;
}
}
for (RimGridTimeHistoryCurve* curve : m_gridTimeHistoryCurves)
{
if (curve->qwtPlotCurve() == qwtCurve)
@@ -1491,12 +1343,6 @@ caf::PdmObject* RimSummaryPlot::findRimCurveFromQwtCurve(const QwtPlotCurve* qwt
}
}
for (RimSummaryCurveFilter* curveFilter: m_curveFilters_OBSOLETE)
{
RimSummaryCurve* foundCurve = curveFilter->findRimCurveFromQwtCurve(qwtCurve);
if (foundCurve) return foundCurve;
}
if (m_summaryCurveCollection)
{
RimSummaryCurve* foundCurve = m_summaryCurveCollection->findRimCurveFromQwtCurve(qwtCurve);
@@ -1517,7 +1363,7 @@ caf::PdmObject* RimSummaryPlot::findRimCurveFromQwtCurve(const QwtPlotCurve* qwt
//--------------------------------------------------------------------------------------------------
size_t RimSummaryPlot::curveCount() const
{
return m_summaryCurves_OBSOLETE.size() + m_gridTimeHistoryCurves.size() + m_asciiDataCurves.size();
return m_summaryCurveCollection->curves().size() + m_gridTimeHistoryCurves.size() + m_asciiDataCurves.size();
}
//--------------------------------------------------------------------------------------------------

7
ApplicationCode/ProjectDataModel/Summary/RimSummaryPlot.h
View File

@@ -32,7 +32,7 @@ class RimGridTimeHistoryCurve;
class RimSummaryCase;
class RimSummaryCurve;
class RimSummaryCurveCollection;
class RimSummaryCurveFilter;
class RimSummaryCurveFilter_OBSOLETE;
class RimSummaryTimeAxisProperties;
class RimSummaryAxisProperties;
class RiuSummaryQwtPlot;
@@ -61,10 +61,9 @@ public:
void addCurveNoUpdate(RimSummaryCurve* curve);
void deleteCurve(RimSummaryCurve* curve);
void addCurveFilter(RimSummaryCurveFilter* curveFilter);
void setCurveCollection(RimSummaryCurveCollection* curveCollection);
void deleteCurvesAssosiatedWithCase(RimSummaryCase* summaryCase);
void deleteAllTopLevelCurves();
//void deleteAllTopLevelCurves();
void addGridTimeHistoryCurve(RimGridTimeHistoryCurve* curve);
@@ -166,7 +165,7 @@ private:
QPointer<RiuSummaryQwtPlot> m_qwtPlot;
caf::PdmChildArrayField<RimSummaryCurve*> m_summaryCurves_OBSOLETE;
caf::PdmChildArrayField<RimSummaryCurveFilter*> m_curveFilters_OBSOLETE;
caf::PdmChildArrayField<RimSummaryCurveFilter_OBSOLETE*> m_curveFilters_OBSOLETE;
bool m_isCrossPlot;
};