ResInsight/ApplicationLibCode/Commands/RicUserDefinedCalculatorUi.cpp

/////////////////////////////////////////////////////////////////////////////////
//
//  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 "RicUserDefinedCalculatorUi.h"

#include "RimUserDefinedCalculation.h"
#include "RimUserDefinedCalculationCollection.h"

#include "cafAssert.h"
#include "cafPdmUiButton.h"
#include "cafPdmUiListEditor.h"
#include "cafPdmUiObjectEditorHandle.h"

CAF_PDM_ABSTRACT_SOURCE_INIT( RicUserDefinedCalculatorUi, "RicUserDefinedCalculator" );

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RicUserDefinedCalculatorUi::RicUserDefinedCalculatorUi()
{
    CAF_PDM_InitObject( "RicUserDefinedCalculator" );

    CAF_PDM_InitFieldNoDefault( &m_currentCalculation, "CurrentCalculation", "" );
    m_currentCalculation.uiCapability()->setUiLabelPosition( caf::PdmUiItemInfo::LabelPosition::HIDDEN );
    m_currentCalculation.uiCapability()->setUiEditorTypeName( caf::PdmUiListEditor::uiEditorTypeName() );

    m_calcContextMenuMgr = std::make_unique<RiuCalculationsContextMenuManager>();
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimUserDefinedCalculation* RicUserDefinedCalculatorUi::currentCalculation() const
{
    return m_currentCalculation();
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicUserDefinedCalculatorUi::setCurrentCalculation( RimUserDefinedCalculation* calculation )
{
    m_currentCalculation = calculation;

    connectSignals( m_currentCalculation() );
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RicUserDefinedCalculatorUi::parseExpression() const
{
    if ( m_currentCalculation() )
    {
        QString previousCurveName = m_currentCalculation->description();
        if ( !m_currentCalculation()->parseExpression() )
        {
            return false;
        }

        QString currentCurveName = m_currentCalculation->description();
        if ( previousCurveName != currentCurveName )
        {
            notifyCalculatedNameChanged( m_currentCalculation()->id(), currentCurveName );
        }

        // Always rebuild the case meta data after parsing the expression. A change in name or change in result type will require rebuild of
        // case metadata. The rebuild is considered lightweight and should not be a performance issue.
        calculationCollection()->rebuildCaseMetaData();
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicUserDefinedCalculatorUi::fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue )
{
    if ( changedField == &m_currentCalculation && m_currentCalculation() )
    {
        connectSignals( m_currentCalculation() );
    }
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicUserDefinedCalculatorUi::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
{
    if ( !m_currentCalculation() && !calculationCollection()->calculations().empty() )
    {
        setCurrentCalculation( calculationCollection()->calculations()[0] );
    }

    {
        caf::PdmUiGroup* group = uiOrdering.addNewGroupWithKeyword( "Calculations", calculationsGroupName() );
        group->add( &m_currentCalculation );
        group
            ->addNewButton( "New Calculation",
                            [this]()
                            {
                                m_currentCalculation = calculationCollection()->addCalculation();
                                connectSignals( m_currentCalculation );
                                updateConnectedEditors();
                            } )
            ->setFillWidth( true );
        group->addNewButton( "Delete Calculation", [this]() { onDeleteCalculationClicked(); }, { .newRow = false } )->setFillWidth( true );
    }

    {
        caf::PdmUiGroup* group = uiOrdering.addNewGroupWithKeyword( "Calculation Settings", calulationGroupName() );
        if ( m_currentCalculation() )
        {
            m_currentCalculation->uiOrdering( uiConfigName, *group );
        }
    }

    caf::PdmUiGroup* group = uiOrdering.findGroup( calculationsGroupName() );
    if ( group )
    {
        group->addNewButton( "Import Calculations", [this]() { importCalculations(); } )->setFillWidth( true );
        group->addNewButton( "Export Calculations", [this]() { exportCalculations(); }, { .newRow = false } )->setFillWidth( true );
    }
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QList<caf::PdmOptionItemInfo> RicUserDefinedCalculatorUi::calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions )
{
    QList<caf::PdmOptionItemInfo> options;
    if ( fieldNeedingOptions == &m_currentCalculation )
    {
        for ( auto c : calculationCollection()->calculations() )
        {
            options.push_back( caf::PdmOptionItemInfo( c->description(), c ) );
        }
    }

    return options;
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RicUserDefinedCalculatorUi::calculate() const
{
    if ( m_currentCalculation() )
    {
        if ( !parseExpression() ) return false;

        if ( !m_currentCalculation()->preCalculate() )
        {
            return false;
        }

        if ( !m_currentCalculation()->calculate() )
        {
            return false;
        }

        m_currentCalculation()->updateDependentObjects();
        caf::PdmUiObjectEditorHandle::updateUiAllObjectEditors();
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicUserDefinedCalculatorUi::onEditorWidgetsCreated()
{
    if ( m_currentCalculation() != nullptr )
    {
        m_currentCalculation->attachToWidget();
    }

    for ( const auto& e : m_currentCalculation.uiCapability()->connectedEditors() )
    {
        auto* listEditor = dynamic_cast<caf::PdmUiListEditor*>( e );
        if ( !listEditor ) continue;

        QWidget* widget = listEditor->editorWidget();
        if ( !widget ) continue;

        m_calcContextMenuMgr->attachWidget( widget, this );
    }
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicUserDefinedCalculatorUi::onVariableUpdated( const SignalEmitter* emitter )
{
    updateConnectedEditors();
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicUserDefinedCalculatorUi::onDeleteCalculationClicked()
{
    if ( m_currentCalculation() )
    {
        calculationCollection()->deleteCalculation( m_currentCalculation() );
        m_currentCalculation = nullptr;

        updateConnectedEditors();
        caf::PdmUiObjectEditorHandle::updateUiAllObjectEditors();
    }
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicUserDefinedCalculatorUi::connectSignals( RimUserDefinedCalculation* calculation )
{
    if ( calculation )
    {
        calculation->variableUpdated.connect( this, &RicUserDefinedCalculatorUi::onVariableUpdated );
    }
}