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

#2020 Move LAS files. Support for submenus and command features with custom name and user data

Browse Source
This commit is contained in:
Bjørn Erik Jensen 2017-11-19 01:12:39 +01:00
parent f032a3eb9f
commit 31a84181e6
25 changed files with 920 additions and 457 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
ApplicationCode/Commands/OctaveScriptCommands/RicExecuteScriptForCasesFeature.cpp
View File

@ -53,27 +53,7 @@ bool RicExecuteScriptForCasesFeature::isCommandEnabled()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RicExecuteScriptForCasesFeature::onActionTriggered(bool isChecked) void RicExecuteScriptForCasesFeature::onActionTriggered(bool isChecked)
{ {
// Dummy - handled by slotExecuteScriptForSelectedCases() QString scriptAbsolutePath = userData().toString();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicExecuteScriptForCasesFeature::setupActionLook(QAction* actionToSetup)
{
actionToSetup->setText("Execute script");
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicExecuteScriptForCasesFeature::slotExecuteScriptForSelectedCases()
{
QAction* action = qobject_cast<QAction*>(sender());
if (!action) return;
QString scriptAbsolutePath = action->data().toString();
RiuMainWindow* mainWindow = RiuMainWindow::instance(); RiuMainWindow* mainWindow = RiuMainWindow::instance();
mainWindow->showProcessMonitorDockPanel(); mainWindow->showProcessMonitorDockPanel();
@ -110,3 +90,11 @@ void RicExecuteScriptForCasesFeature::slotExecuteScriptForSelectedCases()
} }
} }
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicExecuteScriptForCasesFeature::setupActionLook(QAction* actionToSetup)
{
actionToSetup->setText("Execute script");
}

3
ApplicationCode/Commands/OctaveScriptCommands/RicExecuteScriptForCasesFeature.h
View File

@ -35,9 +35,6 @@ protected:
virtual bool isCommandEnabled(); virtual bool isCommandEnabled();
virtual void onActionTriggered( bool isChecked ); virtual void onActionTriggered( bool isChecked );
virtual void setupActionLook( QAction* actionToSetup ); virtual void setupActionLook( QAction* actionToSetup );
private slots:
void slotExecuteScriptForSelectedCases();
}; };

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

