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

Merge pull request #8732 from OPM/summarymultiplot_updates2

Browse Source 
Summary Multiplot updates
This commit is contained in:
jonjenssen 2022-03-25 11:39:12 +01:00 committed by GitHub
parent 8feb0c363b
commit 8d3f41ded8
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
32 changed files with 423 additions and 316 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
ApplicationLibCode/Application/RiaDefines.cpp
View File

@ -135,6 +135,26 @@ void AppEnum<RiaDefines::RINavigationPolicy>::setUp()
setDefault( RiaDefines::RINavigationPolicy::NAVIGATION_POLICY_RMS );
}
template <>
void caf::AppEnum<RiaDefines::ColumnCount>::setUp()
{
addItem( RiaDefines::ColumnCount::COLUMNS_1, "1", "1 Column" );
addItem( RiaDefines::ColumnCount::COLUMNS_2, "2", "2 Columns" );
addItem( RiaDefines::ColumnCount::COLUMNS_3, "3", "3 Columns" );
addItem( RiaDefines::ColumnCount::COLUMNS_4, "4", "4 Columns" );
setDefault( RiaDefines::ColumnCount::COLUMNS_2 );
}
template <>
void caf::AppEnum<RiaDefines::RowCount>::setUp()
{
addItem( RiaDefines::RowCount::ROWS_1, "1", "1 Row" );
addItem( RiaDefines::RowCount::ROWS_2, "2", "2 Rows" );
addItem( RiaDefines::RowCount::ROWS_3, "3", "3 Rows" );
addItem( RiaDefines::RowCount::ROWS_4, "4", "4 Rows" );
setDefault( RiaDefines::RowCount::ROWS_2 );
}
} // namespace caf
//--------------------------------------------------------------------------------------------------

17
ApplicationLibCode/Application/RiaDefines.h
View File

@ -187,4 +187,21 @@ bool isInjector( WellProductionType wellProductionType );
QString stringListSeparator();
enum class ColumnCount
{
COLUMNS_1 = 1,
COLUMNS_2 = 2,
COLUMNS_3 = 3,
COLUMNS_4 = 4,
COLUMNS_UNLIMITED = 1000,
};
enum class RowCount
{
ROWS_1 = 1,
ROWS_2 = 2,
ROWS_3 = 3,
ROWS_4 = 4,
};
}; // namespace RiaDefines

1
ApplicationLibCode/Application/RiaPreferences.cpp
View File

