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

Grid Calculator: refactor summary curve calculator and add grid calculator.

Browse Source
This commit is contained in:
Kristian Bendiksen
2022-04-22 12:18:34 +02:00
parent 621100f0cf
commit 4304bbbc48
52 changed files with 2493 additions and 1015 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
ApplicationLibCode/Commands/SummaryPlotCommands/CMakeLists_files.cmake
View File

@@ -29,7 +29,6 @@ set(SOURCE_GROUP_HEADER_FILES
${CMAKE_CURRENT_LIST_DIR}/RicShowSummaryCurveCalculatorFeature.h
${CMAKE_CURRENT_LIST_DIR}/RicEditSummaryCurveCalculationFeature.h
${CMAKE_CURRENT_LIST_DIR}/RicSummaryCurveCalculatorDialog.h
${CMAKE_CURRENT_LIST_DIR}/RicSummaryCurveCalculatorWidgetCreator.h
${CMAKE_CURRENT_LIST_DIR}/RicSummaryCurveCalculatorUi.h
${CMAKE_CURRENT_LIST_DIR}/RicNewSummaryCrossPlotCurveFeature.h
${CMAKE_CURRENT_LIST_DIR}/RicNewSummaryEnsembleCurveSetFeature.h
@@ -76,7 +75,6 @@ set(SOURCE_GROUP_SOURCE_FILES
${CMAKE_CURRENT_LIST_DIR}/RicShowSummaryCurveCalculatorFeature.cpp
${CMAKE_CURRENT_LIST_DIR}/RicEditSummaryCurveCalculationFeature.cpp
${CMAKE_CURRENT_LIST_DIR}/RicSummaryCurveCalculatorDialog.cpp
${CMAKE_CURRENT_LIST_DIR}/RicSummaryCurveCalculatorWidgetCreator.cpp
${CMAKE_CURRENT_LIST_DIR}/RicSummaryCurveCalculatorUi.cpp
${CMAKE_CURRENT_LIST_DIR}/RicNewSummaryCrossPlotCurveFeature.cpp
${CMAKE_CURRENT_LIST_DIR}/RicNewSummaryEnsembleCurveSetFeature.cpp
@@ -101,7 +99,6 @@ list(
COMMAND_QT_MOC_HEADERS
${CMAKE_CURRENT_LIST_DIR}/RicSummaryPlotEditorWidgetCreator.h
${CMAKE_CURRENT_LIST_DIR}/RicSummaryPlotEditorDialog.h
${CMAKE_CURRENT_LIST_DIR}/RicSummaryCurveCalculatorWidgetCreator.h
${CMAKE_CURRENT_LIST_DIR}/RicSummaryCurveCalculatorDialog.h
)

2
ApplicationLibCode/Commands/SummaryPlotCommands/RicEditSummaryCurveCalculationFeature.cpp
View File

@@ -55,7 +55,7 @@ bool RicEditSummaryCurveCalculationFeature::isCommandEnabled()
void RicEditSummaryCurveCalculationFeature::onActionTriggered( bool isChecked )
{
std::vector<RimSummaryCurve*> selectedCurves = caf::selectedObjectsByType<RimSummaryCurve*>();
RimSummaryCalculation* calculation = nullptr;
RimUserDefinedCalculation* calculation = nullptr;
if ( selectedCurves.size() > 0 )
{

2
ApplicationLibCode/Commands/SummaryPlotCommands/RicShowSummaryCurveCalculatorFeature.cpp
View File

@@ -77,7 +77,7 @@ void RicShowSummaryCurveCalculatorFeature::onActionTriggered( bool isChecked )
RimProject* proj = RimProject::current();
RimSummaryCalculationCollection* calcColl = proj->calculationCollection();
if ( calcColl->calculations().size() == 0 )
if ( calcColl->calculations().empty() )
{
calcColl->addCalculation();
}

106
ApplicationLibCode/Commands/SummaryPlotCommands/RicSummaryCurveCalculatorDialog.cpp
View File

@@ -18,27 +18,18 @@
#include "RicSummaryCurveCalculatorDialog.h"
#include "RicCalculatorWidgetCreator.h"
#include "RicSummaryCurveCalculatorUi.h"
#include "RicSummaryCurveCalculatorWidgetCreator.h"
#include "RimSummaryCalculation.h"
#include "RimSummaryCalculationCollection.h"
#include "RiuTools.h"
#include <QDialogButtonBox>
#include <QMessageBox>
#include <QVBoxLayout>
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RicSummaryCurveCalculatorDialog::RicSummaryCurveCalculatorDialog( QWidget* parent )
: QDialog( parent, RiuTools::defaultDialogFlags() )
: RicUserDefinedCalculatorDialog( parent, "Summary Curve Calculator" )
{
setWindowTitle( "Summary Curve Calculator" );
resize( 1200, 800 );
setUp();
}
@@ -52,96 +43,41 @@ RicSummaryCurveCalculatorDialog::~RicSummaryCurveCalculatorDialog()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicSummaryCurveCalculatorDialog::setCalculationAndUpdateUi( RimSummaryCalculation* calculation )
void RicSummaryCurveCalculatorDialog::setCalculationAndUpdateUi( RimUserDefinedCalculation* calculation )
{
m_summaryCalcEditor->calculator()->setCurrentCalculation( calculation );
CAF_ASSERT( m_summaryCalcEditor );
m_summaryCalcEditor->calculator()->setCurrentCalculation( dynamic_cast<RimSummaryCalculation*>( calculation ) );
updateUi();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicSummaryCurveCalculatorDialog::updateUi()
{
CAF_ASSERT( m_summaryCalcEditor );
m_summaryCalcEditor->updateUi();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicSummaryCurveCalculatorDialog::slotTryCloseDialog()
RimUserDefinedCalculationCollection* RicSummaryCurveCalculatorDialog::calculationCollection() const
{
RimSummaryCalculationCollection* calculationCollection = RicSummaryCurveCalculatorUi::calculationCollection();
if ( dirtyCount() > 0 )
{
QMessageBox msgBox( this );
msgBox.setIcon( QMessageBox::Question );
QString questionText = QString( "Detected calculation expression text modifications." );
msgBox.setText( questionText );
msgBox.setInformativeText( "Do you want to trigger calculation?" );
msgBox.setStandardButtons( QMessageBox::Yes | QMessageBox::No );
int ret = msgBox.exec();
if ( ret == QMessageBox::No )
{
reject();
}
else if ( ret == QMessageBox::Yes )
{
for ( auto c : calculationCollection->calculations() )
{
if ( c->isDirty() )
{
c->calculate();
c->updateDependentCurvesAndPlots();
}
}
if ( dirtyCount() > 0 )
{
return;
}
}
else
{
return;
}
}
accept();
CAF_ASSERT( m_summaryCalcEditor );
return m_summaryCalcEditor->calculator()->calculationCollection();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicSummaryCurveCalculatorDialog::setUp()
QWidget* RicSummaryCurveCalculatorDialog::getCalculatorWidget()
{
QVBoxLayout* mainLayout = new QVBoxLayout( this );
mainLayout->setContentsMargins( 0, 0, 0, 0 );
m_summaryCalcEditor =
std::unique_ptr<RicSummaryCurveCalculatorWidgetCreator>( new RicSummaryCurveCalculatorWidgetCreator() );
mainLayout->addWidget( m_summaryCalcEditor->getOrCreateWidget( this ) );
QDialogButtonBox* buttonBox = new QDialogButtonBox( QDialogButtonBox::Close );
connect( buttonBox, SIGNAL( rejected() ), this, SLOT( slotTryCloseDialog() ) );
mainLayout->addWidget( buttonBox );
m_summaryCalcEditor->updateUi();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RicSummaryCurveCalculatorDialog::dirtyCount() const
{
size_t count = 0;
RimSummaryCalculationCollection* calculationCollection = RicSummaryCurveCalculatorUi::calculationCollection();
for ( auto c : calculationCollection->calculations() )
if ( !m_summaryCalcEditor )
{
if ( c->isDirty() )
{
count++;
}
m_summaryCalcEditor = std::unique_ptr<RicCalculatorWidgetCreator>(
new RicCalculatorWidgetCreator( std::make_unique<RicSummaryCurveCalculatorUi>() ) );
}
return count;
return m_summaryCalcEditor->getOrCreateWidget( this );
}

22
ApplicationLibCode/Commands/SummaryPlotCommands/RicSummaryCurveCalculatorDialog.h
View File

@@ -18,17 +18,17 @@
#pragma once
#include <QDialog>
#include "RicUserDefinedCalculatorDialog.h"
#include <memory>
class RicSummaryCurveCalculatorWidgetCreator;
class RimSummaryCalculation;
class RicCalculatorWidgetCreator;
//==================================================================================================
///
///
//==================================================================================================
class RicSummaryCurveCalculatorDialog : public QDialog
class RicSummaryCurveCalculatorDialog : public RicUserDefinedCalculatorDialog
{
Q_OBJECT
@@ -36,15 +36,11 @@ public:
RicSummaryCurveCalculatorDialog( QWidget* parent );
~RicSummaryCurveCalculatorDialog() override;
void setCalculationAndUpdateUi( RimSummaryCalculation* calculation );
private slots:
void slotTryCloseDialog();
void setCalculationAndUpdateUi( RimUserDefinedCalculation* calculation ) override;
QWidget* getCalculatorWidget() override;
void updateUi() override;
RimUserDefinedCalculationCollection* calculationCollection() const override;
private:
void setUp();
size_t dirtyCount() const;
private:
std::unique_ptr<RicSummaryCurveCalculatorWidgetCreator> m_summaryCalcEditor;
std::unique_ptr<RicCalculatorWidgetCreator> m_summaryCalcEditor;
};

246
ApplicationLibCode/Commands/SummaryPlotCommands/RicSummaryCurveCalculatorUi.cpp
View File

@@ -21,13 +21,9 @@
#include "RiaSummaryTools.h"
#include "RimProject.h"
#include "RimSummaryCalculation.h"
#include "RimSummaryCalculationCollection.h"
#include "cafPdmUiListEditor.h"
#include "cafPdmUiObjectEditorHandle.h"
#include "cafPdmUiPushButtonEditor.h"
#include "cafPdmUiTreeSelectionEditor.h"
#include "RimUserDefinedCalculation.h"
#include "RimUserDefinedCalculationCollection.h"
CAF_PDM_SOURCE_INIT( RicSummaryCurveCalculatorUi, "RicSummaryCurveCalculator" );
@@ -37,25 +33,12 @@ CAF_PDM_SOURCE_INIT( RicSummaryCurveCalculatorUi, "RicSummaryCurveCalculator" );
RicSummaryCurveCalculatorUi::RicSummaryCurveCalculatorUi()
{
CAF_PDM_InitObject( "RicSummaryCurveCalculator" );
CAF_PDM_InitFieldNoDefault( &m_currentCalculation, "CurrentCalculation", "" );
m_currentCalculation.uiCapability()->setUiLabelPosition( caf::PdmUiItemInfo::HIDDEN );
// m_currentCalculation.uiCapability()->setUiEditorTypeName(caf::PdmUiTreeSelectionEditor::uiEditorTypeName());
m_currentCalculation.uiCapability()->setUiEditorTypeName( caf::PdmUiListEditor::uiEditorTypeName() );
CAF_PDM_InitFieldNoDefault( &m_newCalculation, "NewCalculation", "New Calculation" );
RicSummaryCurveCalculatorUi::assignPushButtonEditor( &m_newCalculation );
CAF_PDM_InitFieldNoDefault( &m_deleteCalculation, "DeleteCalculation", "Delete Calculation" );
RicSummaryCurveCalculatorUi::assignPushButtonEditor( &m_deleteCalculation );
m_calcContextMenuMgr = std::unique_ptr<RiuCalculationsContextMenuManager>( new RiuCalculationsContextMenuManager() );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RicSummaryCurveCalculatorUi::calculatedSummariesGroupName()
QString RicSummaryCurveCalculatorUi::calculationsGroupName() const
{
return "CalculatedSummariesGroupName";
}
@@ -63,7 +46,7 @@ QString RicSummaryCurveCalculatorUi::calculatedSummariesGroupName()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RicSummaryCurveCalculatorUi::calulationGroupName()
QString RicSummaryCurveCalculatorUi::calulationGroupName() const
{
return "CalulationGroupName";
}
@@ -71,228 +54,15 @@ QString RicSummaryCurveCalculatorUi::calulationGroupName()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimSummaryCalculation* RicSummaryCurveCalculatorUi::currentCalculation() const
void RicSummaryCurveCalculatorUi::notifyCalculatedNameChanged( int id, const QString& newName ) const
{
return m_currentCalculation();
RiaSummaryTools::notifyCalculatedCurveNameHasChanged( id, newName );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicSummaryCurveCalculatorUi::setCurrentCalculation( RimSummaryCalculation* calculation )
RimUserDefinedCalculationCollection* RicSummaryCurveCalculatorUi::calculationCollection() const
{
m_currentCalculation = calculation;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RicSummaryCurveCalculatorUi::parseExpression() const
{
if ( m_currentCalculation() )
{
QString previousCurveName = m_currentCalculation->description();
if ( !m_currentCalculation()->parseExpression() )
{
return false;
}
QString currentCurveName = m_currentCalculation->description();
if ( previousCurveName != currentCurveName )
{
RiaSummaryTools::notifyCalculatedCurveNameHasChanged( m_currentCalculation()->id(), currentCurveName );
}
m_currentCalculation()->updateDependentCurvesAndPlots();
}
return true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicSummaryCurveCalculatorUi::fieldChangedByUi( const caf::PdmFieldHandle* changedField,
const QVariant& oldValue,
const QVariant& newValue )
{
if ( changedField == &m_newCalculation )
{
m_newCalculation = false;
m_currentCalculation = calculationCollection()->addCalculation();
this->updateConnectedEditors();
}
else if ( changedField == &m_deleteCalculation )
{
m_deleteCalculation = false;
if ( m_currentCalculation() )
{
calculationCollection()->deleteCalculation( m_currentCalculation() );
m_currentCalculation = nullptr;
this->updateConnectedEditors();
caf::PdmUiObjectEditorHandle::updateUiAllObjectEditors();
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicSummaryCurveCalculatorUi::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
{
if ( !m_currentCalculation() )
{
if ( calculationCollection()->calculations().size() > 0 )
{
m_currentCalculation = calculationCollection()->calculations()[0];
}
}
{
caf::PdmUiGroup* group =
uiOrdering.addNewGroupWithKeyword( "Calculated Summaries",
RicSummaryCurveCalculatorUi::calculatedSummariesGroupName() );
group->add( &m_currentCalculation );
group->add( &m_newCalculation );
group->add( &m_deleteCalculation );
}
{
caf::PdmUiGroup* group = uiOrdering.addNewGroupWithKeyword( "Calculation Settings",
RicSummaryCurveCalculatorUi::calulationGroupName() );
if ( m_currentCalculation() )
{
m_currentCalculation->uiOrdering( uiConfigName, *group );
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QList<caf::PdmOptionItemInfo>
RicSummaryCurveCalculatorUi::calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions, bool* useOptionsOnly )
{
QList<caf::PdmOptionItemInfo> options;
if ( fieldNeedingOptions == &m_currentCalculation )
{
for ( auto c : calculationCollection()->calculations() )
{
options.push_back( caf::PdmOptionItemInfo( c->description(), c ) );
}
}
return options;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimSummaryCalculationCollection* RicSummaryCurveCalculatorUi::calculationCollection()
{
RimProject* proj = RimProject::current();
if ( proj )
{
return proj->calculationCollection();
}
return nullptr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicSummaryCurveCalculatorUi::assignPushButtonEditor( caf::PdmFieldHandle* fieldHandle )
{
CVF_ASSERT( fieldHandle );
CVF_ASSERT( fieldHandle->uiCapability() );
fieldHandle->uiCapability()->setUiEditorTypeName( caf::PdmUiPushButtonEditor::uiEditorTypeName() );
fieldHandle->uiCapability()->setUiLabelPosition( caf::PdmUiItemInfo::HIDDEN );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicSummaryCurveCalculatorUi::assignPushButtonEditorText( caf::PdmUiEditorAttribute* attribute, const QString& text )
{
caf::PdmUiPushButtonEditorAttribute* attrib = dynamic_cast<caf::PdmUiPushButtonEditorAttribute*>( attribute );
if ( attrib )
{
attrib->m_buttonText = text;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RicSummaryCurveCalculatorUi::calculate() const
{
if ( m_currentCalculation() )
{
QString previousCurveName = m_currentCalculation->description();
if ( !m_currentCalculation()->parseExpression() )
{
return false;
}
QString currentCurveName = m_currentCalculation->description();
if ( previousCurveName != currentCurveName )
{
RiaSummaryTools::notifyCalculatedCurveNameHasChanged( m_currentCalculation()->id(), currentCurveName );
}
if ( !m_currentCalculation()->calculate() )
{
return false;
}
m_currentCalculation()->updateDependentCurvesAndPlots();
caf::PdmUiObjectEditorHandle::updateUiAllObjectEditors();
}
return true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicSummaryCurveCalculatorUi::defineEditorAttribute( const caf::PdmFieldHandle* field,
QString uiConfigName,
caf::PdmUiEditorAttribute* attribute )
{
if ( &m_newCalculation == field )
{
RicSummaryCurveCalculatorUi::assignPushButtonEditorText( attribute, "New Calculation" );
}
else if ( &m_deleteCalculation == field )
{
RicSummaryCurveCalculatorUi::assignPushButtonEditorText( attribute, "Delete Calculation" );
}
}
//--------------------------------------------------------------------------------------------------
/// f
//--------------------------------------------------------------------------------------------------
void RicSummaryCurveCalculatorUi::onEditorWidgetsCreated()
{
if ( m_currentCalculation() != nullptr )
{
m_currentCalculation->attachToWidget();
}
for ( const auto& e : m_currentCalculation.uiCapability()->connectedEditors() )
{
caf::PdmUiListEditor* listEditor = dynamic_cast<caf::PdmUiListEditor*>( e );
if ( !listEditor ) continue;
QWidget* widget = listEditor->editorWidget();
if ( !widget ) continue;
m_calcContextMenuMgr->attachWidget( widget, this );
}
return RimProject::current()->calculationCollection();
}

48
ApplicationLibCode/Commands/SummaryPlotCommands/RicSummaryCurveCalculatorUi.h
View File

@@ -18,56 +18,22 @@
#pragma once
#include "RiuCalculationsContextMenuManager.h"
#include "cafPdmField.h"
#include "cafPdmObject.h"
#include "cafPdmPtrField.h"
#include <memory>
#include "RicUserDefinedCalculatorUi.h"
class RimSummaryCalculationCollection;
class RimSummaryCalculation;
class RimUserDefinedCalculationCollection;
//==================================================================================================
///
//==================================================================================================
class RicSummaryCurveCalculatorUi : public caf::PdmObject
class RicSummaryCurveCalculatorUi : public RicUserDefinedCalculatorUi
{
CAF_PDM_HEADER_INIT;
public:
RicSummaryCurveCalculatorUi();
static QString calculatedSummariesGroupName();
static QString calulationGroupName();
RimSummaryCalculation* currentCalculation() const;
void setCurrentCalculation( RimSummaryCalculation* calculation );
bool parseExpression() const;
bool calculate() const;
static RimSummaryCalculationCollection* calculationCollection();
private:
void fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue ) override;
void defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering ) override;
QList<caf::PdmOptionItemInfo> calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions,
bool* useOptionsOnly ) override;
void defineEditorAttribute( const caf::PdmFieldHandle* field,
QString uiConfigName,
caf::PdmUiEditorAttribute* attribute ) override;
void onEditorWidgetsCreated() override;
private:
// TODO : Move to a common caf helper class
static void assignPushButtonEditor( caf::PdmFieldHandle* fieldHandle );
static void assignPushButtonEditorText( caf::PdmUiEditorAttribute* attribute, const QString& text );
private:
caf::PdmPtrField<RimSummaryCalculation*> m_currentCalculation;
caf::PdmField<bool> m_newCalculation;
caf::PdmField<bool> m_deleteCalculation;
std::unique_ptr<RiuCalculationsContextMenuManager> m_calcContextMenuMgr;
QString calculationsGroupName() const override;
QString calulationGroupName() const override;
RimUserDefinedCalculationCollection* calculationCollection() const override;
void notifyCalculatedNameChanged( int id, const QString& newName ) const override;
};

220
ApplicationLibCode/Commands/SummaryPlotCommands/RicSummaryCurveCalculatorWidgetCreator.cpp
View File

@@ -1,220 +0,0 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2017- 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 "RicSummaryCurveCalculatorWidgetCreator.h"
#include "RicSummaryCurveCalculatorUi.h"
#include "RimSummaryCalculation.h"
#include "cafPdmUiTableView.h"
#include "QMinimizePanel.h"
#include <QBoxLayout>
#include <QHeaderView>
#include <QPushButton>
#include <QSplitter>
#include <QTableView>
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RicSummaryCurveCalculatorWidgetCreator::RicSummaryCurveCalculatorWidgetCreator()
: m_pdmTableView( nullptr )
{
m_calculator = std::unique_ptr<RicSummaryCurveCalculatorUi>( new RicSummaryCurveCalculatorUi );
this->setPdmObject( m_calculator.get() );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RicSummaryCurveCalculatorWidgetCreator::~RicSummaryCurveCalculatorWidgetCreator()
{
if ( m_pdmTableView )
{
m_pdmTableView->setChildArrayField( nullptr );
delete m_pdmTableView;
m_pdmTableView = nullptr;
}
this->setPdmObject( nullptr );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicSummaryCurveCalculatorWidgetCreator::recursivelyConfigureAndUpdateTopLevelUiOrdering(
const caf::PdmUiOrdering& topLevelUiOrdering,
const QString& uiConfigName )
{
if ( !m_firstRowLeftLayout || !m_firstRowRightLayout ) return;
const std::vector<caf::PdmUiItem*>& topLevelUiItems = topLevelUiOrdering.uiItems();
int layoutItemIndex = 0;
for ( size_t i = 0; i < topLevelUiItems.size(); ++i )
{
if ( topLevelUiItems[i]->isUiHidden( uiConfigName ) ) continue;
if ( topLevelUiItems[i]->isUiGroup() )
{
caf::PdmUiGroup* group = static_cast<caf::PdmUiGroup*>( topLevelUiItems[i] );
auto groupBox = updateGroupBoxWithContent( group, uiConfigName );
if ( group->keyword() == RicSummaryCurveCalculatorUi::calculatedSummariesGroupName() )
{
m_firstRowLeftLayout->addWidget( groupBox );
}
else if ( group->keyword() == RicSummaryCurveCalculatorUi::calulationGroupName() )
{
m_firstRowRightLayout->insertWidget( layoutItemIndex++, groupBox );
}
}
}
if ( m_firstRowRightLayout->itemAt( layoutItemIndex ) != m_parseButtonLayout )
{
m_firstRowRightLayout->insertLayout( layoutItemIndex, m_parseButtonLayout );
}
layoutItemIndex++;
if ( m_calculator->currentCalculation() )
{
m_pdmTableView->setChildArrayField( m_calculator->currentCalculation()->variables() );
}
else
m_pdmTableView->setChildArrayField( nullptr );
m_firstRowRightLayout->insertWidget( layoutItemIndex++, m_pdmTableView );
if ( m_firstRowRightLayout->itemAt( layoutItemIndex ) != m_calculateButtonLayout )
{
m_firstRowRightLayout->insertLayout( layoutItemIndex, m_calculateButtonLayout );
}
layoutItemIndex++;
m_pdmTableView->tableView()->resizeColumnsToContents();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QWidget* RicSummaryCurveCalculatorWidgetCreator::createWidget( QWidget* parent )
{
m_pdmTableView = new caf::PdmUiTableView( parent );
m_pdmTableView->tableView()->setSelectionMode( QAbstractItemView::ExtendedSelection );
m_pdmTableView->enableHeaderText( false );
QHeaderView* verticalHeader = m_pdmTableView->tableView()->verticalHeader();
verticalHeader->setSectionResizeMode( QHeaderView::Interactive );
m_pdmTableView->tableView()->resizeColumnsToContents();
QWidget* widget = new QWidget( parent );
QVBoxLayout* mainLayout = new QVBoxLayout();
mainLayout->setContentsMargins( 5, 5, 5, 5 );
widget->setLayout( mainLayout );
QFrame* firstRowFrame = new QFrame( widget );
QHBoxLayout* firstRowLayout = new QHBoxLayout;
firstRowLayout->setContentsMargins( 0, 0, 0, 0 );
firstRowFrame->setLayout( firstRowLayout );
QFrame* firstRowLeftFrame = new QFrame( widget );
m_firstRowLeftLayout = new QHBoxLayout;
m_firstRowLeftLayout->setContentsMargins( 0, 0, 0, 0 );
firstRowLeftFrame->setLayout( m_firstRowLeftLayout );
QFrame* firstRowRightFrame = new QFrame( widget );
m_firstRowRightLayout = new QVBoxLayout;
m_firstRowRightLayout->setContentsMargins( 0, 0, 0, 0 );
firstRowRightFrame->setLayout( m_firstRowRightLayout );
QSplitter* rowSplitter = new QSplitter( Qt::Horizontal );
rowSplitter->setContentsMargins( 0, 0, 0, 0 );
rowSplitter->setHandleWidth( 6 );
rowSplitter->setStyleSheet( "QSplitter::handle { image: url(:/SplitterV.png); }" );
rowSplitter->insertWidget( 0, firstRowLeftFrame );
rowSplitter->insertWidget( 1, firstRowRightFrame );
rowSplitter->setSizes( QList<int>() << 1 << 1 );
firstRowLayout->addWidget( rowSplitter );
mainLayout->addWidget( rowSplitter );
{
QPushButton* pushButton = new QPushButton( "Parse Expression" );
connect( pushButton, SIGNAL( clicked() ), this, SLOT( slotParseExpression() ) );
m_parseButtonLayout = new QHBoxLayout;
m_parseButtonLayout->addStretch( 10 );
m_parseButtonLayout->addWidget( pushButton );
}
{
QPushButton* pushButton = new QPushButton( "Calculate" );
connect( pushButton, SIGNAL( clicked() ), this, SLOT( slotCalculate() ) );
m_calculateButtonLayout = new QHBoxLayout;
m_calculateButtonLayout->addStretch( 10 );
m_calculateButtonLayout->addWidget( pushButton );
}
return widget;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QMinimizePanel* RicSummaryCurveCalculatorWidgetCreator::updateGroupBoxWithContent( caf::PdmUiGroup* group,
const QString& uiConfigName )
{
QMinimizePanel* groupBox = findOrCreateGroupBox( this->widget(), group, uiConfigName );
recursivelyConfigureAndUpdateUiOrderingInGridLayout( *group, groupBox->contentFrame(), uiConfigName );
return groupBox;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RicSummaryCurveCalculatorUi* RicSummaryCurveCalculatorWidgetCreator::calculator() const
{
return m_calculator.get();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicSummaryCurveCalculatorWidgetCreator::slotCalculate()
{
m_calculator->calculate();
m_calculator->updateConnectedEditors();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicSummaryCurveCalculatorWidgetCreator::slotParseExpression()
{
m_calculator->parseExpression();
m_calculator->updateConnectedEditors();
}

76
ApplicationLibCode/Commands/SummaryPlotCommands/RicSummaryCurveCalculatorWidgetCreator.h
View File

@@ -1,76 +0,0 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2017- 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 "cafPdmUiFormLayoutObjectEditor.h"
#include <memory>
#include <vector>
class RicSummaryCurveCalculatorUi;
class QMinimizePanel;
class QString;
class QVBoxLayout;
class QHBoxLayout;
class QPushButton;
namespace caf
{
class PdmUiItem;
class PdmUiTableView;
} // namespace caf
//==================================================================================================
///
///
//==================================================================================================
class RicSummaryCurveCalculatorWidgetCreator : public caf::PdmUiFormLayoutObjectEditor
{
Q_OBJECT
public:
RicSummaryCurveCalculatorWidgetCreator();
~RicSummaryCurveCalculatorWidgetCreator() override;
RicSummaryCurveCalculatorUi* calculator() const;
private:
void recursivelyConfigureAndUpdateTopLevelUiOrdering( const caf::PdmUiOrdering& topLevelUiItems,
const QString& uiConfigName ) override;
QWidget* createWidget( QWidget* parent ) override;
QMinimizePanel* updateGroupBoxWithContent( caf::PdmUiGroup* group, const QString& uiConfigName );
private slots:
void slotCalculate();
void slotParseExpression();
private:
QPointer<QHBoxLayout> m_firstRowLeftLayout;
QPointer<QVBoxLayout> m_firstRowRightLayout;
QPointer<QHBoxLayout> m_parseButtonLayout;
QPointer<QHBoxLayout> m_calculateButtonLayout;
caf::PdmUiTableView* m_pdmTableView;
std::unique_ptr<RicSummaryCurveCalculatorUi> m_calculator;
};