OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2026-09-03 20:53:13 -05: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
ApplicationCode/ProjectDataModel/Summary/RimSummaryCurveFilter.cpp
+5 -629
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;
}
ApplicationCode/ProjectDataModel/Summary/RimSummaryCurveFilter.h
+4 -56
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;
ApplicationCode/ProjectDataModel/Summary/RimSummaryFilter.cpp
-10
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();
}
}
}
//--------------------------------------------------------------------------------------------------
ApplicationCode/ProjectDataModel/Summary/RimSummaryPlot.cpp
+1 -155
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();
}
//--------------------------------------------------------------------------------------------------
ApplicationCode/ProjectDataModel/Summary/RimSummaryPlot.h
+3 -4
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;
};