@ -288,6 +288,7 @@ void RiaPreferences::defineEditorAttribute( const caf::PdmFieldHandle* field,
caf::PdmUiEditorAttribute* attribute )
{
m_readerSettings->defineEditorAttribute( field, uiConfigName, attribute );
m_summaryPreferences->defineEditorAttribute( field, uiConfigName, attribute );
{
caf::PdmUiFilePathEditorAttribute* myAttr = dynamic_cast<caf::PdmUiFilePathEditorAttribute*>( attribute );

72
ApplicationLibCode/Application/RiaPreferencesSummary.cpp
View File

@ -22,6 +22,7 @@
#include "RiaPreferences.h"
#include "cafPdmUiCheckBoxEditor.h"
#include "cafPdmUiComboBoxEditor.h"
#include <algorithm>
@ -55,6 +56,7 @@ void RiaPreferencesSummary::SummaryReaderModeType::setUp()
addItem( RiaPreferencesSummary::SummaryReaderMode::OPM_COMMON, "OPM_COMMON", "ESMRY (opm-common)" );
setDefault( RiaPreferencesSummary::SummaryReaderMode::HDF5_OPM_COMMON );
}
} // namespace caf
CAF_PDM_SOURCE_INIT( RiaPreferencesSummary, "RiaPreferencesSummary" );
@ -137,6 +139,11 @@ RiaPreferencesSummary::RiaPreferencesSummary()
true,
"Use Multiple Threads for Import of Summary Files" );
caf::PdmUiNativeCheckBoxEditor::configureFieldForEditor( &m_useMultipleThreadsWhenLoadingSummaryCases );
CAF_PDM_InitFieldNoDefault( &m_defaultColumnCount, "DefaultNumberOfColumns", "Columns" );
m_defaultColumnCount = RiaDefines::ColumnCount::COLUMNS_2;
CAF_PDM_InitFieldNoDefault( &m_defaultRowsPerPage, "DefaultRowsPerPage", "Rows per Page" );
m_defaultRowsPerPage = RiaDefines::RowCount::ROWS_2;
}
//--------------------------------------------------------------------------------------------------
@ -221,6 +228,11 @@ void RiaPreferencesSummary::appendItemsToPlottingGroup( caf::PdmUiOrdering& uiOr
uiOrdering.add( &m_defaultSummaryCurvesTextFilter );
uiOrdering.add( &m_defaultSummaryHistoryCurveStyle );
uiOrdering.add( &m_showSummaryTimeAsLongString );
auto multiGroup = uiOrdering.addNewGroup( "Multi Plot Defaults" );
multiGroup->add( &m_defaultColumnCount );
multiGroup->add( &m_defaultRowsPerPage );
}
//--------------------------------------------------------------------------------------------------
@ -316,6 +328,23 @@ void RiaPreferencesSummary::defineUiOrdering( QString uiConfigName, caf::PdmUiOr
uiOrdering.skipRemainingFields();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiaPreferencesSummary::defineEditorAttribute( const caf::PdmFieldHandle* field,
QString uiConfigName,
caf::PdmUiEditorAttribute* attribute )
{
if ( field == &m_defaultRowsPerPage || field == &m_defaultColumnCount )
{
auto myattr = dynamic_cast<caf::PdmUiComboBoxEditorAttribute*>( attribute );
if ( myattr )
{
myattr->iconSize = QSize( 24, 16 );
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -362,6 +391,49 @@ QList<caf::PdmOptionItemInfo>
options.push_back( caf::PdmOptionItemInfo( allowImport.uiText(),
RiaPreferencesSummary::SummaryRestartFilesImportMode::IMPORT ) );
}
else if ( fieldNeedingOptions == &m_defaultColumnCount )
{
for ( size_t i = 0; i < ColumnCountEnum::size(); ++i )
{
RiaDefines::ColumnCount enumVal = ColumnCountEnum::fromIndex( i );
QString columnCountString = ( enumVal == RiaDefines::ColumnCount::COLUMNS_UNLIMITED )
? "Unlimited"
: QString( "%1" ).arg( static_cast<int>( enumVal ) );
QString iconPath = QString( ":/Columns%1.png" ).arg( columnCountString );
options.push_back( caf::PdmOptionItemInfo( ColumnCountEnum::uiText( enumVal ),
enumVal,
false,
caf::IconProvider( iconPath, QSize( 24, 16 ) ) ) );
}
}
else if ( fieldNeedingOptions == &m_defaultRowsPerPage )
{
for ( size_t i = 0; i < RowCountEnum::size(); ++i )
{
RiaDefines::RowCount enumVal = RowCountEnum::fromIndex( i );
QString iconPath = QString( ":/Rows%1.png" ).arg( static_cast<int>( enumVal ) );
options.push_back( caf::PdmOptionItemInfo( RowCountEnum::uiText( enumVal ),
enumVal,
false,
caf::IconProvider( iconPath, QSize( 24, 16 ) ) ) );
}
}
return options;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaDefines::ColumnCount RiaPreferencesSummary::defaultMultiPlotColumnCount() const
{
return m_defaultColumnCount();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaDefines::RowCount RiaPreferencesSummary::defaultMultiPlotRowCount() const
{
return m_defaultRowsPerPage();
}

15
ApplicationLibCode/Application/RiaPreferencesSummary.h
View File

@ -22,6 +22,8 @@
#include "cafPdmField.h"
#include "cafPdmObject.h"
#include "RiaDefines.h"
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -54,6 +56,9 @@ public:
};
using SummaryHistoryCurveStyleModeType = caf::AppEnum<SummaryHistoryCurveStyleMode>;
using ColumnCountEnum = caf::AppEnum<RiaDefines::ColumnCount>;
using RowCountEnum = caf::AppEnum<RiaDefines::RowCount>;
public:
RiaPreferencesSummary();
@ -80,6 +85,13 @@ public:
SummaryHistoryCurveStyleMode defaultSummaryHistoryCurveStyle() const;
RiaDefines::ColumnCount defaultMultiPlotColumnCount() const;
RiaDefines::RowCount defaultMultiPlotRowCount() const;
void defineEditorAttribute( const caf::PdmFieldHandle* field,
QString uiConfigName,
caf::PdmUiEditorAttribute* attribute ) override;
protected:
void defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering ) override;
QList<caf::PdmOptionItemInfo> calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions,
@ -104,4 +116,7 @@ private:
caf::PdmField<int> m_createH5SummaryFileThreadCount;
caf::PdmField<SummaryReaderModeType> m_summaryReader;
caf::PdmField<ColumnCountEnum> m_defaultColumnCount;
caf::PdmField<RowCountEnum> m_defaultRowsPerPage;
};

6
ApplicationLibCode/Application/Tools/RiaImportEclipseCaseTools.cpp
View File

@ -20,6 +20,7 @@
#include "ApplicationCommands/RicShowMainWindowFeature.h"
#include "PlotBuilderCommands/RicSummaryPlotBuilder.h"
#include "SummaryPlotCommands/RicNewSummaryCurveFeature.h"
#include "SummaryPlotCommands/RicSummaryPlotFeatureImpl.h"
@ -195,10 +196,7 @@ bool RiaImportEclipseCaseTools::openEclipseCasesFromFile( const QStringList&
if ( !newSumCases.empty() )
{
RimSummaryPlotCollection* summaryPlotColl = project->mainPlotCollection()->summaryPlotCollection();
RicSummaryPlotFeatureImpl::ensureAtLeastOnePlot( summaryPlotColl, newSumCases.front() );
RicSummaryPlotBuilder::createAndAppendDefaultSummaryMultiPlot( { newSumCases.front() }, {} );
RiuPlotMainWindowTools::setExpanded( newSumCases.front() );
}
}

93
ApplicationLibCode/Commands/PlotBuilderCommands/RicNewSummaryMultiPlotFeature.cpp
View File

@ -18,8 +18,12 @@
#include "RicNewSummaryMultiPlotFeature.h"
#include "RimMultiPlotCollection.h"
#include "RicSummaryPlotBuilder.h"
#include "RimSummaryCase.h"
#include "RimSummaryCaseCollection.h"
#include "RimSummaryMultiPlot.h"
#include "RimSummaryMultiPlotCollection.h"
#include "RimSummaryPlot.h"
#include "RicSummaryPlotBuilder.h"
@ -29,27 +33,23 @@
#include <QAction>
RICF_SOURCE_INIT( RicNewSummaryMultiPlotFeature, "RicNewSummaryMultiPlotFeature", "createSummaryMultiPlot" );
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RicNewSummaryMultiPlotFeature::RicNewSummaryMultiPlotFeature()
{
CAF_PDM_InitFieldNoDefault( &m_plots, "plots", "Plots" );
}
CAF_CMD_SOURCE_INIT( RicNewSummaryMultiPlotFeature, "RicNewSummaryMultiPlotFeature" );
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RicNewSummaryMultiPlotFeature::isCommandEnabled()
{
auto plots = selectedPlots();
std::vector<caf::PdmUiItem*> selectedUiItems;
caf::SelectionManager::instance()->selectedItems( selectedUiItems );
return !plots.empty() && plots.size() == selectedUiItems.size();
if ( selectedCollection( selectedUiItems ) ) return true;
std::vector<RimSummaryCase*> selectedIndividualSummaryCases;
std::vector<RimSummaryCaseCollection*> selectedEnsembles;
if ( selectedCases( &selectedIndividualSummaryCases, &selectedEnsembles ) ) return true;
return false;
}
//--------------------------------------------------------------------------------------------------
@ -57,13 +57,25 @@ bool RicNewSummaryMultiPlotFeature::isCommandEnabled()
//--------------------------------------------------------------------------------------------------
void RicNewSummaryMultiPlotFeature::onActionTriggered( bool isChecked )
{
m_plots.v().clear();
auto plots = selectedPlots();
for ( RimPlot* plot : plots )
std::vector<caf::PdmUiItem*> selectedUiItems;
caf::SelectionManager::instance()->selectedItems( selectedUiItems );
RimSummaryMultiPlotCollection* coll = selectedCollection( selectedUiItems );
if ( coll )
{
m_plots.v().push_back( reinterpret_cast<uintptr_t>( plot ) );
std::vector<caf::PdmObjectHandle*> objects = {};
RimSummaryMultiPlot* multiPlot = RicSummaryPlotBuilder::createAndAppendSummaryMultiPlot( objects );
return;
}
std::vector<RimSummaryCase*> selectedIndividualSummaryCases;
std::vector<RimSummaryCaseCollection*> selectedEnsembles;
if ( selectedCases( &selectedIndividualSummaryCases, &selectedEnsembles ) )
{
RicSummaryPlotBuilder::createAndAppendDefaultSummaryMultiPlot( selectedIndividualSummaryCases, selectedEnsembles );
}
execute();
}
//--------------------------------------------------------------------------------------------------
@ -71,47 +83,42 @@ void RicNewSummaryMultiPlotFeature::onActionTriggered( bool isChecked )
//--------------------------------------------------------------------------------------------------
void RicNewSummaryMultiPlotFeature::setupActionLook( QAction* actionToSetup )
{
actionToSetup->setText( "Create Summary Multi Plot from Selected Plots" );
actionToSetup->setText( "New Summary Plot" );
actionToSetup->setIcon( QIcon( ":/MultiPlot16x16.png" ) );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimSummaryPlot*> RicNewSummaryMultiPlotFeature::selectedPlots()
RimSummaryMultiPlotCollection* RicNewSummaryMultiPlotFeature::selectedCollection( std::vector<caf::PdmUiItem*>& items )
{
std::vector<caf::PdmUiItem*> uiItems;
caf::SelectionManager::instance()->selectedItems( uiItems );
std::vector<RimSummaryPlot*> plots;
for ( caf::PdmUiItem* uiItem : uiItems )
for ( caf::PdmUiItem* uiItem : items )
{
RimSummaryPlot* summaryPlot = dynamic_cast<RimSummaryPlot*>( uiItem );
if ( summaryPlot )
{
plots.push_back( summaryPlot );
}
RimSummaryMultiPlotCollection* coll = dynamic_cast<RimSummaryMultiPlotCollection*>( uiItem );
if ( coll ) return coll;
}
return plots;
return nullptr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
caf::PdmScriptResponse RicNewSummaryMultiPlotFeature::execute()
bool RicNewSummaryMultiPlotFeature::selectedCases( std::vector<RimSummaryCase*>* selectedIndividualSummaryCases,
std::vector<RimSummaryCaseCollection*>* selectedEnsembles )
{
if ( !m_plots().empty() )
CAF_ASSERT( selectedIndividualSummaryCases && selectedEnsembles );
caf::SelectionManager::instance()->objectsByTypeStrict( selectedEnsembles );
if ( !selectedEnsembles->empty() )
{
std::vector<RimSummaryPlot*> plots;
for ( auto ptr : m_plots() )
{
plots.push_back( reinterpret_cast<RimSummaryPlot*>( ptr ) );
}
auto copyOfPlots = RicSummaryPlotBuilder::duplicateSummaryPlots( plots );
RicSummaryPlotBuilder::createAndAppendSummaryMultiPlot( copyOfPlots );
return true;
}
// Second try selected summary cases
caf::SelectionManager::instance()->objectsByTypeStrict( selectedIndividualSummaryCases );
if ( !selectedIndividualSummaryCases->empty() )
{
return true;
}
return caf::PdmScriptResponse();
return false;
}

21
ApplicationLibCode/Commands/PlotBuilderCommands/RicNewSummaryMultiPlotFeature.h
View File

@ -18,26 +18,22 @@
#pragma once
#include "RicfCommandObject.h"
#include "cafCmdFeature.h"
#include "cafPdmField.h"
#include "cafPdmUiItem.h"
#include <vector>
class RimSummaryPlot;
class RimSummaryMultiPlotCollection;
class RimSummaryCase;
class RimSummaryCaseCollection;
//==================================================================================================
///
//==================================================================================================
class RicNewSummaryMultiPlotFeature : public caf::CmdFeature, public RicfCommandObject
class RicNewSummaryMultiPlotFeature : public caf::CmdFeature
{
RICF_HEADER_INIT;
public:
RicNewSummaryMultiPlotFeature();
caf::PdmScriptResponse execute() override;
CAF_CMD_HEADER_INIT;
protected:
bool isCommandEnabled() override;
@ -45,7 +41,8 @@ protected:
void setupActionLook( QAction* actionToSetup ) override;
private:
static std::vector<RimSummaryPlot*> selectedPlots();
RimSummaryMultiPlotCollection* selectedCollection( std::vector<caf::PdmUiItem*>& items );
caf::PdmField<std::vector<uint64_t>> m_plots;
bool selectedCases( std::vector<RimSummaryCase*>* selectedIndividualSummaryCases,
std::vector<RimSummaryCaseCollection*>* selectedEnsembles );
};

2
ApplicationLibCode/Commands/PlotBuilderCommands/RicNewSummaryMultiPlotFromDataVectorFeature.cpp
View File

@ -110,6 +110,6 @@ void RicNewSummaryMultiPlotFromDataVectorFeature::onActionTriggered( bool isChec
//--------------------------------------------------------------------------------------------------
void RicNewSummaryMultiPlotFromDataVectorFeature::setupActionLook( QAction* actionToSetup )
{
actionToSetup->setText( "New Multi Summary Plot" );
actionToSetup->setText( "New Summary Plot" );
actionToSetup->setIcon( QIcon( ":/SummaryPlotLight16x16.png" ) );
}

57
ApplicationLibCode/Commands/PlotBuilderCommands/RicSummaryPlotBuilder.cpp
View File

@ -18,6 +18,9 @@
#include "RicSummaryPlotBuilder.h"
#include "SummaryPlotCommands/RicNewSummaryEnsembleCurveSetFeature.h"
#include "SummaryPlotCommands/RicSummaryPlotFeatureImpl.h"
#include "RiaSummaryAddressAnalyzer.h"
#include "RiaSummaryTools.h"
@ -357,7 +360,8 @@ RimSummaryMultiPlot*
plotCollection->updateAllRequiredEditors();
plotWindow->loadDataAndUpdate();
RiuPlotMainWindowTools::selectAsCurrentItem( plotWindow, true );
RiuPlotMainWindowTools::selectAsCurrentItem( plotWindow );
RiuPlotMainWindowTools::setExpanded( plotWindow, true );
return plotWindow;
}
@ -369,7 +373,7 @@ void RicSummaryPlotBuilder::appendPlotsToMultiPlot( RimMultiPlot* multiPlot, con
{
for ( auto plot : plots )
{
// Remove the currently window controller, as this will be managed by the multi plot
// Remove the current window controller, as this will be managed by the multi plot
// This must be done before adding the plot to the multi plot to ensure that the viewer widget is recreated
plot->revokeMdiWindowStatus();
@ -382,6 +386,50 @@ void RicSummaryPlotBuilder::appendPlotsToMultiPlot( RimMultiPlot* multiPlot, con
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimSummaryMultiPlot*
RicSummaryPlotBuilder::createAndAppendDefaultSummaryMultiPlot( const std::vector<RimSummaryCase*>& cases,
const std::vector<RimSummaryCaseCollection*>& ensembles )
{
RimProject* project = RimProject::current();
auto* plotCollection = project->mainPlotCollection()->summaryMultiPlotCollection();
auto* plotWindow = new RimSummaryMultiPlot();
plotWindow->setAsPlotMdiWindow();
plotCollection->addSummaryMultiPlot( plotWindow );
RimSummaryPlot* plot = new RimSummaryPlot();
plot->setAsPlotMdiWindow();
plot->enableAutoPlotTitle( true );
for ( auto sumCase : cases )
{
RicSummaryPlotFeatureImpl::addDefaultCurvesToPlot( plot, sumCase );
}
for ( auto ensemble : ensembles )
{
RicNewSummaryEnsembleCurveSetFeature::addDefaultCurveSets( plot, ensemble );
}
plot->applyDefaultCurveAppearances();
plot->loadDataAndUpdate();
plotCollection->updateConnectedEditors();
appendPlotsToSummaryMultiPlot( plotWindow, { plot } );
plotCollection->updateAllRequiredEditors();
plotWindow->loadDataAndUpdate();
plotWindow->updateAllRequiredEditors();
RiuPlotMainWindowTools::selectAsCurrentItem( plotWindow );
return plotWindow;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -391,7 +439,6 @@ RimSummaryMultiPlot* RicSummaryPlotBuilder::createAndAppendSummaryMultiPlot( con
auto* plotCollection = project->mainPlotCollection()->summaryMultiPlotCollection();
auto* plotWindow = new RimSummaryMultiPlot();
plotWindow->setMultiPlotTitle( QString( "Multi Summary Plot %1" ).arg( plotCollection->multiPlots().size() + 1 ) );
plotWindow->setAsPlotMdiWindow();
plotCollection->addSummaryMultiPlot( plotWindow );
@ -399,10 +446,10 @@ RimSummaryMultiPlot* RicSummaryPlotBuilder::createAndAppendSummaryMultiPlot( con
plotCollection->updateAllRequiredEditors();
plotWindow->loadDataAndUpdate();
RiuPlotMainWindowTools::selectAsCurrentItem( plotWindow, true );
plotWindow->updateAllRequiredEditors();
RiuPlotMainWindowTools::selectAsCurrentItem( plotWindow );
return plotWindow;
}

4
ApplicationLibCode/Commands/PlotBuilderCommands/RicSummaryPlotBuilder.h
View File

@ -75,6 +75,10 @@ public:
static RimMultiPlot* createAndAppendMultiPlot( const std::vector<RimPlot*>& plots );
static void appendPlotsToMultiPlot( RimMultiPlot* multiPlot, const std::vector<RimPlot*>& plots );
static RimSummaryMultiPlot*
createAndAppendDefaultSummaryMultiPlot( const std::vector<RimSummaryCase*>& cases,
const std::vector<RimSummaryCaseCollection*>& ensembles );
static RimSummaryMultiPlot* createAndAppendSummaryMultiPlot( const std::vector<RimSummaryPlot*>& plots );
static RimSummaryMultiPlot* createAndAppendSummaryMultiPlot( const std::vector<caf::PdmObjectHandle*>& objects );
static void appendPlotsToSummaryMultiPlot( RimSummaryMultiPlot* multiPlot, const std::vector<RimSummaryPlot*>& plots );

3
ApplicationLibCode/Commands/RicImportEnsembleFeature.cpp
View File

@ -44,6 +44,7 @@
#include "RiuMainWindow.h"
#include "RiuPlotMainWindow.h"
#include "PlotBuilderCommands/RicSummaryPlotBuilder.h"
#include "SummaryPlotCommands/RicNewSummaryEnsembleCurveSetFeature.h"
#include <QAction>
@ -123,7 +124,7 @@ void RicImportEnsembleFeature::importSingleEnsemble( const QStringList&
summaryCase->updateAutoShortName();
}
RicNewSummaryEnsembleCurveSetFeature::createPlotForCurveSetsAndUpdate( { ensemble } );
RicSummaryPlotBuilder::createAndAppendDefaultSummaryMultiPlot( {}, { ensemble } );
}
std::vector<RimCase*> allCases;

11
ApplicationLibCode/Commands/RicImportSummaryCasesFeature.cpp
View File

@ -36,6 +36,7 @@
#include "RimSummaryCase.h"
#include "RimSummaryCaseCollection.h"
#include "RimSummaryCaseMainCollection.h"
#include "RimSummaryMultiPlot.h"
#include "RimSummaryPlot.h"
#include "RimSummaryPlotCollection.h"
@ -43,6 +44,7 @@
#include "RiuPlotMainWindow.h"
#include "RiuPlotMainWindowTools.h"
#include "PlotBuilderCommands/RicSummaryPlotBuilder.h"
#include "SummaryPlotCommands/RicNewSummaryEnsembleCurveSetFeature.h"
#include "SummaryPlotCommands/RicSummaryPlotFeatureImpl.h"
@ -83,11 +85,9 @@ void RicImportSummaryCasesFeature::onActionTriggered( bool isChecked )
addSummaryCases( cases );
if ( !cases.empty() )
{
auto objectToSelect = RicSummaryPlotFeatureImpl::createDefaultSummaryPlot( cases.front() );
if ( objectToSelect )
for ( auto sumcase : cases )
{
RiuPlotMainWindowTools::setExpanded( objectToSelect );
RiuPlotMainWindowTools::selectAsCurrentItem( objectToSelect );
RicSummaryPlotBuilder::createAndAppendDefaultSummaryMultiPlot( { sumcase }, {} );
}
}
@ -136,7 +136,8 @@ bool RicImportSummaryCasesFeature::createAndAddSummaryCasesFromFiles( const QStr
addSummaryCases( *cases );
if ( !cases->empty() && doCreateDefaultPlot )
{
auto objectToSelect = RicSummaryPlotFeatureImpl::createDefaultSummaryPlot( cases->back() );
auto objectToSelect = RicSummaryPlotBuilder::createAndAppendDefaultSummaryMultiPlot( { cases->back() }, {} );
if ( objectToSelect )
{
RiuPlotMainWindowTools::setExpanded( objectToSelect );

25
ApplicationLibCode/Commands/SummaryPlotCommands/RicNewDefaultSummaryPlotFeature.cpp
View File

@ -20,6 +20,7 @@
#include "RiaSummaryTools.h"
#include "PlotBuilderCommands/RicSummaryPlotBuilder.h"
#include "RicEditSummaryPlotFeature.h"
#include "RicNewSummaryCurveFeature.h"
#include "RicNewSummaryEnsembleCurveSetFeature.h"
@ -36,6 +37,7 @@
#include "RimSummaryCase.h"
#include "RimSummaryCaseCollection.h"
#include "RimSummaryCaseMainCollection.h"
#include "RimSummaryMultiPlot.h"
#include "RimSummaryPlot.h"
#include "RimSummaryPlotCollection.h"
@ -129,6 +131,13 @@ RimSummaryPlot* RicNewDefaultSummaryPlotFeature::createFromSummaryCases( RimSumm
//--------------------------------------------------------------------------------------------------
bool RicNewDefaultSummaryPlotFeature::isCommandEnabled()
{
RimSummaryMultiPlot* multiPlot =
dynamic_cast<RimSummaryMultiPlot*>( caf::SelectionManager::instance()->selectedItem() );
if ( multiPlot )
{
return true;
}
std::vector<RimSummaryCase*> selectedIndividualSummaryCases;
std::vector<RimSummaryCaseCollection*> selectedEnsembles;
@ -152,6 +161,16 @@ bool RicNewDefaultSummaryPlotFeature::isCommandEnabled()
//--------------------------------------------------------------------------------------------------
void RicNewDefaultSummaryPlotFeature::onActionTriggered( bool isChecked )
{
RimSummaryMultiPlot* multiPlot =
dynamic_cast<RimSummaryMultiPlot*>( caf::SelectionManager::instance()->selectedItem() );
if ( multiPlot )
{
RimSummaryPlot* plot = new RimSummaryPlot();
plot->enableAutoPlotTitle( true );
RicSummaryPlotBuilder::appendPlotsToSummaryMultiPlot( multiPlot, { plot } );
return;
}
std::vector<RimSummaryCase*> selectedIndividualSummaryCases;
std::vector<RimSummaryCaseCollection*> selectedEnsembles;
extractPlotObjectsFromSelection( &selectedIndividualSummaryCases, &selectedEnsembles );
@ -178,13 +197,13 @@ void RicNewDefaultSummaryPlotFeature::setupActionLook( QAction* actionToSetup )
extractPlotObjectsFromSelection( &selectedIndividualSummaryCases, &selectedEnsembles );
if ( !selectedIndividualSummaryCases.empty() )
if ( !selectedEnsembles.empty() )
{
actionToSetup->setText( "New Summary Plot" );
actionToSetup->setText( "Add Ensemble Summary Plot" );
}
else
{
actionToSetup->setText( "New Ensemble Summary Plot" );
actionToSetup->setText( "Add Summary Plot" );
}
actionToSetup->setIcon( QIcon( ":/SummaryPlotLight16x16.png" ) );
}

4
ApplicationLibCode/Commands/SummaryPlotCommands/RicNewSummaryEnsembleCurveSetFeature.h
View File

@ -35,15 +35,13 @@ class RicNewSummaryEnsembleCurveSetFeature : public caf::CmdFeature
public:
static RimSummaryPlot* createPlotForCurveSetsAndUpdate( std::vector<RimSummaryCaseCollection*> ensembles );
static std::vector<RimEnsembleCurveSet*> addDefaultCurveSets( RimSummaryPlot* plot, RimSummaryCaseCollection* ensemble );
protected:
bool isCommandEnabled() override;
void onActionTriggered( bool isChecked ) override;
void setupActionLook( QAction* actionToSetup ) override;
private:
static std::vector<RimEnsembleCurveSet*> addDefaultCurveSets( RimSummaryPlot* plot, RimSummaryCaseCollection* ensemble );
private:
RimSummaryPlot* selectedSummaryPlot() const;
};

89
ApplicationLibCode/Commands/SummaryPlotCommands/RicSummaryPlotEditorUi.cpp
View File

@ -42,6 +42,7 @@
#include "RimSummaryCurve.h"
#include "RimSummaryCurveAutoName.h"
#include "RimSummaryCurveCollection.h"
#include "RimSummaryMultiPlot.h"
#include "RimSummaryPlot.h"
#include "RimSummaryPlotCollection.h"
@ -83,6 +84,7 @@ std::vector<T> toVector( const std::set<T>& set );
///
//--------------------------------------------------------------------------------------------------
RicSummaryPlotEditorUi::RicSummaryPlotEditorUi()
: m_plotContainer( nullptr )
{
CAF_PDM_InitFieldNoDefault( &m_targetPlot, "TargetPlot", "Target Plot" );
@ -162,6 +164,7 @@ void RicSummaryPlotEditorUi::updateFromSummaryPlot( RimSummaryPlot*
if ( m_targetPlot )
{
targetPlot->firstAncestorOfType( m_plotContainer );
populateCurveCreator( *m_targetPlot );
syncPreviewCurvesFromUiSelection();
setInitialCurveVisibility( targetPlot );
@ -172,6 +175,7 @@ void RicSummaryPlotEditorUi::updateFromSummaryPlot( RimSummaryPlot*
setDefaultCurveSelection( defaultSources );
m_previewPlot->enableAutoPlotTitle( true );
syncPreviewCurvesFromUiSelection();
m_plotContainer = nullptr;
}
caf::PdmUiItem::updateConnectedEditors();
@ -262,19 +266,25 @@ QList<caf::PdmOptionItemInfo>
{
QList<caf::PdmOptionItemInfo> options;
if ( fieldNeedingOptions == &m_targetPlot )
if ( m_targetPlot && ( fieldNeedingOptions == &m_targetPlot ) )
{
RimProject* proj = RimProject::current();
RimSummaryPlotCollection* summaryPlotColl = proj->mainPlotCollection()->summaryPlotCollection();
// Create New Plot item
QString displayName = "( New Plot )";
options.push_back( caf::PdmOptionItemInfo( displayName, nullptr ) );
if ( summaryPlotColl )
if ( m_plotContainer )
{
summaryPlotColl->summaryPlotItemInfos( &options );
m_plotContainer->summaryPlotItemInfos( &options );
}
else
{
RimProject* proj = RimProject::current();
RimSummaryPlotCollection* summaryPlotColl = proj->mainPlotCollection()->summaryPlotCollection();
if ( summaryPlotColl )
{
summaryPlotColl->summaryPlotItemInfos( &options );
}
}
}
@ -841,52 +851,39 @@ void RicSummaryPlotEditorUi::createNewPlot()
{
RimProject* proj = RimProject::current();
RimSummaryPlot* newSummaryPlot = nullptr;
RimSummaryPlotCollection* summaryPlotColl = proj->mainPlotCollection()->summaryPlotCollection();
if ( summaryPlotColl )
if ( m_plotContainer )
{
RimSummaryPlot* newSummaryPlot = nullptr;
if ( m_useAutoPlotTitleProxy() )
newSummaryPlot = new RimSummaryPlot();
newSummaryPlot->setAsPlotMdiWindow();
newSummaryPlot->enableAutoPlotTitle( true );
m_plotContainer->addPlot( newSummaryPlot );
}
else if ( summaryPlotColl )
{
newSummaryPlot = summaryPlotColl->createSummaryPlotWithAutoTitle();
}
if ( newSummaryPlot )
{
newSummaryPlot->loadDataAndUpdate();
if ( m_plotContainer )
{
newSummaryPlot = summaryPlotColl->createSummaryPlotWithAutoTitle();
m_plotContainer->updateConnectedEditors();
}
else
else if ( summaryPlotColl )
{
QString candidatePlotName;
if ( m_previewPlot )
{
candidatePlotName = m_previewPlot->generatedPlotTitleFromAllCurves();
}
{
bool ok = false;
candidatePlotName = QInputDialog::getText( nullptr,
"New Summary Plot Name",
"New Summary Plot Name",
QLineEdit::Normal,
candidatePlotName,
&ok,
RiuTools::defaultDialogFlags() );
if ( !ok )
{
return;
}
newSummaryPlot = summaryPlotColl->createNamedSummaryPlot( candidatePlotName );
}
}
if ( newSummaryPlot )
{
newSummaryPlot->loadDataAndUpdate();
summaryPlotColl->updateConnectedEditors();
m_targetPlot = newSummaryPlot;
updateTargetPlot();
RiuPlotMainWindow* mainPlotWindow = RiaGuiApplication::instance()->mainPlotWindow();
mainPlotWindow->updateSummaryPlotToolBar();
}
m_targetPlot = newSummaryPlot;
RiuPlotMainWindow* mainPlotWindow = RiaGuiApplication::instance()->mainPlotWindow();
mainPlotWindow->updateSummaryPlotToolBar();
}
}

3
ApplicationLibCode/Commands/SummaryPlotCommands/RicSummaryPlotEditorUi.h
View File

@ -41,6 +41,7 @@ class PdmObject;
};
class RimSummaryCase;
class RimSummaryMultiPlot;
class RimSummaryCurveAutoName;
class RimSummaryPlot;
class RiaSummaryCurveDefinition;
@ -133,4 +134,6 @@ private:
caf::PdmField<bool> m_closeButtonField;
std::unique_ptr<RiuSummaryVectorSelectionWidgetCreator> m_summaryCurveSelectionEditor;
RimSummaryMultiPlot* m_plotContainer;
};

56
ApplicationLibCode/Commands/SummaryPlotCommands/RicSummaryPlotFeatureImpl.cpp
View File

@ -51,6 +51,7 @@
#include "RimProject.h"
#include "RimSummaryCase.h"
#include "RimSummaryCurve.h"
#include "RimSummaryMultiPlotCollection.h"
#include "RimSummaryPlot.h"
#include "RimSummaryPlotCollection.h"
@ -78,61 +79,6 @@ std::vector<RimSummaryCurve*> RicSummaryPlotFeatureImpl::addDefaultCurvesToPlot(
return addCurvesFromAddressFiltersToPlot( curveFilters, plot, summaryCase, addHistoryCurve );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicSummaryPlotFeatureImpl::ensureAtLeastOnePlot( RimSummaryPlotCollection* summaryPlotCollection,
RimSummaryCase* summaryCase )
{
if ( summaryPlotCollection && summaryCase )
{
if ( summaryPlotCollection->plots().empty() )
{
auto objectToSelect = createDefaultSummaryPlot( summaryCase );
if ( objectToSelect )
{
RiuPlotMainWindowTools::setExpanded( objectToSelect );
RiuPlotMainWindowTools::selectAsCurrentItem( objectToSelect );
}
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
caf::PdmObject* RicSummaryPlotFeatureImpl::createDefaultSummaryPlot( RimSummaryCase* summaryCase )
{
RimSummaryPlotCollection* summaryPlotCollection = RimProject::current()->mainPlotCollection->summaryPlotCollection();
RiaPreferencesSummary* prefs = RiaPreferencesSummary::current();
caf::PdmObject* itemToSelect = nullptr;
if ( summaryPlotCollection && summaryCase && !prefs->defaultSummaryCurvesTextFilter().isEmpty() )
{
auto plot = summaryPlotCollection->createSummaryPlotWithAutoTitle();
std::vector<RimSummaryCurve*> curves = RicSummaryPlotFeatureImpl::addDefaultCurvesToPlot( plot, summaryCase );
plot->applyDefaultCurveAppearances();
plot->loadDataAndUpdate();
summaryPlotCollection->updateConnectedEditors();
if ( curves.size() )
{
itemToSelect = curves[0];
}
else
{
itemToSelect = plot;
}
}
return itemToSelect;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

10
ApplicationLibCode/Commands/WellLogCommands/RicDeleteSubPlotFeature.cpp
View File

@ -77,6 +77,12 @@ void RicDeleteSubPlotFeature::onActionTriggered( bool isChecked )
caf::SelectionManager::instance()->objectsByType( &selection );
std::set<RimPlotWindow*> alteredPlotWindows;
for ( RimPlot* plot : selection )
{
if ( !plot ) continue;
caf::SelectionManager::instance()->removeObjectFromAllSelections( plot );
}
for ( RimPlot* plot : selection )
{
if ( !plot ) continue;
@ -89,8 +95,6 @@ void RicDeleteSubPlotFeature::onActionTriggered( bool isChecked )
{
alteredPlotWindows.insert( multiPlot );
multiPlot->removePlot( plot );
caf::SelectionManager::instance()->removeObjectFromAllSelections( plot );
multiPlot->updateConnectedEditors();
delete plot;
}
@ -98,8 +102,6 @@ void RicDeleteSubPlotFeature::onActionTriggered( bool isChecked )
{
alteredPlotWindows.insert( wellLogPlot );
wellLogPlot->removePlot( plot );
caf::SelectionManager::instance()->removeObjectFromAllSelections( plot );
wellLogPlot->updateConnectedEditors();
delete plot;
}

17
ApplicationLibCode/ProjectDataModel/RimContextCommandBuilder.cpp
View File

@ -126,6 +126,8 @@
#include "RimSummaryCrossPlotCollection.h"
#include "RimSummaryCurve.h"
#include "RimSummaryCurveCollection.h"
#include "RimSummaryMultiPlot.h"
#include "RimSummaryMultiPlotCollection.h"
#include "RimSummaryPlot.h"
#include "RimSummaryPlotCollection.h"
#include "RimSurface.h"
@ -564,6 +566,10 @@ caf::CmdFeatureMenuBuilder RimContextCommandBuilder::commandsFromSelection()
menuBuilder << "Separator";
menuBuilder << "RicShowSummaryCurveCalculatorFeature";
}
else if ( dynamic_cast<RimSummaryMultiPlotCollection*>( firstUiItem ) )
{
menuBuilder << "RicNewSummaryMultiPlotFeature";
}
else if ( dynamic_cast<RimAnalysisPlotCollection*>( firstUiItem ) )
{
menuBuilder << "RicNewAnalysisPlotFeature";
@ -768,6 +774,7 @@ caf::CmdFeatureMenuBuilder RimContextCommandBuilder::commandsFromSelection()
menuBuilder << "RicImportEnsembleFeature";
menuBuilder.subMenuEnd();
menuBuilder.addSeparator();
menuBuilder << "RicNewSummaryMultiPlotFeature";
menuBuilder << "RicNewDerivedEnsembleFeature";
menuBuilder << "RicOpenSummaryPlotEditorFeature";
menuBuilder << "RicNewDefaultSummaryPlotFeature";
@ -785,6 +792,7 @@ caf::CmdFeatureMenuBuilder RimContextCommandBuilder::commandsFromSelection()
menuBuilder << "RicImportEnsembleFeature";
menuBuilder.subMenuEnd();
menuBuilder.addSeparator();
menuBuilder << "RicNewSummaryMultiPlotFeature";
menuBuilder << "RicOpenSummaryPlotEditorFeature";
menuBuilder << "RicNewDefaultSummaryPlotFeature";
menuBuilder << "RicNewSummaryCrossPlotFeature";
@ -1023,6 +1031,12 @@ caf::CmdFeatureMenuBuilder RimContextCommandBuilder::commandsFromSelection()
{
menuBuilder << "RicReloadPlotTemplatesFeature";
}
else if ( dynamic_cast<RimSummaryMultiPlot*>( firstUiItem ) )
{
menuBuilder << "RicNewDefaultSummaryPlotFeature";
menuBuilder << "Separator";
menuBuilder << "RicSnapshotViewToPdfFeature";
}
else if ( dynamic_cast<RimMultiPlot*>( firstUiItem ) )
{
menuBuilder << "RicSnapshotViewToPdfFeature";
@ -1062,10 +1076,10 @@ caf::CmdFeatureMenuBuilder RimContextCommandBuilder::commandsFromSelection()
menuBuilder << "RicShowPlotDataFeature";
menuBuilder << "RicShowTotalAllocationDataFeature";
menuBuilder << "RicNewSummaryMultiPlotFeature";
menuBuilder << "RicNewDerivedEnsembleFeature";
menuBuilder << "RicOpenSummaryPlotEditorFeature";
menuBuilder << "RicNewDefaultSummaryPlotFeature";
menuBuilder << "RicNewSummaryMultiPlotFeature";
menuBuilder << "RicNewSummaryCrossPlotFeature";
menuBuilder << "RicSummaryCurveSwitchAxisFeature";
menuBuilder << "RicNewDerivedSummaryFeature";
@ -1188,7 +1202,6 @@ caf::CmdFeatureMenuBuilder RimContextCommandBuilder::commandsFromSelection()
}
else if ( dynamic_cast<RimSummaryAddress*>( firstUiItem ) )
{
menuBuilder << "RicNewSummaryPlotFromDataVectorFeature";
menuBuilder << "RicNewSummaryMultiPlotFromDataVectorFeature";
}
#ifdef USE_ODB_API

51
ApplicationLibCode/ProjectDataModel/RimMultiPlot.cpp
View File

@ -19,6 +19,7 @@
#include "RimMultiPlot.h"
#include "RiaPreferences.h"
#include "RiaPreferencesSummary.h"
#include "RimPlot.h"
#include "RimProject.h"
@ -37,29 +38,6 @@
#include <cvfAssert.h>
namespace caf
{
template <>
void RimMultiPlot::ColumnCountEnum::setUp()
{
addItem( RimMultiPlot::ColumnCount::COLUMNS_1, "1", "1 Column" );
addItem( RimMultiPlot::ColumnCount::COLUMNS_2, "2", "2 Columns" );
addItem( RimMultiPlot::ColumnCount::COLUMNS_3, "3", "3 Columns" );
addItem( RimMultiPlot::ColumnCount::COLUMNS_4, "4", "4 Columns" );
setDefault( RimMultiPlot::ColumnCount::COLUMNS_2 );
}
template <>
void RimMultiPlot::RowCountEnum::setUp()
{
addItem( RimMultiPlot::RowCount::ROWS_1, "1", "1 Row" );
addItem( RimMultiPlot::RowCount::ROWS_2, "2", "2 Rows" );
addItem( RimMultiPlot::RowCount::ROWS_3, "3", "3 Rows" );
addItem( RimMultiPlot::RowCount::ROWS_4, "4", "4 Rows" );
setDefault( RimMultiPlot::RowCount::ROWS_2 );
}
} // namespace caf
CAF_PDM_SOURCE_INIT( RimMultiPlot, "MultiPlot" );
//--------------------------------------------------------------------------------------------------
@ -77,8 +55,11 @@ RimMultiPlot::RimMultiPlot()
auto reorderability = caf::PdmFieldReorderCapability::addToField( &m_plots );
reorderability->orderChanged.connect( this, &RimMultiPlot::onPlotsReordered );
RiaPreferencesSummary* sumPrefs = RiaPreferencesSummary::current();
CAF_PDM_InitFieldNoDefault( &m_columnCount, "NumberOfColumns", "Number of Columns" );
m_columnCount = sumPrefs->defaultMultiPlotColumnCount();
CAF_PDM_InitFieldNoDefault( &m_rowsPerPage, "RowsPerPage", "Rows per Page" );
m_rowsPerPage = sumPrefs->defaultMultiPlotRowCount();
CAF_PDM_InitField( &m_showIndividualPlotTitles, "ShowPlotTitles", true, "Show Sub Plot Titles" );
CAF_PDM_InitFieldNoDefault( &m_majorTickmarkCount, "MajorTickmarkCount", "Major Tickmark Count" );
@ -401,7 +382,7 @@ void RimMultiPlot::setAutoScaleYEnabled( bool enabled )
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimMultiPlot::setColumnCount( RiuMultiPlotPage::ColumnCount columnCount )
void RimMultiPlot::setColumnCount( RiaDefines::ColumnCount columnCount )
{
m_columnCount = columnCount;
}
@ -409,7 +390,7 @@ void RimMultiPlot::setColumnCount( RiuMultiPlotPage::ColumnCount columnCount )
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimMultiPlot::setRowCount( RowCount rowCount )
void RimMultiPlot::setRowCount( RiaDefines::RowCount rowCount )
{
m_rowsPerPage = rowCount;
}
@ -440,7 +421,7 @@ void RimMultiPlot::setTickmarkCount( RimPlot* plot, RimPlotAxisPropertiesInterfa
//--------------------------------------------------------------------------------------------------
int RimMultiPlot::columnCount() const
{
if ( m_columnCount() == ColumnCount::COLUMNS_UNLIMITED )
if ( m_columnCount() == RiaDefines::ColumnCount::COLUMNS_UNLIMITED )
{
return std::numeric_limits<int>::max();
}
@ -452,22 +433,22 @@ int RimMultiPlot::columnCount() const
//--------------------------------------------------------------------------------------------------
int RimMultiPlot::rowsPerPage() const
{
RimMultiPlot::RowCount rowEnum = m_rowsPerPage().value();
RiaDefines::RowCount rowEnum = m_rowsPerPage().value();
int rowCount = 2;
switch ( rowEnum )
{
case RimMultiPlot::RowCount::ROWS_1:
case RiaDefines::RowCount::ROWS_1:
rowCount = 1;
break;
case RimMultiPlot::RowCount::ROWS_2:
case RiaDefines::RowCount::ROWS_2:
rowCount = 2;
break;
case RimMultiPlot::RowCount::ROWS_3:
case RiaDefines::RowCount::ROWS_3:
rowCount = 3;
break;
case RimMultiPlot::RowCount::ROWS_4:
case RiaDefines::RowCount::ROWS_4:
rowCount = 4;
break;
default:
@ -754,8 +735,8 @@ QList<caf::PdmOptionItemInfo> RimMultiPlot::calculateValueOptions( const caf::Pd
{
for ( size_t i = 0; i < ColumnCountEnum::size(); ++i )
{
ColumnCount enumVal = ColumnCountEnum::fromIndex( i );
QString columnCountString = ( enumVal == ColumnCount::COLUMNS_UNLIMITED )
RiaDefines::ColumnCount enumVal = ColumnCountEnum::fromIndex( i );
QString columnCountString = ( enumVal == RiaDefines::ColumnCount::COLUMNS_UNLIMITED )
? "Unlimited"
: QString( "%1" ).arg( static_cast<int>( enumVal ) );
QString iconPath = QString( ":/Columns%1.png" ).arg( columnCountString );
@ -769,8 +750,8 @@ QList<caf::PdmOptionItemInfo> RimMultiPlot::calculateValueOptions( const caf::Pd
{
for ( size_t i = 0; i < RowCountEnum::size(); ++i )
{
RowCount enumVal = RowCountEnum::fromIndex( i );
QString iconPath = QString( ":/Rows%1.png" ).arg( static_cast<int>( enumVal ) );
RiaDefines::RowCount enumVal = RowCountEnum::fromIndex( i );
QString iconPath = QString( ":/Rows%1.png" ).arg( static_cast<int>( enumVal ) );
options.push_back( caf::PdmOptionItemInfo( RowCountEnum::uiText( enumVal ),
enumVal,
false,

21
ApplicationLibCode/ProjectDataModel/RimMultiPlot.h
View File

@ -18,6 +18,8 @@
#pragma once
#include "RiaDefines.h"
#include "RimAbstractPlotCollection.h"
#include "RimPlot.h"
#include "RimPlotAxisPropertiesInterface.h"
@ -44,19 +46,8 @@ class RimMultiPlot : public RimPlotWindow, public RimTypedPlotCollection<RimPlot
CAF_PDM_HEADER_INIT;
public:
using ColumnCount = RiuMultiPlotBook::ColumnCount;
using ColumnCountEnum = caf::AppEnum<ColumnCount>;
enum class RowCount
{
ROWS_1 = 1,
ROWS_2 = 2,
ROWS_3 = 3,
ROWS_4 = 4,
};
using RowCountEnum = caf::AppEnum<RowCount>;
friend class RimSummaryMultiPlot;
using ColumnCountEnum = caf::AppEnum<RiaDefines::ColumnCount>;
using RowCountEnum = caf::AppEnum<RiaDefines::RowCount>;
public:
RimMultiPlot();
@ -90,8 +81,8 @@ public:
void setAutoScaleXEnabled( bool enabled );
void setAutoScaleYEnabled( bool enabled );
void setColumnCount( RiuMultiPlotPage::ColumnCount columnCount );
void setRowCount( RimMultiPlot::RowCount rowCount );
void setColumnCount( RiaDefines::ColumnCount columnCount );
void setRowCount( RiaDefines::RowCount rowCount );
void setTickmarkCount( RimPlotAxisPropertiesInterface::LegendTickmarkCountEnum tickmarkCount );
int columnCount() const override;

2
ApplicationLibCode/ProjectDataModel/RimPlotWindow.cpp
View File

@ -211,7 +211,7 @@ void RimPlotWindow::updateParentLayout()
//--------------------------------------------------------------------------------------------------
int RimPlotWindow::columnCount() const
{
return static_cast<int>( RiuMultiPlotPage::ColumnCount::COLUMNS_UNLIMITED );
return static_cast<int>( RiaDefines::ColumnCount::COLUMNS_UNLIMITED );
}
//--------------------------------------------------------------------------------------------------

69
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryMultiPlot.cpp
View File

@ -327,6 +327,7 @@ void RimSummaryMultiPlot::updatePlotWindowTitle()
populateNameHelper( m_nameHelper.get() );
auto title = m_nameHelper->plotTitle();
if ( title.isEmpty() ) title = "Empty Plot";
setMultiPlotTitle( title );
}
@ -386,62 +387,6 @@ std::vector<RimSummaryPlot*> RimSummaryMultiPlot::summaryPlots() const
return typedPlots;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryMultiPlot::insertGraphsIntoPlot( RimSummaryMultiPlot* plot, const std::vector<RimSummaryPlot*>& graphs )
{
auto columnCount = RiuMultiPlotPage::ColumnCount::COLUMNS_2;
auto rowCount = RimMultiPlot::RowCount::ROWS_2;
auto tickmarkCount = RimPlotAxisPropertiesInterface::LegendTickmarkCount::TICKMARK_DEFAULT;
bool showTitleSubGraph = true;
if ( graphs.size() == 1 )
{
showTitleSubGraph = false;
tickmarkCount = RimPlotAxisPropertiesInterface::LegendTickmarkCount::TICKMARK_MANY;
}
else if ( 4 < graphs.size() && graphs.size() <= 6 )
{
columnCount = RiuMultiPlotPage::ColumnCount::COLUMNS_3;
rowCount = RimMultiPlot::RowCount::ROWS_2;
tickmarkCount = RimPlotAxisPropertiesInterface::LegendTickmarkCount::TICKMARK_FEW;
}
else if ( 6 < graphs.size() && graphs.size() <= 12 )
{
columnCount = RiuMultiPlotPage::ColumnCount::COLUMNS_4;
rowCount = RimMultiPlot::RowCount::ROWS_3;
tickmarkCount = RimPlotAxisPropertiesInterface::LegendTickmarkCount::TICKMARK_VERY_FEW;
}
else
{
columnCount = RiuMultiPlotPage::ColumnCount::COLUMNS_4;
rowCount = RimMultiPlot::RowCount::ROWS_4;
tickmarkCount = RimPlotAxisPropertiesInterface::LegendTickmarkCount::TICKMARK_VERY_FEW;
}
plot->setAutoTitlePlot( true );
plot->setAutoTitleGraphs( showTitleSubGraph );
plot->setColumnCount( columnCount );
plot->setRowCount( rowCount );
plot->setShowPlotTitles( showTitleSubGraph );
plot->setTickmarkCount( tickmarkCount );
for ( auto graph : graphs )
{
plot->addPlot( graph );
graph->resolveReferencesRecursively();
graph->revokeMdiWindowStatus();
graph->setShowWindow( true );
graph->loadDataAndUpdate();
}
plot->loadDataAndUpdate();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -570,6 +515,18 @@ void RimSummaryMultiPlot::syncAxisRanges()
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryMultiPlot::summaryPlotItemInfos( QList<caf::PdmOptionItemInfo>* optionInfos ) const
{
for ( RimSummaryPlot* plot : summaryPlots() )
{
QString displayName = plot->description();
optionInfos->push_back( caf::PdmOptionItemInfo( displayName, plot, false, plot->uiCapability()->uiIconProvider() ) );
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

7
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryMultiPlot.h
View File

@ -24,8 +24,11 @@
#include "cafPdmChildField.h"
#include "cafPdmObject.h"
#include "cafPdmPtrArrayField.h"
#include "cafPdmUiItem.h"
#include "cafSignal.h"
#include <QList>
#include <vector>
class RimSummaryPlot;
@ -68,6 +71,8 @@ public:
void addPlot( const std::vector<caf::PdmObjectHandle*>& objects );
void summaryPlotItemInfos( QList<caf::PdmOptionItemInfo>* optionInfos ) const;
protected:
bool handleGlobalKeyEvent( QKeyEvent* keyEvent ) override;
bool handleGlobalWheelEvent( QWheelEvent* wheelEvent ) override;
@ -85,8 +90,6 @@ private:
std::vector<RimSummaryPlot*> summaryPlots() const;
static void insertGraphsIntoPlot( RimSummaryMultiPlot* plot, const std::vector<RimSummaryPlot*>& graphs );
void updatePlotWindowTitle() override;
void duplicate();

10
ApplicationLibCode/UserInterface/RiuDragDrop.cpp
View File

@ -778,6 +778,8 @@ bool RiuDragDrop::handleGenericDropEvent( QEvent* event, std::vector<caf::PdmObj
const MimeDataWithIndexes* mimeData = nullptr;
Qt::KeyboardModifiers keyModifiers;
bool bResult = false;
if ( event->type() == QEvent::Drop )
{
// These drop events come from Qwt
@ -788,6 +790,8 @@ bool RiuDragDrop::handleGenericDropEvent( QEvent* event, std::vector<caf::PdmObj
keyModifiers = dropEvent->keyboardModifiers();
dropEvent->acceptProposedAction();
dropEvent->accept();
bResult = true;
}
}
else if ( event->type() == QEvent::GraphicsSceneDrop )
@ -799,6 +803,8 @@ bool RiuDragDrop::handleGenericDropEvent( QEvent* event, std::vector<caf::PdmObj
mimeData = qobject_cast<const MimeDataWithIndexes*>( dropEvent->mimeData() );
dropEvent->acceptProposedAction();
dropEvent->accept();
bResult = true;
}
}
@ -819,8 +825,8 @@ bool RiuDragDrop::handleGenericDropEvent( QEvent* event, std::vector<caf::PdmObj
if ( obj ) droppedObjects.push_back( obj );
}
return true;
bResult = true;
}
return false;
return bResult;
}

1
ApplicationLibCode/UserInterface/RiuMainWindowBase.cpp
View File

@ -262,7 +262,6 @@ void RiuMainWindowBase::selectAsCurrentItem( const caf::PdmObject* object, bool
if ( dw )
{
dw->show();
dw->raise();
}
}

31
ApplicationLibCode/UserInterface/RiuMultiPlotBook.cpp
View File

@ -104,6 +104,8 @@ RiuMultiPlotBook::RiuMultiPlotBook( RimMultiPlot* plotDefinition, QWidget* paren
, m_subTitlesVisible( true )
, m_previewMode( true )
, m_currentPageIndex( 0 )
, m_goToLastPageAfterUpdate( false )
, m_pageTimerId( -1 )
{
const int spacing = 8;
@ -168,6 +170,7 @@ void RiuMultiPlotBook::addPlot( RiuPlotWidget* plotWidget )
void RiuMultiPlotBook::insertPlot( RiuPlotWidget* plotWidget, size_t index )
{
m_plotWidgets.insert( static_cast<int>( index ), plotWidget );
m_goToLastPageAfterUpdate = true;
scheduleUpdate();
}
@ -461,6 +464,24 @@ void RiuMultiPlotBook::performUpdate()
deleteAllPages();
createPages();
updateGeometry();
// use a timer to trigger a viewer page change, if needed
if ( m_goToLastPageAfterUpdate )
{
m_pageTimerId = startTimer( 100 );
m_goToLastPageAfterUpdate = false;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuMultiPlotBook::timerEvent( QTimerEvent* event )
{
if ( event->timerId() == m_pageTimerId )
{
killTimer( m_pageTimerId );
goToLastPage();
}
}
//--------------------------------------------------------------------------------------------------
@ -501,8 +522,8 @@ void RiuMultiPlotBook::createPages()
{
CAF_ASSERT( m_plotDefinition );
QList<QPointer<RiuPlotWidget>> plotWidgets = this->visiblePlotWidgets();
auto rowAndColumnCount = this->rowAndColumnCount( plotWidgets.size() );
QList<QPointer<RiuPlotWidget>> plotWidgets = this->visiblePlotWidgets();
auto [rowCount, columnCount] = this->rowAndColumnCount( plotWidgets.size() );
int rowsPerPage = m_plotDefinition->rowsPerPage();
int row = 0;
@ -514,9 +535,9 @@ void RiuMultiPlotBook::createPages()
for ( int visibleIndex = 0; visibleIndex < plotWidgets.size(); ++visibleIndex )
{
int expectedColSpan = static_cast<int>( plotWidgets[visibleIndex]->colSpan() );
int colSpan = std::min( expectedColSpan, rowAndColumnCount.second );
int colSpan = std::min( expectedColSpan, columnCount );
std::tie( row, column ) = page->findAvailableRowAndColumn( row, column, colSpan, rowAndColumnCount.second );
std::tie( row, column ) = page->findAvailableRowAndColumn( row, column, colSpan, columnCount );
if ( row >= rowsPerPage )
{
page = createPage();
@ -609,7 +630,7 @@ void RiuMultiPlotBook::applyLook()
void RiuMultiPlotBook::changeCurrentPage( int pageNumber )
{
m_currentPageIndex = pageNumber;
if ( m_currentPageIndex >= (int)m_pages.size() ) m_currentPageIndex = (int)m_pages.size() - 1;
if ( m_currentPageIndex >= m_pages.size() ) m_currentPageIndex = m_pages.size() - 1;
if ( m_currentPageIndex < 0 ) m_currentPageIndex = 0;
if ( !m_pages.isEmpty() ) m_scrollArea->ensureWidgetVisible( m_pages[m_currentPageIndex] );
}

8
ApplicationLibCode/UserInterface/RiuMultiPlotBook.h
View File

@ -53,9 +53,6 @@ class RiuMultiPlotBook : public QWidget, public RiuInterfaceToViewWindow
{
Q_OBJECT
public:
using ColumnCount = RiuMultiPlotPage::ColumnCount;
public:
RiuMultiPlotBook( RimMultiPlot* plotDefinition, QWidget* parent = nullptr );
~RiuMultiPlotBook() override;
@ -108,6 +105,8 @@ protected:
void dragEnterEvent( QDragEnterEvent* event ) override;
void dropEvent( QDropEvent* event ) override;
void timerEvent( QTimerEvent* event ) override;
private:
void deleteAllPages();
void createPages();
@ -136,4 +135,7 @@ protected:
bool m_subTitlesVisible;
bool m_previewMode;
int m_currentPageIndex;
bool m_goToLastPageAfterUpdate;
int m_pageTimerId;
};

2
ApplicationLibCode/UserInterface/RiuMultiPlotPage.cpp
View File

@ -537,7 +537,7 @@ void RiuMultiPlotPage::onSelectionManagerSelectionChanged( const std::set<int>&
for ( RiuPlotWidget* plotWidget : m_plotWidgets )
{
CAF_ASSERT( plotWidget );
if ( !plotWidget ) continue;
RimPlot* plot = plotWidget->plotDefinition();
if ( !plot ) continue;

10
ApplicationLibCode/UserInterface/RiuMultiPlotPage.h
View File

@ -53,16 +53,6 @@ class RiuMultiPlotPage : public QWidget, public caf::SelectionChangedReceiver, p
{
Q_OBJECT
public:
enum class ColumnCount
{
COLUMNS_1 = 1,
COLUMNS_2 = 2,
COLUMNS_3 = 3,
COLUMNS_4 = 4,
COLUMNS_UNLIMITED = 1000,
};
public:
RiuMultiPlotPage( RimPlotWindow* plotDefinition, QWidget* parent = nullptr );
~RiuMultiPlotPage() override;

1
ApplicationLibCode/UserInterface/RiuPlotMainWindow.cpp
View File

@ -1025,7 +1025,6 @@ void RiuPlotMainWindow::selectedObjectsChanged()
// The only way to get to this code is by selection change initiated from the project tree view
// As we are activating an MDI-window, the focus is given to this MDI-window
// Set focus back to the tree view to be able to continue keyboard tree view navigation
projectTree->raise();
projectTree->treeView()->setFocus();
}
}