@ -27,6 +27,7 @@ ${CEE_CURRENT_LIST_DIR}RicChangeDataSourceFeature.h
${CEE_CURRENT_LIST_DIR}RicChangeDataSourceFeatureUi.h ${CEE_CURRENT_LIST_DIR}RicChangeDataSourceFeatureUi.h
${CEE_CURRENT_LIST_DIR}RicAsciiExportWellLogPlotFeature.h ${CEE_CURRENT_LIST_DIR}RicAsciiExportWellLogPlotFeature.h
${CEE_CURRENT_LIST_DIR}RicWellLogFileCloseFeature.h ${CEE_CURRENT_LIST_DIR}RicWellLogFileCloseFeature.h
${CEE_CURRENT_LIST_DIR}RicMoveWellLogFilesFeature.h
) )
set (SOURCE_GROUP_SOURCE_FILES set (SOURCE_GROUP_SOURCE_FILES
@ -52,6 +53,7 @@ ${CEE_CURRENT_LIST_DIR}RicChangeDataSourceFeature.cpp
${CEE_CURRENT_LIST_DIR}RicChangeDataSourceFeatureUi.cpp ${CEE_CURRENT_LIST_DIR}RicChangeDataSourceFeatureUi.cpp
${CEE_CURRENT_LIST_DIR}RicAsciiExportWellLogPlotFeature.cpp ${CEE_CURRENT_LIST_DIR}RicAsciiExportWellLogPlotFeature.cpp
${CEE_CURRENT_LIST_DIR}RicWellLogFileCloseFeature.cpp ${CEE_CURRENT_LIST_DIR}RicWellLogFileCloseFeature.cpp
${CEE_CURRENT_LIST_DIR}RicMoveWellLogFilesFeature.cpp
) )
list(APPEND CODE_HEADER_FILES list(APPEND CODE_HEADER_FILES

75
ApplicationCode/Commands/WellLogCommands/RicMoveWellLogFilesFeature.cpp Normal file
View File

@ -0,0 +1,75 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2015- Statoil ASA
// Copyright (C) 2015- Ceetron Solutions AS
//
// 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 "RicMoveWellLogFilesFeature.h"
#include "RiaApplication.h"
#include "RimProject.h"
#include "RimWellPath.h"
#include "RimWellLogFile.h"
#include "RiuMainWindow.h"
#include "cafPdmUiObjectEditorHandle.h"
#include "cafSelectionManagerTools.h"
#include <QAction>
#include <QFileDialog>
CAF_CMD_SOURCE_INIT(RicMoveWellLogFilesFeature, "RicMoveWellLogFilesFeature");
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RicMoveWellLogFilesFeature::isCommandEnabled()
{
return true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicMoveWellLogFilesFeature::onActionTriggered(bool isChecked)
{
const QVariant userData = this->userData();
if (!userData.isNull() && userData.type() == QVariant::String)
{
RimProject* proj = RiaApplication::instance()->project();
RimWellPath* destWellPath = proj->wellPathByName(userData.toString());
RimWellLogFile* wellLogFile = caf::firstAncestorOfTypeFromSelectedObject<RimWellLogFile*>();
RimWellPath* sourceWellPath = caf::firstAncestorOfTypeFromSelectedObject<RimWellPath*>();
if (!destWellPath || !wellLogFile || !sourceWellPath) return;
sourceWellPath->detachWellLogFile(wellLogFile);
destWellPath->addWellLogFile(wellLogFile);
sourceWellPath->updateConnectedEditors();
destWellPath->updateConnectedEditors();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicMoveWellLogFilesFeature::setupActionLook(QAction* actionToSetup)
{
actionToSetup->setText("Move Well Log File(s)");
actionToSetup->setIcon(QIcon(":/Well.png"));
}

37
ApplicationCode/Commands/WellLogCommands/RicMoveWellLogFilesFeature.h Normal file
View File

@ -0,0 +1,37 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2015- Statoil ASA
// Copyright (C) 2015- Ceetron Solutions AS
//
// ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
#pragma once
#include "cafCmdFeature.h"
//==================================================================================================
///
//==================================================================================================
class RicMoveWellLogFilesFeature : public caf::CmdFeature
{
CAF_CMD_HEADER_INIT;
protected:
// Overrides
virtual bool isCommandEnabled() override;
virtual void onActionTriggered( bool isChecked ) override;
virtual void setupActionLook( QAction* actionToSetup ) override;
};

625
ApplicationCode/ProjectDataModel/RimContextCommandBuilder.cpp
View File

@ -19,6 +19,8 @@
#include "RimContextCommandBuilder.h" #include "RimContextCommandBuilder.h"
#include "RiaApplication.h"
#include "RimCalcScript.h" #include "RimCalcScript.h"
#include "RimCaseCollection.h" #include "RimCaseCollection.h"
#include "RimCellRangeFilter.h" #include "RimCellRangeFilter.h"
@ -47,6 +49,7 @@
#include "RimIntersectionBox.h" #include "RimIntersectionBox.h"
#include "RimIntersectionCollection.h" #include "RimIntersectionCollection.h"
#include "RimObservedData.h" #include "RimObservedData.h"
#include "RimProject.h"
#include "RimScriptCollection.h" #include "RimScriptCollection.h"
#include "RimSimWellInView.h" #include "RimSimWellInView.h"
#include "RimSimWellInViewCollection.h" #include "RimSimWellInViewCollection.h"
@ -84,24 +87,30 @@
#include "RimWellPathFractureCollection.h" #include "RimWellPathFractureCollection.h"
#endif // USE_PROTOTYPE_FEATURE_FRACTURES #endif // USE_PROTOTYPE_FEATURE_FRACTURES
#include "RiuMainWindow.h"
#include "ToggleCommands/RicToggleItemsFeatureImpl.h" #include "ToggleCommands/RicToggleItemsFeatureImpl.h"
#include "cafCmdFeature.h" #include "cafCmdFeature.h"
#include "cafCmdFeatureManager.h" #include "cafCmdFeatureManager.h"
#include "cafCmdFeatureMenuBuilder.h"
#include "cafPdmUiItem.h" #include "cafPdmUiItem.h"
#include "cafSelectionManager.h" #include "cafSelectionManager.h"
#include "cafSelectionManagerTools.h"
#include "cvfAssert.h" #include "cvfAssert.h"
#include <vector> #include <vector>
#include <QMenu> #include <QMenu>
#include <QDir>
#include "OctaveScriptCommands/RicExecuteScriptForCasesFeature.h"
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
QStringList RimContextCommandBuilder::commandsFromSelection() caf::CmdFeatureMenuBuilder RimContextCommandBuilder::commandsFromSelection()
{ {
QStringList commandIds; //QStringList commandIds;
caf::CmdFeatureMenuBuilder menuBuilder;
std::vector<caf::PdmUiItem*> uiItems; std::vector<caf::PdmUiItem*> uiItems;
caf::SelectionManager::instance()->selectedItems(uiItems); caf::SelectionManager::instance()->selectedItems(uiItems);
@ -113,366 +122,382 @@ QStringList RimContextCommandBuilder::commandsFromSelection()
if (dynamic_cast<RimEclipseCaseCollection*>(uiItem)) if (dynamic_cast<RimEclipseCaseCollection*>(uiItem))
{ {
commandIds << "RicImportEclipseCaseFeature"; menuBuilder << "RicImportEclipseCaseFeature";
commandIds << "RicImportInputEclipseCaseFeature"; menuBuilder << "RicImportInputEclipseCaseFeature";
commandIds << "RicCreateGridCaseGroupFeature"; menuBuilder << "RicCreateGridCaseGroupFeature";
commandIds << "RicEclipseCaseNewGroupFeature"; menuBuilder << "RicEclipseCaseNewGroupFeature";
commandIds << "RicCalculateNumberOfFloodedPoreVolumes"; menuBuilder << "RicCalculateNumberOfFloodedPoreVolumes";
} }
else if (dynamic_cast<RimGeoMechView*>(uiItem)) else if (dynamic_cast<RimGeoMechView*>(uiItem))
{ {
commandIds << "RicPasteGeoMechViewsFeature"; menuBuilder << "RicPasteGeoMechViewsFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicNewViewFeature"; menuBuilder << "RicNewViewFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicCopyReferencesToClipboardFeature"; menuBuilder << "RicCopyReferencesToClipboardFeature";
} }
else if (dynamic_cast<RimEclipseView*>(uiItem)) else if (dynamic_cast<RimEclipseView*>(uiItem))
{ {
commandIds << "RicPasteEclipseViewsFeature"; menuBuilder << "RicPasteEclipseViewsFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicNewViewFeature"; menuBuilder << "RicNewViewFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicCopyReferencesToClipboardFeature"; menuBuilder << "RicCopyReferencesToClipboardFeature";
commandIds << "RicSaveEclipseInputVisibleCellsFeature"; menuBuilder << "RicSaveEclipseInputVisibleCellsFeature";
} }
else if (dynamic_cast<RimCaseCollection*>(uiItem)) else if (dynamic_cast<RimCaseCollection*>(uiItem))
{ {
commandIds << "RicPasteEclipseCasesFeature"; menuBuilder << "RicPasteEclipseCasesFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicNewStatisticsCaseFeature"; menuBuilder << "RicNewStatisticsCaseFeature";
} }
else if (dynamic_cast<RimEclipseStatisticsCase*>(uiItem)) else if (dynamic_cast<RimEclipseStatisticsCase*>(uiItem))
{ {
commandIds << "RicNewViewFeature"; menuBuilder << "RicNewViewFeature";
commandIds << "RicComputeStatisticsFeature"; menuBuilder << "RicComputeStatisticsFeature";
commandIds << "Separator"; menuBuilder << "Separator";
} }
else if (dynamic_cast<RimEclipseCase*>(uiItem)) else if (dynamic_cast<RimEclipseCase*>(uiItem))
{ {
commandIds << "RicPasteEclipseCasesFeature"; menuBuilder << "RicPasteEclipseCasesFeature";
commandIds << "RicPasteEclipseViewsFeature"; menuBuilder << "RicPasteEclipseViewsFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicNewViewFeature"; menuBuilder << "RicNewViewFeature";
commandIds << "RicShowFlowCharacteristicsPlotFeature"; menuBuilder << "RicShowFlowCharacteristicsPlotFeature";
commandIds << "RicEclipseCaseNewGroupFeature"; menuBuilder << "RicEclipseCaseNewGroupFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicCopyReferencesToClipboardFeature"; menuBuilder << "RicCopyReferencesToClipboardFeature";
commandIds << "Separator"; menuBuilder << "Separator";
} }
else if (dynamic_cast<RimGeoMechCase*>(uiItem)) else if (dynamic_cast<RimGeoMechCase*>(uiItem))
{ {
commandIds << "RicPasteGeoMechViewsFeature"; menuBuilder << "RicPasteGeoMechViewsFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicNewViewFeature"; menuBuilder << "RicNewViewFeature";
commandIds << "Separator"; menuBuilder << "Separator";
} }
else if (dynamic_cast<RimIdenticalGridCaseGroup*>(uiItem)) else if (dynamic_cast<RimIdenticalGridCaseGroup*>(uiItem))
{ {
commandIds << "RicPasteEclipseCasesFeature"; menuBuilder << "RicPasteEclipseCasesFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicEclipseCaseNewGroupFeature"; menuBuilder << "RicEclipseCaseNewGroupFeature";
} }
else if (dynamic_cast<RimEclipseCellColors*>(uiItem)) else if (dynamic_cast<RimEclipseCellColors*>(uiItem))
{ {
commandIds << "RicSaveEclipseResultAsInputPropertyFeature"; menuBuilder << "RicSaveEclipseResultAsInputPropertyFeature";
} }
else if (dynamic_cast<RimEclipseInputPropertyCollection*>(uiItem)) else if (dynamic_cast<RimEclipseInputPropertyCollection*>(uiItem))
{ {
commandIds << "RicAddEclipseInputPropertyFeature"; menuBuilder << "RicAddEclipseInputPropertyFeature";
} }
else if (dynamic_cast<RimEclipseInputProperty*>(uiItem)) else if (dynamic_cast<RimEclipseInputProperty*>(uiItem))
{ {
commandIds << "RicSaveEclipseInputPropertyFeature"; menuBuilder << "RicSaveEclipseInputPropertyFeature";
} }
else if (dynamic_cast<RimCellRangeFilterCollection*>(uiItem)) else if (dynamic_cast<RimCellRangeFilterCollection*>(uiItem))
{ {
commandIds << "RicRangeFilterNewFeature"; menuBuilder << "RicRangeFilterNewFeature";
commandIds << "RicRangeFilterNewSliceIFeature"; menuBuilder << "RicRangeFilterNewSliceIFeature";
commandIds << "RicRangeFilterNewSliceJFeature"; menuBuilder << "RicRangeFilterNewSliceJFeature";
commandIds << "RicRangeFilterNewSliceKFeature"; menuBuilder << "RicRangeFilterNewSliceKFeature";
} }
else if (dynamic_cast<RimCellRangeFilter*>(uiItem)) else if (dynamic_cast<RimCellRangeFilter*>(uiItem))
{ {
commandIds << "RicRangeFilterInsertFeature"; menuBuilder << "RicRangeFilterInsertFeature";
commandIds << "RicRangeFilterNewSliceIFeature"; menuBuilder << "RicRangeFilterNewSliceIFeature";
commandIds << "RicRangeFilterNewSliceJFeature"; menuBuilder << "RicRangeFilterNewSliceJFeature";
commandIds << "RicRangeFilterNewSliceKFeature"; menuBuilder << "RicRangeFilterNewSliceKFeature";
} }
else if (dynamic_cast<RimEclipsePropertyFilterCollection*>(uiItem)) else if (dynamic_cast<RimEclipsePropertyFilterCollection*>(uiItem))
{ {
commandIds << "RicEclipsePropertyFilterNewFeature"; menuBuilder << "RicEclipsePropertyFilterNewFeature";
} }
else if (dynamic_cast<RimEclipsePropertyFilter*>(uiItem)) else if (dynamic_cast<RimEclipsePropertyFilter*>(uiItem))
{ {
commandIds << "RicEclipsePropertyFilterInsertFeature"; menuBuilder << "RicEclipsePropertyFilterInsertFeature";
commandIds << "RicApplyPropertyFilterAsCellResultFeature"; menuBuilder << "RicApplyPropertyFilterAsCellResultFeature";
} }
else if (dynamic_cast<RimGeoMechPropertyFilterCollection*>(uiItem)) else if (dynamic_cast<RimGeoMechPropertyFilterCollection*>(uiItem))
{ {
commandIds << "RicGeoMechPropertyFilterNewFeature"; menuBuilder << "RicGeoMechPropertyFilterNewFeature";
} }
else if (dynamic_cast<RimGeoMechPropertyFilter*>(uiItem)) else if (dynamic_cast<RimGeoMechPropertyFilter*>(uiItem))
{ {
commandIds << "RicGeoMechPropertyFilterInsertFeature"; menuBuilder << "RicGeoMechPropertyFilterInsertFeature";
commandIds << "RicApplyPropertyFilterAsCellResultFeature"; menuBuilder << "RicApplyPropertyFilterAsCellResultFeature";
} }
else if (dynamic_cast<RimWellPathCollection*>(uiItem)) else if (dynamic_cast<RimWellPathCollection*>(uiItem))
{ {
commandIds << "RicWellPathsImportFileFeature"; menuBuilder << "RicWellPathsImportFileFeature";
commandIds << "RicWellPathsImportSsihubFeature"; menuBuilder << "RicWellPathsImportSsihubFeature";
commandIds << "RicWellLogsImportFileFeature"; menuBuilder << "RicWellLogsImportFileFeature";
commandIds << "Separator"; menuBuilder << "Separator";
} }
else if (dynamic_cast<RimWellPath*>(uiItem)) else if (dynamic_cast<RimWellPath*>(uiItem))
{ {
commandIds << "RicWellPathsImportFileFeature"; menuBuilder << "RicWellPathsImportFileFeature";
commandIds << "RicWellLogsImportFileFeature"; menuBuilder << "RicWellLogsImportFileFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicNewRftPlotFeature"; menuBuilder << "RicNewRftPlotFeature";
commandIds << "RicNewPltPlotFeature"; menuBuilder << "RicNewPltPlotFeature";
commandIds << "RicNewWellLogFileCurveFeature"; menuBuilder << "RicNewWellLogFileCurveFeature";
commandIds << "RicNewWellLogCurveExtractionFeature"; menuBuilder << "RicNewWellLogCurveExtractionFeature";
commandIds << "RicNewWellPathIntersectionFeature"; menuBuilder << "RicNewWellPathIntersectionFeature";
} }
else if (dynamic_cast<RimWellLogFile*>(uiItem)) else if (dynamic_cast<RimWellLogFile*>(uiItem))
{ {
commandIds << "RicWellPathsImportFileFeature"; menuBuilder << "RicWellPathsImportFileFeature";
commandIds << "RicWellLogsImportFileFeature"; menuBuilder << "RicWellLogsImportFileFeature";
menuBuilder << "Separator";
menuBuilder.subMenuStart("Move LAS file to well path");
RimWellPath* parentWellPath = caf::firstAncestorOfTypeFromSelectedObject<RimWellPath*>();
QString parentWellPathName = parentWellPath ? parentWellPath->name() : "";
for (RimWellPath* wellPath : allWellPaths())
{
if (wellPath->name() != parentWellPathName)
{
menuBuilder.addCmdFeatureWithUserData("RicMoveWellLogFilesFeature", wellPath->name(), wellPath->name());
}
}
menuBuilder.subMenuEnd();
} }
else if (dynamic_cast<RimWellRftPlot*>(uiItem)) else if (dynamic_cast<RimWellRftPlot*>(uiItem))
{ {
commandIds << "RicDeleteRftPlotFeature"; menuBuilder << "RicDeleteRftPlotFeature";
} }
else if (dynamic_cast<RimWellPltPlot*>(uiItem)) else if (dynamic_cast<RimWellPltPlot*>(uiItem))
{ {
commandIds << "RicDeletePltPlotFeature"; menuBuilder << "RicDeletePltPlotFeature";
} }
else if (dynamic_cast<RimCalcScript*>(uiItem)) else if (dynamic_cast<RimCalcScript*>(uiItem))
{ {
commandIds << "RicEditScriptFeature"; menuBuilder << "RicEditScriptFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicNewScriptFeature"; menuBuilder << "RicNewScriptFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicExecuteScriptFeature"; menuBuilder << "RicExecuteScriptFeature";
} }
else if (dynamic_cast<RimScriptCollection*>(uiItem)) else if (dynamic_cast<RimScriptCollection*>(uiItem))
{ {
commandIds << "RicNewScriptFeature"; menuBuilder << "RicNewScriptFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicAddScriptPathFeature"; menuBuilder << "RicAddScriptPathFeature";
commandIds << "RicRefreshScriptsFeature"; menuBuilder << "RicRefreshScriptsFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicDeleteScriptPathFeature"; menuBuilder << "RicDeleteScriptPathFeature";
} }
else if (dynamic_cast<RimViewController*>(uiItem)) else if (dynamic_cast<RimViewController*>(uiItem))
{ {
commandIds << "RicShowAllLinkedViewsFeature"; menuBuilder << "RicShowAllLinkedViewsFeature";
} }
else if (dynamic_cast<RimViewLinker*>(uiItem)) else if (dynamic_cast<RimViewLinker*>(uiItem))
{ {
commandIds << "RicShowAllLinkedViewsFeature"; menuBuilder << "RicShowAllLinkedViewsFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicDeleteAllLinkedViewsFeature"; menuBuilder << "RicDeleteAllLinkedViewsFeature";
} }
else if (dynamic_cast<RimWellLogPlotCollection*>(uiItem)) else if (dynamic_cast<RimWellLogPlotCollection*>(uiItem))
{ {
commandIds << "RicPasteWellLogPlotFeature"; menuBuilder << "RicPasteWellLogPlotFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicNewWellLogPlotFeature"; menuBuilder << "RicNewWellLogPlotFeature";
} }
else if (dynamic_cast<RimRftPlotCollection*>(uiItem)) else if (dynamic_cast<RimRftPlotCollection*>(uiItem))
{ {
commandIds << "RicNewRftPlotFeature"; menuBuilder << "RicNewRftPlotFeature";
} }
else if (dynamic_cast<RimPltPlotCollection*>(uiItem)) else if (dynamic_cast<RimPltPlotCollection*>(uiItem))
{ {
commandIds << "RicNewPltPlotFeature"; menuBuilder << "RicNewPltPlotFeature";
} }
else if (dynamic_cast<RimSummaryPlotCollection*>(uiItem)) else if (dynamic_cast<RimSummaryPlotCollection*>(uiItem))
{ {
commandIds << "RicPasteSummaryPlotFeature"; menuBuilder << "RicPasteSummaryPlotFeature";
commandIds << "RicPasteAsciiDataToSummaryPlotFeature"; menuBuilder << "RicPasteAsciiDataToSummaryPlotFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicNewSummaryPlotFeature"; menuBuilder << "RicNewSummaryPlotFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicShowSummaryCurveCalculatorFeature"; menuBuilder << "RicShowSummaryCurveCalculatorFeature";
} }
else if (dynamic_cast<RimSummaryCrossPlotCollection*>(uiItem)) else if (dynamic_cast<RimSummaryCrossPlotCollection*>(uiItem))
{ {
commandIds << "RicNewSummaryCrossPlotFeature"; menuBuilder << "RicNewSummaryCrossPlotFeature";
} }
else if (dynamic_cast<RimWellLogPlot*>(uiItem)) else if (dynamic_cast<RimWellLogPlot*>(uiItem))
{ {
commandIds << "RicPasteWellLogPlotFeature"; menuBuilder << "RicPasteWellLogPlotFeature";
commandIds << "RicPasteWellLogTrackFeature"; menuBuilder << "RicPasteWellLogTrackFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicNewWellLogPlotTrackFeature"; menuBuilder << "RicNewWellLogPlotTrackFeature";
commandIds << "RicAsciiExportWellLogPlotFeature"; menuBuilder << "RicAsciiExportWellLogPlotFeature";
} }
else if (dynamic_cast<RimWellLogTrack*>(uiItem)) else if (dynamic_cast<RimWellLogTrack*>(uiItem))
{ {
commandIds << "RicPasteWellLogTrackFeature"; menuBuilder << "RicPasteWellLogTrackFeature";
commandIds << "RicPasteWellLogCurveFeature"; menuBuilder << "RicPasteWellLogCurveFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicNewWellLogCurveExtractionFeature"; menuBuilder << "RicNewWellLogCurveExtractionFeature";
commandIds << "RicNewWellLogRftCurveFeature"; menuBuilder << "RicNewWellLogRftCurveFeature";
commandIds << "RicNewWellLogFileCurveFeature"; menuBuilder << "RicNewWellLogFileCurveFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicDeleteWellLogPlotTrackFeature"; menuBuilder << "RicDeleteWellLogPlotTrackFeature";
} }
else if (dynamic_cast<RimWellLogCurve*>(uiItem)) else if (dynamic_cast<RimWellLogCurve*>(uiItem))
{ {
commandIds << "RicPasteWellLogCurveFeature"; menuBuilder << "RicPasteWellLogCurveFeature";
} }
else if (dynamic_cast<RimSummaryPlot*>(uiItem)) // This is also the definition for RimSummaryCrossPlot else if (dynamic_cast<RimSummaryPlot*>(uiItem)) // This is also the definition for RimSummaryCrossPlot
{ {
commandIds << "RicPasteSummaryCurveFeature"; menuBuilder << "RicPasteSummaryCurveFeature";
commandIds << "RicPasteSummaryCurveFilterFeature"; menuBuilder << "RicPasteSummaryCurveFilterFeature";
commandIds << "RicPasteSummaryPlotFeature"; menuBuilder << "RicPasteSummaryPlotFeature";
commandIds << "RicPasteAsciiDataToSummaryPlotFeature"; menuBuilder << "RicPasteAsciiDataToSummaryPlotFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicEditSummaryPlotFeature"; menuBuilder << "RicEditSummaryPlotFeature";
commandIds << "RicNewSummaryPlotFeature"; menuBuilder << "RicNewSummaryPlotFeature";
commandIds << "RicNewSummaryCurveFeature"; menuBuilder << "RicNewSummaryCurveFeature";
commandIds << "RicNewSummaryCrossPlotCurveFeature"; menuBuilder << "RicNewSummaryCrossPlotCurveFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicShowSummaryCurveCalculatorFeature"; menuBuilder << "RicShowSummaryCurveCalculatorFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicAsciiExportSummaryPlotFeature"; menuBuilder << "RicAsciiExportSummaryPlotFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicCopyReferencesToClipboardFeature"; menuBuilder << "RicCopyReferencesToClipboardFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicViewZoomAllFeature"; menuBuilder << "RicViewZoomAllFeature";
} }
else if (dynamic_cast<RimSummaryCurve*>(uiItem)) else if (dynamic_cast<RimSummaryCurve*>(uiItem))
{ {
commandIds << "RicPasteSummaryCurveFeature"; menuBuilder << "RicPasteSummaryCurveFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicNewSummaryCurveFeature"; menuBuilder << "RicNewSummaryCurveFeature";
commandIds << "RicNewSummaryCrossPlotCurveFeature"; menuBuilder << "RicNewSummaryCrossPlotCurveFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicCopyReferencesToClipboardFeature"; menuBuilder << "RicCopyReferencesToClipboardFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicEditSummaryCurveCalculationFeature"; menuBuilder << "RicEditSummaryCurveCalculationFeature";
} }
else if (dynamic_cast<RimSummaryCurveCollection*>(uiItem)) else if (dynamic_cast<RimSummaryCurveCollection*>(uiItem))
{ {
commandIds << "RicEditSummaryPlotFeature"; menuBuilder << "RicEditSummaryPlotFeature";
} }
else if(dynamic_cast<RimSummaryCurveFilter*>(uiItem)) else if(dynamic_cast<RimSummaryCurveFilter*>(uiItem))
{ {
commandIds << "RicPasteSummaryCurveFilterFeature"; menuBuilder << "RicPasteSummaryCurveFilterFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicNewSummaryCurveFeature"; menuBuilder << "RicNewSummaryCurveFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicCopyReferencesToClipboardFeature"; menuBuilder << "RicCopyReferencesToClipboardFeature";
} }
else if (dynamic_cast<RimSummaryCase*>(uiItem)) else if (dynamic_cast<RimSummaryCase*>(uiItem))
{ {
if (!dynamic_cast<RimObservedData*>(uiItem)) if (!dynamic_cast<RimObservedData*>(uiItem))
{ {
commandIds << "RicShowSummaryCurveCalculatorFeature"; menuBuilder << "RicShowSummaryCurveCalculatorFeature";
commandIds << "RicNewSummaryPlotFeature"; menuBuilder << "RicNewSummaryPlotFeature";
} }
} }
else if (dynamic_cast<RimWellLogFileChannel*>(uiItem)) else if (dynamic_cast<RimWellLogFileChannel*>(uiItem))
{ {
commandIds << "RicAddWellLogToPlotFeature"; menuBuilder << "RicAddWellLogToPlotFeature";
} }
else if (dynamic_cast<RimIntersectionCollection*>(uiItem)) else if (dynamic_cast<RimIntersectionCollection*>(uiItem))
{ {
commandIds << "RicAppendIntersectionFeature"; menuBuilder << "RicAppendIntersectionFeature";
commandIds << "RicAppendIntersectionBoxFeature"; menuBuilder << "RicAppendIntersectionBoxFeature";
} }
else if (dynamic_cast<RimIntersection*>(uiItem)) else if (dynamic_cast<RimIntersection*>(uiItem))
{ {
commandIds << "RicAppendIntersectionFeature"; menuBuilder << "RicAppendIntersectionFeature";
commandIds << "RicAppendIntersectionBoxFeature"; menuBuilder << "RicAppendIntersectionBoxFeature";
} }
else if (dynamic_cast<RimIntersectionBox*>(uiItem)) else if (dynamic_cast<RimIntersectionBox*>(uiItem))
{ {
commandIds << "RicAppendIntersectionFeature"; menuBuilder << "RicAppendIntersectionFeature";
commandIds << "RicAppendIntersectionBoxFeature"; menuBuilder << "RicAppendIntersectionBoxFeature";
} }
else if (dynamic_cast<RimSimWellInView*>(uiItem)) else if (dynamic_cast<RimSimWellInView*>(uiItem))
{ {
commandIds << "RicNewWellLogCurveExtractionFeature"; menuBuilder << "RicNewWellLogCurveExtractionFeature";
commandIds << "RicNewWellLogRftCurveFeature"; menuBuilder << "RicNewWellLogRftCurveFeature";
commandIds << "RicNewSimWellIntersectionFeature"; menuBuilder << "RicNewSimWellIntersectionFeature";
commandIds << "RicNewRftPlotFeature"; menuBuilder << "RicNewRftPlotFeature";
commandIds << "RicNewPltPlotFeature"; menuBuilder << "RicNewPltPlotFeature";
commandIds << "RicShowWellAllocationPlotFeature"; menuBuilder << "RicShowWellAllocationPlotFeature";
} }
else if(dynamic_cast<RimFormationNames*>(uiItem)) else if(dynamic_cast<RimFormationNames*>(uiItem))
{ {
commandIds << "RicImportFormationNamesFeature"; menuBuilder << "RicImportFormationNamesFeature";
commandIds << "RicReloadFormationNamesFeature"; menuBuilder << "RicReloadFormationNamesFeature";
} }
else if(dynamic_cast<RimFormationNamesCollection*>(uiItem)) else if(dynamic_cast<RimFormationNamesCollection*>(uiItem))
{ {
commandIds << "RicImportFormationNamesFeature"; menuBuilder << "RicImportFormationNamesFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicReloadFormationNamesFeature"; menuBuilder << "RicReloadFormationNamesFeature";
} }
else if ( dynamic_cast<RimFaultInView*>(uiItem) ) else if ( dynamic_cast<RimFaultInView*>(uiItem) )
{ {
commandIds << "RicExportFaultsFeature"; menuBuilder << "RicExportFaultsFeature";
} }
else if (dynamic_cast<RimWellAllocationPlot*>(uiItem)) else if (dynamic_cast<RimWellAllocationPlot*>(uiItem))
{ {
commandIds << "RicAddStoredWellAllocationPlotFeature"; menuBuilder << "RicAddStoredWellAllocationPlotFeature";
} }
else if (dynamic_cast<RimFlowCharacteristicsPlot*>(uiItem)) else if (dynamic_cast<RimFlowCharacteristicsPlot*>(uiItem))
{ {
commandIds << "RicAddStoredFlowCharacteristicsPlotFeature"; menuBuilder << "RicAddStoredFlowCharacteristicsPlotFeature";
} }
else if (dynamic_cast<RimFlowDiagSolution*>(uiItem)) else if (dynamic_cast<RimFlowDiagSolution*>(uiItem))
{ {
commandIds << "RicShowFlowCharacteristicsPlotFeature"; menuBuilder << "RicShowFlowCharacteristicsPlotFeature";
} }
else if (dynamic_cast<RimFlowPlotCollection*>(uiItem)) else if (dynamic_cast<RimFlowPlotCollection*>(uiItem))
{ {
commandIds << "RicShowFlowCharacteristicsPlotFeature"; menuBuilder << "RicShowFlowCharacteristicsPlotFeature";
} }
else if (dynamic_cast<Rim3dOverlayInfoConfig*>(uiItem)) else if (dynamic_cast<Rim3dOverlayInfoConfig*>(uiItem))
{ {
commandIds << "RicShowGridStatisticsFeature"; menuBuilder << "RicShowGridStatisticsFeature";
} }
#ifdef USE_PROTOTYPE_FEATURE_FRACTURES #ifdef USE_PROTOTYPE_FEATURE_FRACTURES
else if (dynamic_cast<RimSimWellFracture*>(uiItem)) else if (dynamic_cast<RimSimWellFracture*>(uiItem))
{ {
commandIds << "RicNewSimWellFractureFeature"; menuBuilder << "RicNewSimWellFractureFeature";
} }
else if (dynamic_cast<RimFractureTemplateCollection*>(uiItem) || else if (dynamic_cast<RimFractureTemplateCollection*>(uiItem) ||
dynamic_cast<RimStimPlanFractureTemplate*>(uiItem)) dynamic_cast<RimStimPlanFractureTemplate*>(uiItem))
{ {
commandIds << "RicNewEllipseFractureTemplateFeature"; menuBuilder << "RicNewEllipseFractureTemplateFeature";
commandIds << "RicNewStimPlanFractureTemplateFeature"; menuBuilder << "RicNewStimPlanFractureTemplateFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicConvertAllFractureTemplatesToMetricFeature"; menuBuilder << "RicConvertAllFractureTemplatesToMetricFeature";
commandIds << "RicConvertAllFractureTemplatesToFieldFeature"; menuBuilder << "RicConvertAllFractureTemplatesToFieldFeature";
} }
else if (dynamic_cast<RimEllipseFractureTemplate*>(uiItem)) else if (dynamic_cast<RimEllipseFractureTemplate*>(uiItem))
{ {
commandIds << "RicNewEllipseFractureTemplateFeature"; menuBuilder << "RicNewEllipseFractureTemplateFeature";
commandIds << "RicNewStimPlanFractureTemplateFeature"; menuBuilder << "RicNewStimPlanFractureTemplateFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicConvertFractureTemplateUnitFeature"; menuBuilder << "RicConvertFractureTemplateUnitFeature";
} }
#endif // USE_PROTOTYPE_FEATURE_FRACTURES #endif // USE_PROTOTYPE_FEATURE_FRACTURES
if (dynamic_cast<RimView*>(uiItem)) if (dynamic_cast<RimView*>(uiItem))
{ {
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicLinkVisibleViewsFeature"; menuBuilder << "RicLinkVisibleViewsFeature";
commandIds << "RicLinkViewFeature"; menuBuilder << "RicLinkViewFeature";
commandIds << "RicShowLinkOptionsFeature"; menuBuilder << "RicShowLinkOptionsFeature";
commandIds << "RicSetMasterViewFeature"; menuBuilder << "RicSetMasterViewFeature";
commandIds << "RicUnLinkViewFeature"; menuBuilder << "RicUnLinkViewFeature";
} }
} }
@ -487,41 +512,41 @@ QStringList RimContextCommandBuilder::commandsFromSelection()
// without using dyncamic_cast. // without using dyncamic_cast.
commandIds << "RicPasteTimeHistoryCurveFeature"; menuBuilder << "RicPasteTimeHistoryCurveFeature";
commandIds << "RicPasteAsciiDataCurveFeature"; menuBuilder << "RicPasteAsciiDataCurveFeature";
commandIds << "RicCopyReferencesToClipboardFeature"; menuBuilder << "RicCopyReferencesToClipboardFeature";
commandIds << "RicShowPlotDataFeature"; menuBuilder << "RicShowPlotDataFeature";
commandIds << "RicShowTotalAllocationDataFeature"; menuBuilder << "RicShowTotalAllocationDataFeature";
commandIds << "RicSummaryCurveSwitchAxisFeature"; menuBuilder << "RicSummaryCurveSwitchAxisFeature";
commandIds << "RicNewFishbonesSubsFeature"; menuBuilder << "RicNewFishbonesSubsFeature";
commandIds << "RicNewPerforationIntervalFeature"; menuBuilder << "RicNewPerforationIntervalFeature";
commandIds << "RicEditPerforationCollectionFeature"; menuBuilder << "RicEditPerforationCollectionFeature";
commandIds << "RicExportFishbonesLateralsFeature"; menuBuilder << "RicExportFishbonesLateralsFeature";
commandIds << "RicExportFishbonesWellSegmentsFeature"; menuBuilder << "RicExportFishbonesWellSegmentsFeature";
commandIds << "RicWellPathImportPerforationIntervalsFeature"; menuBuilder << "RicWellPathImportPerforationIntervalsFeature";
commandIds << "RicWellPathExportCompletionDataFeature"; menuBuilder << "RicWellPathExportCompletionDataFeature";
commandIds << "RicWellPathImportCompletionsFileFeature"; menuBuilder << "RicWellPathImportCompletionsFileFeature";
commandIds << "RicFlyToObjectFeature"; menuBuilder << "RicFlyToObjectFeature";
commandIds << "RicExportCarfin"; menuBuilder << "RicExportCarfin";
commandIds << "RicImportObservedDataFeature"; menuBuilder << "RicImportObservedDataFeature";
commandIds << "RicPasteSummaryCaseFeature"; menuBuilder << "RicPasteSummaryCaseFeature";
commandIds << "RicReloadSummaryCaseFeature"; menuBuilder << "RicReloadSummaryCaseFeature";
commandIds << "RicCreateSummaryCaseCollectionFeature"; menuBuilder << "RicCreateSummaryCaseCollectionFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicCutReferencesToClipboardFeature"; menuBuilder << "RicCutReferencesToClipboardFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicCloseSummaryCaseFeature"; menuBuilder << "RicCloseSummaryCaseFeature";
commandIds << "RicCloseSummaryCaseInCollectionFeature"; menuBuilder << "RicCloseSummaryCaseInCollectionFeature";
commandIds << "RicDeleteSummaryCaseCollectionFeature"; menuBuilder << "RicDeleteSummaryCaseCollectionFeature";
commandIds << "RicCloseObservedDataFeature"; menuBuilder << "RicCloseObservedDataFeature";
// Fracture commands // Fracture commands
#ifdef USE_PROTOTYPE_FEATURE_FRACTURES #ifdef USE_PROTOTYPE_FEATURE_FRACTURES
commandIds << "RicNewWellPathFractureFeature"; menuBuilder << "RicNewWellPathFractureFeature";
#endif // USE_PROTOTYPE_FEATURE_FRACTURES #endif // USE_PROTOTYPE_FEATURE_FRACTURES
// Work in progress -- End // Work in progress -- End
@ -529,55 +554,55 @@ QStringList RimContextCommandBuilder::commandsFromSelection()
caf::PdmUiItem* uiItem = uiItems[0]; caf::PdmUiItem* uiItem = uiItems[0];
if (dynamic_cast<RimWellLogFileChannel*>(uiItem)) if (dynamic_cast<RimWellLogFileChannel*>(uiItem))
{ {
commandIds << "RicAddWellLogToPlotFeature"; menuBuilder << "RicAddWellLogToPlotFeature";
} }
else if (dynamic_cast<RimEclipseStatisticsCase*>(uiItem)) else if (dynamic_cast<RimEclipseStatisticsCase*>(uiItem))
{ {
commandIds << "RicExecuteScriptForCasesFeature"; createExecuteScriptForCasesFeatureMenu(menuBuilder);
} }
else if (dynamic_cast<RimEclipseCase*>(uiItem)) else if (dynamic_cast<RimEclipseCase*>(uiItem))
{ {
commandIds << "RicReloadCaseFeature"; menuBuilder << "RicReloadCaseFeature";
commandIds << "RicExecuteScriptForCasesFeature"; createExecuteScriptForCasesFeatureMenu(menuBuilder);
commandIds << "RicCloseSourSimDataFeature"; menuBuilder << "RicCloseSourSimDataFeature";
} }
else if (dynamic_cast<RimSummaryPlot*>(uiItem)) else if (dynamic_cast<RimSummaryPlot*>(uiItem))
{ {
commandIds << "RicAsciiExportSummaryPlotFeature"; menuBuilder << "RicAsciiExportSummaryPlotFeature";
} }
else if (dynamic_cast<RimWellLogPlot*>(uiItem)) else if (dynamic_cast<RimWellLogPlot*>(uiItem))
{ {
commandIds << "RicAsciiExportWellLogPlotFeature"; menuBuilder << "RicAsciiExportWellLogPlotFeature";
} }
else if (dynamic_cast<RimWellLogCurve*>(uiItem) || else if (dynamic_cast<RimWellLogCurve*>(uiItem) ||
dynamic_cast<RimWellLogTrack*>(uiItem) || dynamic_cast<RimWellLogTrack*>(uiItem) ||
dynamic_cast<RimWellLogPlot*>(uiItem)) dynamic_cast<RimWellLogPlot*>(uiItem))
{ {
commandIds << "RicExportToLasFileFeature"; menuBuilder << "RicExportToLasFileFeature";
commandIds << "RicChangeDataSourceFeature"; menuBuilder << "RicChangeDataSourceFeature";
} }
else if (dynamic_cast<RimWellLogPlotCollection*>(uiItem)) else if (dynamic_cast<RimWellLogPlotCollection*>(uiItem))
{ {
commandIds << "RicExportToLasFileFeature"; menuBuilder << "RicExportToLasFileFeature";
} }
else if (dynamic_cast<RimFaultInView*>(uiItem) ) else if (dynamic_cast<RimFaultInView*>(uiItem) )
{ {
commandIds << "RicExportFaultsFeature"; menuBuilder << "RicExportFaultsFeature";
} }
else if (dynamic_cast<RimSimWellInView*>(uiItem)) else if (dynamic_cast<RimSimWellInView*>(uiItem))
{ {
commandIds << "RicPlotProductionRateFeature"; menuBuilder << "RicPlotProductionRateFeature";
commandIds << "RicShowContributingWellsFeature"; menuBuilder << "RicShowContributingWellsFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicEclipseWellShowLabelFeature"; menuBuilder << "RicEclipseWellShowLabelFeature";
commandIds << "RicEclipseWellShowHeadFeature"; menuBuilder << "RicEclipseWellShowHeadFeature";
commandIds << "RicEclipseWellShowPipeFeature"; menuBuilder << "RicEclipseWellShowPipeFeature";
commandIds << "RicEclipseWellShowSpheresFeature"; menuBuilder << "RicEclipseWellShowSpheresFeature";
commandIds << "RicEclipseWellShowWellCellsFeature"; menuBuilder << "RicEclipseWellShowWellCellsFeature";
commandIds << "RicEclipseWellShowWellCellFenceFeature"; menuBuilder << "RicEclipseWellShowWellCellFenceFeature";
#ifdef USE_PROTOTYPE_FEATURE_FRACTURES #ifdef USE_PROTOTYPE_FEATURE_FRACTURES
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicNewSimWellFractureFeature"; menuBuilder << "RicNewSimWellFractureFeature";
#endif // USE_PROTOTYPE_FEATURE_FRACTURES #endif // USE_PROTOTYPE_FEATURE_FRACTURES
} }
} }
@ -585,83 +610,129 @@ QStringList RimContextCommandBuilder::commandsFromSelection()
if (RicToggleItemsFeatureImpl::isToggleCommandsAvailable()) if (RicToggleItemsFeatureImpl::isToggleCommandsAvailable())
{ {
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicToggleItemsOnFeature"; menuBuilder << "RicToggleItemsOnFeature";
commandIds << "RicToggleItemsOffFeature"; menuBuilder << "RicToggleItemsOffFeature";
commandIds << "RicToggleItemsFeature"; menuBuilder << "RicToggleItemsFeature";
} }
if ( caf::CmdFeatureManager::instance()->getCommandFeature("RicDeleteItemFeature")->canFeatureBeExecuted() ) if ( caf::CmdFeatureManager::instance()->getCommandFeature("RicDeleteItemFeature")->canFeatureBeExecuted() )
{ {
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicDeleteItemFeature"; menuBuilder << "RicDeleteItemFeature";
} }
if (caf::CmdFeatureManager::instance()->getCommandFeature("RicDeleteSubItemsFeature")->canFeatureBeExecuted()) if (caf::CmdFeatureManager::instance()->getCommandFeature("RicDeleteSubItemsFeature")->canFeatureBeExecuted())
{ {
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicDeleteSubItemsFeature"; menuBuilder << "RicDeleteSubItemsFeature";
} }
if (caf::CmdFeatureManager::instance()->getCommandFeature("RicWellPathDeleteFeature")->canFeatureBeExecuted()) if (caf::CmdFeatureManager::instance()->getCommandFeature("RicWellPathDeleteFeature")->canFeatureBeExecuted())
{ {
// Special delete command for Well paths // Special delete command for Well paths
// Placed here to fit context menu location of general delete feature // Placed here to fit context menu location of general delete feature
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicWellPathDeleteFeature"; menuBuilder << "RicWellPathDeleteFeature";
} }
if (caf::CmdFeatureManager::instance()->getCommandFeature("RicWellLogFileCloseFeature")->canFeatureBeExecuted()) if (caf::CmdFeatureManager::instance()->getCommandFeature("RicWellLogFileCloseFeature")->canFeatureBeExecuted())
{ {
// Special delete command for Well paths // Special delete command for Well paths
// Placed here to fit context menu location of general delete feature // Placed here to fit context menu location of general delete feature
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicWellLogFileCloseFeature"; menuBuilder << "RicWellLogFileCloseFeature";
} }
if ( caf::CmdFeatureManager::instance()->getCommandFeature("RicCloseCaseFeature")->canFeatureBeExecuted() ) if ( caf::CmdFeatureManager::instance()->getCommandFeature("RicCloseCaseFeature")->canFeatureBeExecuted() )
{ {
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicCloseCaseFeature"; menuBuilder << "RicCloseCaseFeature";
} }
return commandIds; return menuBuilder;
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimContextCommandBuilder::appendCommandsToMenu(const QStringList& commandIds, QMenu* menu) std::vector<RimWellPath*> RimContextCommandBuilder::allWellPaths()
{ {
CVF_ASSERT(menu); RimProject* proj = RiaApplication::instance()->project();
return proj->allWellPaths();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimContextCommandBuilder::createExecuteScriptForCasesFeatureMenu(caf::CmdFeatureMenuBuilder& menuBuilder)
{
//menuBuilder << "RicExecuteScriptForCasesFeature";
// Execute script on selection of cases
RiuMainWindow* ruiMainWindow = RiuMainWindow::instance();
if (ruiMainWindow)
{
std::vector<RimCase*> cases;
ruiMainWindow->selectedCases(cases);
if (cases.size() > 0)
{
menuBuilder.subMenuStart("Execute script");
RiaApplication* app = RiaApplication::instance();
RimProject* proj = app->project();
if (proj && proj->scriptCollection())
{
RimScriptCollection* rootScriptCollection = proj->scriptCollection();
// Root script collection holds a list of subdirectories of user defined script folders
for (size_t i = 0; i < rootScriptCollection->subDirectories.size(); i++)
{
RimScriptCollection* subDir = rootScriptCollection->subDirectories[i];
if (subDir)
{
appendScriptItems(menuBuilder, subDir);
}
}
}
menuBuilder.addSeparator();
menuBuilder.subMenuEnd();
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimContextCommandBuilder::appendScriptItems(caf::CmdFeatureMenuBuilder& menuBuilder, RimScriptCollection* scriptCollection)
{
QDir dir(scriptCollection->directory);
menuBuilder.subMenuStart(dir.dirName());
caf::CmdFeatureManager* commandManager = caf::CmdFeatureManager::instance(); caf::CmdFeatureManager* commandManager = caf::CmdFeatureManager::instance();
for (int i = 0; i < commandIds.size(); i++) CVF_ASSERT(commandManager);
{
if (commandIds[i] == "Separator")
{
menu->addSeparator();
}
else
{
caf::CmdFeature* feature = commandManager->getCommandFeature(commandIds[i].toStdString());
CVF_ASSERT(feature);
if (feature->canFeatureBeExecuted()) RicExecuteScriptForCasesFeature* executeScriptFeature = dynamic_cast<RicExecuteScriptForCasesFeature*>(commandManager->getCommandFeature("RicExecuteScriptForCasesFeature"));
{ CVF_ASSERT(executeScriptFeature);
QAction* act = commandManager->action(commandIds[i]);
CVF_ASSERT(act);
for (QAction* existingAct : menu->actions()) for (size_t i = 0; i < scriptCollection->calcScripts.size(); i++)
{ {
// If action exist, continue to make sure the action is positioned at the first RimCalcScript* calcScript = scriptCollection->calcScripts[i];
// location of a command ID QFileInfo fi(calcScript->absolutePath());
if (existingAct == act) continue;
QString menuText = fi.baseName();
menuBuilder.addCmdFeatureWithUserData("RicExecuteScriptForCasesFeature", menuText, QVariant(calcScript->absolutePath()));
} }
menu->addAction(act); for (size_t i = 0; i < scriptCollection->subDirectories.size(); i++)
} {
} RimScriptCollection* subDir = scriptCollection->subDirectories[i];
}
appendScriptItems(menuBuilder, subDir);
} }
menuBuilder.subMenuEnd();
}

15
ApplicationCode/ProjectDataModel/RimContextCommandBuilder.h
View File

@ -19,9 +19,14 @@
#pragma once #pragma once
#include <QStringList> #include <vector>
namespace caf {
class CmdFeatureMenuBuilder;
}
class QMenu; class QMenu;
class RimWellPath;
class RimScriptCollection;
//================================================================================================== //==================================================================================================
/// ///
@ -30,6 +35,10 @@ class QMenu;
class RimContextCommandBuilder class RimContextCommandBuilder
{ {
public: public:
static QStringList commandsFromSelection(); static caf::CmdFeatureMenuBuilder commandsFromSelection();
static void appendCommandsToMenu(const QStringList& commandIds, QMenu* menu);
private:
static std::vector<RimWellPath*> allWellPaths();
static void createExecuteScriptForCasesFeatureMenu(caf::CmdFeatureMenuBuilder& menuBuilder);
static void appendScriptItems(caf::CmdFeatureMenuBuilder& menuBuilder, RimScriptCollection* scriptCollection);
}; };

95
ApplicationCode/ProjectDataModel/RimProject.cpp
View File

@ -75,7 +75,7 @@
#include "cafCmdFeature.h" #include "cafCmdFeature.h"
#include "cafCmdFeatureManager.h" #include "cafCmdFeatureManager.h"
#include "cafPdmUiTreeOrdering.h" #include "cafPdmUiTreeOrdering.h"
#include "cafCmdFeatureMenuBuilder.h"
#include "cvfBoundingBox.h" #include "cvfBoundingBox.h"
#include <QDir> #include <QDir>
@ -754,63 +754,9 @@ void RimProject::computeUtmAreaOfInterest()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimProject::actionsBasedOnSelection(QMenu& contextMenu) void RimProject::actionsBasedOnSelection(QMenu& contextMenu)
{ {
QStringList commandIds = RimContextCommandBuilder::commandsFromSelection(); caf::CmdFeatureMenuBuilder menuBuilder = RimContextCommandBuilder::commandsFromSelection();
caf::CmdFeatureManager* commandManager = caf::CmdFeatureManager::instance(); menuBuilder.appendToMenu(&contextMenu);
for (int i = 0; i < commandIds.size(); i++)
{
if (commandIds[i] == "Separator")
{
contextMenu.addSeparator();
}
else if (commandIds[i] == "RicExecuteScriptForCasesFeature")
{
// Execute script on selection of cases
RiuMainWindow* ruiMainWindow = RiuMainWindow::instance();
if (ruiMainWindow)
{
std::vector<RimCase*> cases;
ruiMainWindow->selectedCases(cases);
if (cases.size() > 0)
{
QMenu* executeMenu = contextMenu.addMenu("Execute script");
RiaApplication* app = RiaApplication::instance();
RimProject* proj = app->project();
if (proj && proj->scriptCollection())
{
RimScriptCollection* rootScriptCollection = proj->scriptCollection();
// Root script collection holds a list of subdirectories of user defined script folders
for (size_t i = 0; i < rootScriptCollection->subDirectories.size(); i++)
{
RimScriptCollection* subDir = rootScriptCollection->subDirectories[i];
if (subDir)
{
appendScriptItems(executeMenu, subDir);
}
}
}
contextMenu.addSeparator();
contextMenu.addMenu(executeMenu);
}
}
}
else
{
caf::CmdFeature* feature = commandManager->getCommandFeature(commandIds[i].toStdString());
if (feature->canFeatureBeExecuted())
{
QAction* act = commandManager->action(commandIds[i]);
CVF_ASSERT(act);
contextMenu.addAction(act);
}
}
}
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -985,41 +931,6 @@ void RimProject::reloadCompletionTypeResultsForEclipseCase(RimEclipseCase* eclip
RiaApplication::instance()->scheduleRecalculateCompletionTypeAndRedrawEclipseCase(eclipseCase); RiaApplication::instance()->scheduleRecalculateCompletionTypeAndRedrawEclipseCase(eclipseCase);
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimProject::appendScriptItems(QMenu* menu, RimScriptCollection* scriptCollection)
{
CVF_ASSERT(menu);
QDir dir(scriptCollection->directory);
QMenu* subMenu = menu->addMenu(dir.dirName());
caf::CmdFeatureManager* commandManager = caf::CmdFeatureManager::instance();
CVF_ASSERT(commandManager);
RicExecuteScriptForCasesFeature* executeScriptFeature = dynamic_cast<RicExecuteScriptForCasesFeature*>(commandManager->getCommandFeature("RicExecuteScriptForCasesFeature"));
CVF_ASSERT(executeScriptFeature);
for (size_t i = 0; i < scriptCollection->calcScripts.size(); i++)
{
RimCalcScript* calcScript = scriptCollection->calcScripts[i];
QFileInfo fi(calcScript->absolutePath());
QString menuText = fi.baseName();
QAction* scriptAction = subMenu->addAction(menuText, executeScriptFeature, SLOT(slotExecuteScriptForSelectedCases()));
scriptAction->setData(QVariant(calcScript->absolutePath()));
}
for (size_t i = 0; i < scriptCollection->subDirectories.size(); i++)
{
RimScriptCollection* subDir = scriptCollection->subDirectories[i];
appendScriptItems(subMenu, subDir);
}
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

3
ApplicationCode/ProjectDataModel/RimProject.h
View File

@ -140,9 +140,6 @@ protected:
virtual void defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName = ""); virtual void defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName = "");
private:
void appendScriptItems(QMenu* menu, RimScriptCollection* scriptCollection);
private: private:
caf::PdmField<QString> m_projectFileVersionString; caf::PdmField<QString> m_projectFileVersionString;

10
ApplicationCode/ProjectDataModel/RimWellPath.cpp
View File

@ -656,6 +656,15 @@ void RimWellPath::addWellLogFile(RimWellLogFile* logFileInfo)
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimWellPath::deleteWellLogFile(RimWellLogFile* logFileInfo) void RimWellPath::deleteWellLogFile(RimWellLogFile* logFileInfo)
{
detachWellLogFile(logFileInfo);
delete logFileInfo;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellPath::detachWellLogFile(RimWellLogFile* logFileInfo)
{ {
auto pdmObject = dynamic_cast<caf::PdmObjectHandle*>(logFileInfo); auto pdmObject = dynamic_cast<caf::PdmObjectHandle*>(logFileInfo);
for (size_t i = 0; i < m_wellLogFiles.size(); i++) for (size_t i = 0; i < m_wellLogFiles.size(); i++)
@ -663,7 +672,6 @@ void RimWellPath::deleteWellLogFile(RimWellLogFile* logFileInfo)
if (m_wellLogFiles[i] == pdmObject) if (m_wellLogFiles[i] == pdmObject)
{ {
m_wellLogFiles.removeChildObject(pdmObject); m_wellLogFiles.removeChildObject(pdmObject);
delete pdmObject;
break; break;
} }
} }

1
ApplicationCode/ProjectDataModel/RimWellPath.h
View File

@ -68,6 +68,7 @@ public:
void addWellLogFile(RimWellLogFile* logFileInfo); void addWellLogFile(RimWellLogFile* logFileInfo);
void deleteWellLogFile(RimWellLogFile* logFileInfo); void deleteWellLogFile(RimWellLogFile* logFileInfo);
void detachWellLogFile(RimWellLogFile* logFileInfo);
virtual caf::PdmFieldHandle* userDescriptionField(); virtual caf::PdmFieldHandle* userDescriptionField();
virtual caf::PdmFieldHandle* objectToggleField(); virtual caf::PdmFieldHandle* objectToggleField();

6
ApplicationCode/UserInterface/RiuContextMenuLauncher.cpp
View File

@ -31,9 +31,9 @@
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RiuContextMenuLauncher::RiuContextMenuLauncher(QWidget* widget, const QStringList& commandIds) : RiuContextMenuLauncher::RiuContextMenuLauncher(QWidget* widget, const caf::CmdFeatureMenuBuilder& commandIds) :
QObject(widget), QObject(widget),
m_commandIds(commandIds) m_menuBuilder(commandIds)
{ {
widget->installEventFilter(this); widget->installEventFilter(this);
} }
@ -46,7 +46,7 @@ bool RiuContextMenuLauncher::eventFilter(QObject* watchedObject, QEvent* event)
if (event->type() == QEvent::ContextMenu) if (event->type() == QEvent::ContextMenu)
{ {
QMenu menu; QMenu menu;
RimContextCommandBuilder::appendCommandsToMenu(m_commandIds, &menu); m_menuBuilder.appendToMenu(&menu);
if (menu.actions().size() > 0) if (menu.actions().size() > 0)
{ {

5
ApplicationCode/UserInterface/RiuContextMenuLauncher.h
View File

@ -18,6 +18,7 @@
#pragma once #pragma once
#include "cafCmdFeatureMenuBuilder.h"
#include <QObject> #include <QObject>
#include <QStringList> #include <QStringList>
@ -32,12 +33,12 @@ class QWidget;
class RiuContextMenuLauncher : public QObject class RiuContextMenuLauncher : public QObject
{ {
public: public:
explicit RiuContextMenuLauncher(QWidget* widget, const QStringList& commandIds); explicit RiuContextMenuLauncher(QWidget* widget, const caf::CmdFeatureMenuBuilder& commandIds);
protected: protected:
bool eventFilter(QObject* watched, QEvent* event) override; bool eventFilter(QObject* watched, QEvent* event) override;
private: private:
QStringList m_commandIds; caf::CmdFeatureMenuBuilder m_menuBuilder;
}; };

8
ApplicationCode/UserInterface/RiuResultQwtPlot.cpp
View File

@ -25,6 +25,8 @@
#include "RiuLineSegmentQwtPlotCurve.h" #include "RiuLineSegmentQwtPlotCurve.h"
#include "cafCmdFeatureMenuBuilder.h"
#include "cvfBase.h" #include "cvfBase.h"
#include "cvfAssert.h" #include "cvfAssert.h"
#include "cvfColor3.h" #include "cvfColor3.h"
@ -130,11 +132,11 @@ QSize RiuResultQwtPlot::minimumSizeHint() const
void RiuResultQwtPlot::contextMenuEvent(QContextMenuEvent* event) void RiuResultQwtPlot::contextMenuEvent(QContextMenuEvent* event)
{ {
QMenu menu; QMenu menu;
QStringList commandIds; caf::CmdFeatureMenuBuilder menuBuilder;
commandIds << "RicNewGridTimeHistoryCurveFeature"; menuBuilder << "RicNewGridTimeHistoryCurveFeature";
RimContextCommandBuilder::appendCommandsToMenu(commandIds, &menu); menuBuilder.appendToMenu(&menu);
if (menu.actions().size() > 0) if (menu.actions().size() > 0)
{ {

7
ApplicationCode/UserInterface/RiuSummaryQwtPlot.cpp
View File

@ -32,6 +32,7 @@
#include "RiuQwtScalePicker.h" #include "RiuQwtScalePicker.h"
#include "cafSelectionManager.h" #include "cafSelectionManager.h"
#include "cafCmdFeatureMenuBuilder.h"
#include "qwt_date_scale_draw.h" #include "qwt_date_scale_draw.h"
#include "qwt_date_scale_engine.h" #include "qwt_date_scale_engine.h"
@ -166,13 +167,13 @@ QSize RiuSummaryQwtPlot::minimumSizeHint() const
void RiuSummaryQwtPlot::contextMenuEvent(QContextMenuEvent* event) void RiuSummaryQwtPlot::contextMenuEvent(QContextMenuEvent* event)
{ {
QMenu menu; QMenu menu;
QStringList commandIds; caf::CmdFeatureMenuBuilder menuBuilder;
caf::SelectionManager::instance()->setSelectedItem(ownerPlotDefinition()); caf::SelectionManager::instance()->setSelectedItem(ownerPlotDefinition());
commandIds << "RicShowPlotDataFeature"; menuBuilder << "RicShowPlotDataFeature";
RimContextCommandBuilder::appendCommandsToMenu(commandIds, &menu); menuBuilder.appendToMenu(&menu);
if (menu.actions().size() > 0) if (menu.actions().size() > 0)
{ {

65
ApplicationCode/UserInterface/RiuViewerCommands.cpp
View File

@ -73,6 +73,7 @@
#include "cafCmdFeatureManager.h" #include "cafCmdFeatureManager.h"
#include "cafDisplayCoordTransform.h" #include "cafDisplayCoordTransform.h"
#include "cafSelectionManager.h" #include "cafSelectionManager.h"
#include "cafCmdFeatureMenuBuilder.h"
#include "cvfDrawableGeo.h" #include "cvfDrawableGeo.h"
#include "cvfHitItemCollection.h" #include "cvfHitItemCollection.h"
@ -279,7 +280,7 @@ void RiuViewerCommands::displayContextMenu(QMouseEvent* event)
} }
} }
QStringList commandIds; caf::CmdFeatureMenuBuilder menuBuilder;
// Well log curve creation commands // Well log curve creation commands
if (firstHitPart && firstHitPart->sourceInfo()) if (firstHitPart && firstHitPart->sourceInfo())
@ -297,21 +298,21 @@ void RiuViewerCommands::displayContextMenu(QMouseEvent* event)
RiuSelectionManager::instance()->setSelectedItem(selItem, RiuSelectionManager::RUI_TEMPORARY); RiuSelectionManager::instance()->setSelectedItem(selItem, RiuSelectionManager::RUI_TEMPORARY);
#ifdef USE_PROTOTYPE_FEATURE_FRACTURES #ifdef USE_PROTOTYPE_FEATURE_FRACTURES
commandIds << "RicNewWellPathFractureAtPosFeature"; menuBuilder << "RicNewWellPathFractureAtPosFeature";
#endif // USE_PROTOTYPE_FEATURE_FRACTURES #endif // USE_PROTOTYPE_FEATURE_FRACTURES
//TODO: Update so these also use RiuWellPathSelectionItem //TODO: Update so these also use RiuWellPathSelectionItem
caf::SelectionManager::instance()->setSelectedItem(wellPath); caf::SelectionManager::instance()->setSelectedItem(wellPath);
commandIds << "RicNewWellLogCurveExtractionFeature"; menuBuilder << "RicNewWellLogCurveExtractionFeature";
commandIds << "RicNewWellLogFileCurveFeature"; menuBuilder << "RicNewWellLogFileCurveFeature";
commandIds << "RicNewRftPlotFeature"; menuBuilder << "RicNewRftPlotFeature";
commandIds << "RicNewPltPlotFeature"; menuBuilder << "RicNewPltPlotFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicNewWellPathIntersectionFeature"; menuBuilder << "RicNewWellPathIntersectionFeature";
commandIds << "RicNewFishbonesSubsAtMeasuredDepthFeature"; menuBuilder << "RicNewFishbonesSubsAtMeasuredDepthFeature";
commandIds << "RicNewPerforationIntervalAtMeasuredDepthFeature"; menuBuilder << "RicNewPerforationIntervalAtMeasuredDepthFeature";
} }
} }
@ -326,19 +327,19 @@ void RiuViewerCommands::displayContextMenu(QMouseEvent* event)
RiuSelectionItem* selItem = new RiuSimWellSelectionItem(eclipseWellSourceInfo->well(), m_currentPickPositionInDomainCoords, eclipseWellSourceInfo->branchIndex()); RiuSelectionItem* selItem = new RiuSimWellSelectionItem(eclipseWellSourceInfo->well(), m_currentPickPositionInDomainCoords, eclipseWellSourceInfo->branchIndex());
RiuSelectionManager::instance()->setSelectedItem(selItem, RiuSelectionManager::RUI_TEMPORARY); RiuSelectionManager::instance()->setSelectedItem(selItem, RiuSelectionManager::RUI_TEMPORARY);
commandIds << "RicNewWellLogCurveExtractionFeature"; menuBuilder << "RicNewWellLogCurveExtractionFeature";
commandIds << "RicNewWellLogRftCurveFeature"; menuBuilder << "RicNewWellLogRftCurveFeature";
commandIds << "RicNewRftPlotFeature"; menuBuilder << "RicNewRftPlotFeature";
commandIds << "RicNewPltPlotFeature"; menuBuilder << "RicNewPltPlotFeature";
commandIds << "RicShowWellAllocationPlotFeature"; menuBuilder << "RicShowWellAllocationPlotFeature";
commandIds << "RicPlotProductionRateFeature"; menuBuilder << "RicPlotProductionRateFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicShowContributingWellsFeature"; menuBuilder << "RicShowContributingWellsFeature";
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicNewSimWellIntersectionFeature"; menuBuilder << "RicNewSimWellIntersectionFeature";
commandIds << "RicPlotProductionRateFeature"; menuBuilder << "RicPlotProductionRateFeature";
#ifdef USE_PROTOTYPE_FEATURE_FRACTURES #ifdef USE_PROTOTYPE_FEATURE_FRACTURES
commandIds << "RicNewSimWellFractureAtPosFeature"; menuBuilder << "RicNewSimWellFractureAtPosFeature";
#endif // USE_PROTOTYPE_FEATURE_FRACTURES #endif // USE_PROTOTYPE_FEATURE_FRACTURES
} }
} }
@ -348,19 +349,19 @@ void RiuViewerCommands::displayContextMenu(QMouseEvent* event)
// View Link commands // View Link commands
if (!firstHitPart) if (!firstHitPart)
{ {
commandIds << "RicLinkViewFeature"; menuBuilder << "RicLinkViewFeature";
commandIds << "RicShowLinkOptionsFeature"; menuBuilder << "RicShowLinkOptionsFeature";
commandIds << "RicSetMasterViewFeature"; menuBuilder << "RicSetMasterViewFeature";
commandIds << "RicUnLinkViewFeature"; menuBuilder << "RicUnLinkViewFeature";
} }
commandIds << "Separator"; menuBuilder << "Separator";
commandIds << "RicNewGridTimeHistoryCurveFeature"; menuBuilder << "RicNewGridTimeHistoryCurveFeature";
commandIds << "RicShowFlowCharacteristicsPlotFeature"; menuBuilder << "RicShowFlowCharacteristicsPlotFeature";
commandIds << "RicSaveEclipseInputVisibleCellsFeature"; menuBuilder << "RicSaveEclipseInputVisibleCellsFeature";
commandIds << "RicShowGridStatisticsFeature"; menuBuilder << "RicShowGridStatisticsFeature";
RimContextCommandBuilder::appendCommandsToMenu(commandIds, &menu); menuBuilder.appendToMenu(&menu);
if (!menu.isEmpty()) if (!menu.isEmpty())
{ {

14
ApplicationCode/UserInterface/RiuWellAllocationPlot.cpp
View File

@ -79,16 +79,16 @@ RiuWellAllocationPlot::RiuWellAllocationPlot(RimWellAllocationPlot* plotDefiniti
m_legendWidget = new RiuNightchartsWidget(this); m_legendWidget = new RiuNightchartsWidget(this);
new RiuPlotObjectPicker(m_legendWidget, m_plotDefinition->plotLegend()); new RiuPlotObjectPicker(m_legendWidget, m_plotDefinition->plotLegend());
QStringList commandIds; caf::CmdFeatureMenuBuilder menuBuilder;
commandIds << "RicShowTotalAllocationDataFeature"; menuBuilder << "RicShowTotalAllocationDataFeature";
new RiuContextMenuLauncher(m_legendWidget, commandIds); new RiuContextMenuLauncher(m_legendWidget, menuBuilder);
rightColumnLayout->addWidget(m_legendWidget); rightColumnLayout->addWidget(m_legendWidget);
m_legendWidget->showPie(false); m_legendWidget->showPie(false);
QWidget* totalFlowAllocationWidget = m_plotDefinition->totalWellFlowPlot()->createViewWidget(this); QWidget* totalFlowAllocationWidget = m_plotDefinition->totalWellFlowPlot()->createViewWidget(this);
new RiuPlotObjectPicker(totalFlowAllocationWidget, m_plotDefinition->totalWellFlowPlot()); new RiuPlotObjectPicker(totalFlowAllocationWidget, m_plotDefinition->totalWellFlowPlot());
new RiuContextMenuLauncher(totalFlowAllocationWidget, commandIds); new RiuContextMenuLauncher(totalFlowAllocationWidget, menuBuilder);
rightColumnLayout->addWidget(totalFlowAllocationWidget, Qt::AlignTop); rightColumnLayout->addWidget(totalFlowAllocationWidget, Qt::AlignTop);
rightColumnLayout->addWidget(m_plotDefinition->tofAccumulatedPhaseFractionsPlot()->createViewWidget(this), Qt::AlignTop); rightColumnLayout->addWidget(m_plotDefinition->tofAccumulatedPhaseFractionsPlot()->createViewWidget(this), Qt::AlignTop);
@ -193,11 +193,11 @@ QSize RiuWellAllocationPlot::minimumSizeHint() const
void RiuWellAllocationPlot::contextMenuEvent(QContextMenuEvent* event) void RiuWellAllocationPlot::contextMenuEvent(QContextMenuEvent* event)
{ {
QMenu menu; QMenu menu;
QStringList commandIds; caf::CmdFeatureMenuBuilder menuBuilder;
commandIds << "RicShowContributingWellsFromPlotFeature"; menuBuilder << "RicShowContributingWellsFromPlotFeature";
RimContextCommandBuilder::appendCommandsToMenu(commandIds, &menu); menuBuilder.appendToMenu(&menu);
if (menu.actions().size() > 0) if (menu.actions().size() > 0)
{ {

9
ApplicationCode/UserInterface/RiuWellLogPlot.cpp
View File

@ -27,6 +27,7 @@
#include "RiuWellLogTrack.h" #include "RiuWellLogTrack.h"
#include "cafSelectionManager.h" #include "cafSelectionManager.h"
#include "cafCmdFeatureMenuBuilder.h"
#include "cvfAssert.h" #include "cvfAssert.h"
@ -214,14 +215,14 @@ QSize RiuWellLogPlot::sizeHint() const
void RiuWellLogPlot::contextMenuEvent(QContextMenuEvent* event) void RiuWellLogPlot::contextMenuEvent(QContextMenuEvent* event)
{ {
QMenu menu; QMenu menu;
QStringList commandIds; caf::CmdFeatureMenuBuilder menuBuilder;
caf::SelectionManager::instance()->setSelectedItem(ownerPlotDefinition()); caf::SelectionManager::instance()->setSelectedItem(ownerPlotDefinition());
commandIds << "RicShowPlotDataFeature"; menuBuilder << "RicShowPlotDataFeature";
commandIds << "RicShowContributingWellsFromPlotFeature"; menuBuilder << "RicShowContributingWellsFromPlotFeature";
RimContextCommandBuilder::appendCommandsToMenu(commandIds, &menu); menuBuilder.appendToMenu(&menu);
if (menu.actions().size() > 0) if (menu.actions().size() > 0)
{ {

2
Fwk/AppFwk/cafCommand/CMakeLists.txt
View File

@ -61,6 +61,8 @@ set( PROJECT_FILES
cafCmdFeature.h cafCmdFeature.h
cafCmdFeatureManager.cpp cafCmdFeatureManager.cpp
cafCmdFeatureManager.h cafCmdFeatureManager.h
cafCmdFeatureMenuBuilder.cpp
cafCmdFeatureMenuBuilder.h
) )

28
Fwk/AppFwk/cafCommand/cafCmdFeature.cpp
View File

@ -68,13 +68,21 @@ CmdFeature::~CmdFeature()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
QAction* CmdFeature::action() QAction* CmdFeature::action()
{ {
return this->action(QString("")); return this->actionWithCustomText(QString(""));
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
QAction* CmdFeature::action(QString customText) QAction* CmdFeature::actionWithCustomText(const QString& customText)
{
return actionWithUserData(customText, QVariant());
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QAction* CmdFeature::actionWithUserData(const QString& customText, const QVariant& userData)
{ {
QAction* action = NULL; QAction* action = NULL;
@ -88,6 +96,11 @@ QAction* CmdFeature::action(QString customText)
else else
{ {
action = new QAction(this); action = new QAction(this);
if (!userData.isNull())
{
action->setData(userData);
}
connect(action, SIGNAL(triggered(bool)), SLOT(actionTriggered(bool))); connect(action, SIGNAL(triggered(bool)), SLOT(actionTriggered(bool)));
m_customTextToActionMap[customText]= action; m_customTextToActionMap[customText]= action;
} }
@ -170,4 +183,15 @@ void CmdFeature::disableModelChangeContribution()
m_triggerModelChange = false; m_triggerModelChange = false;
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const QVariant CmdFeature::userData() const
{
QAction* action = qobject_cast<QAction*>(sender());
if (!action) return QVariant();
return action->data();
}
} // end namespace caf } // end namespace caf

4
Fwk/AppFwk/cafCommand/cafCmdFeature.h
View File

@ -77,7 +77,8 @@ public:
virtual ~CmdFeature(); virtual ~CmdFeature();
QAction* action(); QAction* action();
QAction* action(QString customText); QAction* actionWithCustomText(const QString& customText);
QAction* actionWithUserData(const QString& customText, const QVariant& userData);
void refreshEnabledState(); void refreshEnabledState();
void refreshCheckedState(); void refreshCheckedState();
@ -93,6 +94,7 @@ protected:
virtual bool isCommandChecked(); virtual bool isCommandChecked();
void disableModelChangeContribution(); void disableModelChangeContribution();
const QVariant userData() const;
private: private:
std::map<QString, QAction*> m_customTextToActionMap; std::map<QString, QAction*> m_customTextToActionMap;

16
Fwk/AppFwk/cafCommand/cafCmdFeatureManager.cpp
View File

@ -108,7 +108,21 @@ QAction* CmdFeatureManager::action(const QString& commandId, const QString& cust
{ {
std::pair<CmdFeature*, size_t> featurePair = createFeature(commandId.toStdString()); std::pair<CmdFeature*, size_t> featurePair = createFeature(commandId.toStdString());
QAction* act = featurePair.first->action(customActionText); QAction* act = featurePair.first->actionWithCustomText(customActionText);
m_actionToFeatureIdxMap[act] = featurePair.second;
return act;
}
//--------------------------------------------------------------------------------------------------
/// Get action for the specified command, with custom action text
/// The action is owned by the PdmCommandItemManager
//--------------------------------------------------------------------------------------------------
QAction* CmdFeatureManager::actionWithUserData(const QString& commandId, const QString& customActionText, const QVariant& userData)
{
std::pair<CmdFeature*, size_t> featurePair = createFeature(commandId.toStdString());
QAction* act = featurePair.first->actionWithUserData(customActionText, userData);
m_actionToFeatureIdxMap[act] = featurePair.second; m_actionToFeatureIdxMap[act] = featurePair.second;
return act; return act;

4
Fwk/AppFwk/cafCommand/cafCmdFeatureManager.h
View File

@ -63,8 +63,8 @@ public:
virtual ~CmdFeatureManager(); virtual ~CmdFeatureManager();
QAction* action(const QString& commandId); QAction* action(const QString& commandId);
QAction* action(const QString& commandId, const QString& actionText); QAction* action(const QString& commandId, const QString& customActionText);
QAction* actionWithUserData(const QString& commandId, const QString& customActionText, const QVariant& userData);
void refreshStates(const QStringList& commandIdList = QStringList()); void refreshStates(const QStringList& commandIdList = QStringList());
void refreshEnabledState(const QStringList& commandIdList = QStringList()); void refreshEnabledState(const QStringList& commandIdList = QStringList());
void refreshCheckedState(const QStringList& commandIdList = QStringList()); void refreshCheckedState(const QStringList& commandIdList = QStringList());

209
Fwk/AppFwk/cafCommand/cafCmdFeatureMenuBuilder.cpp Normal file
View File

@ -0,0 +1,209 @@
//##################################################################################################
//
// Custom Visualization Core library
// Copyright (C) 2011-2013 Ceetron AS
//
// This library may be used under the terms of either the GNU General Public License or
// the GNU Lesser General Public License as follows:
//
// GNU General Public License Usage
// This library 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.
//
// This library 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.
//
// GNU Lesser General Public License Usage
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation; either version 2.1 of the License, or
// (at your option) any later version.
//
// This library 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 Lesser General Public License at <<http://www.gnu.org/licenses/lgpl-2.1.html>>
// for more details.
//
//##################################################################################################
#include "cafCmdFeatureMenuBuilder.h"
#include "cafCmdFeature.h"
#include "cafCmdFeatureManager.h"
#include "cafCmdSelectionHelper.h"
#include "cafFactory.h"
#include "cvfAssert.h"
#include "defaultfeatures/cafCmdDeleteItemFeature.h"
#include "defaultfeatures/cafCmdAddItemFeature.h"
#include <QAction>
#include <QMenu>
namespace caf
{
// typedef Factory<CmdFeature, std::string> CommandFeatureFactory;
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
CmdFeatureMenuBuilder::CmdFeatureMenuBuilder()
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
CmdFeatureMenuBuilder::~CmdFeatureMenuBuilder()
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
CmdFeatureMenuBuilder& CmdFeatureMenuBuilder::operator<<(const QString& commandId)
{
if (commandId == "Separator")
{
addSeparator();
}
else
{
addCmdFeature(commandId);
}
return *this;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
CmdFeatureMenuBuilder& CmdFeatureMenuBuilder::addCmdFeature(const QString commandId, const QString& uiText)
{
MenuItem i;
i.itemType = MenuItem::COMMAND;
i.itemName = commandId;
i.uiText = uiText;
m_items.push_back(i);
return *this;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
CmdFeatureMenuBuilder& CmdFeatureMenuBuilder::addCmdFeatureWithUserData(const QString commandId, const QString& uiText, const QVariant& userData)
{
MenuItem i;
i.itemType = MenuItem::COMMAND;
i.itemName = commandId;
i.uiText = uiText;
i.userData = userData;
m_items.push_back(i);
return *this;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
CmdFeatureMenuBuilder& CmdFeatureMenuBuilder::addSeparator()
{
MenuItem i;
i.itemType = MenuItem::SEPARATOR;
m_items.push_back(i);
return *this;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
CmdFeatureMenuBuilder& CmdFeatureMenuBuilder::subMenuStart(const QString& menuName)
{
MenuItem i;
i.itemType = MenuItem::SUBMENU_START;
i.itemName = menuName;
m_items.push_back(i);
return *this;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
CmdFeatureMenuBuilder& CmdFeatureMenuBuilder::subMenuEnd()
{
MenuItem i;
i.itemType = MenuItem::SUBMENU_END;
m_items.push_back(i);
return *this;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void CmdFeatureMenuBuilder::appendToMenu(QMenu* menu)
{
CVF_ASSERT(menu);
std::vector<QMenu*> menus = { menu };
for (int i = 0; i < m_items.size(); i++)
{
if (m_items[i].itemType == MenuItem::SEPARATOR)
{
menu->addSeparator();
}
else if (m_items[i].itemType == MenuItem::SUBMENU_START)
{
QMenu* subMenu = menus.back()->addMenu(m_items[i].itemName);
menus.push_back(subMenu);
}
else if (m_items[i].itemType == MenuItem::SUBMENU_END)
{
if (menus.size() > 1)
{
menus.pop_back();
}
}
else
{
CmdFeatureManager* commandManager = CmdFeatureManager::instance();
QMenu* currentMenu = menus.back();
caf::CmdFeature* feature = commandManager->getCommandFeature(m_items[i].itemName.toStdString());
CVF_ASSERT(feature);
if (feature->canFeatureBeExecuted())
{
const QAction* act;
if (!m_items[i].userData.isNull())
{
act = commandManager->actionWithUserData(m_items[i].itemName, m_items[i].uiText, m_items[i].userData);
}
else
{
act = commandManager->action(m_items[i].itemName);
}
CVF_ASSERT(act);
for (QAction* existingAct : currentMenu->actions())
{
// If action exist, continue to make sure the action is positioned at the first
// location of a command ID
if (existingAct == act) continue;
}
currentMenu->addAction(const_cast<QAction*>(act));
}
}
}
}
} // end namespace caf

110
Fwk/AppFwk/cafCommand/cafCmdFeatureMenuBuilder.h Normal file
View File

@ -0,0 +1,110 @@
//##################################################################################################
//
// Custom Visualization Core library
// Copyright (C) 2011-2013 Ceetron AS
//
// This library may be used under the terms of either the GNU General Public License or
// the GNU Lesser General Public License as follows:
//
// GNU General Public License Usage
// This library 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.
//
// This library 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.
//
// GNU Lesser General Public License Usage
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation; either version 2.1 of the License, or
// (at your option) any later version.
//
// This library 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 Lesser General Public License at <<http://www.gnu.org/licenses/lgpl-2.1.html>>
// for more details.
//
//##################################################################################################
#pragma once
#include <vector>
#include <map>
#include <set>
#include <QObject>
#include <QVariant>
class QAction;
class QMenu;
namespace caf
{
class CmdFeature;
//==================================================================================================
///
//==================================================================================================
class CmdFeatureMenuBuilder
{
public:
CmdFeatureMenuBuilder();
//CmdFeatureMenuBuilder(const CmdFeatureMenuBuilder& other);
virtual ~CmdFeatureMenuBuilder();
CmdFeatureMenuBuilder& operator<<(const QString& commandIdOrSeparator);
CmdFeatureMenuBuilder& addCmdFeature(const QString commandId, const QString& customUiText = "");
CmdFeatureMenuBuilder& addCmdFeatureWithUserData(const QString commandId, const QString& customUiText, const QVariant& userData);
CmdFeatureMenuBuilder& addSeparator();
CmdFeatureMenuBuilder& subMenuStart(const QString& menuName);
CmdFeatureMenuBuilder& subMenuEnd();
void appendToMenu(QMenu* menu);
// const std::vector<MenuItem> items() const;
private:
struct MenuItem
{
public:
enum ItemType { COMMAND, SEPARATOR, SUBMENU_START, SUBMENU_END };
ItemType itemType;
QString itemName;
QString uiText;
QVariant userData;
};
std::vector<MenuItem> m_items;
};
} // end namespace caf
//static MenuItem command(QString commandName)
//{
// MenuItem i;
// i.itemType = COMMAND;
// i.itemName = commandName;
// return i;
//}
//
//static MenuItem separator()
//{
// MenuItem i;
// i.itemType = SEPARATOR;
// return i;
//}