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 remote-tracking branch 'origin/dev' into summary-template-adjustments

Browse Source
This commit is contained in:
Magne Sjaastad 2019-09-30 19:41:07 +02:00
commit 7ce7211187
19 changed files with 300 additions and 188 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
ApplicationCode/Commands/PlotTemplateCommands/RicCreatePlotFromTemplateByShortcutFeature.cpp
View File

@ -61,8 +61,10 @@ void RicCreatePlotFromTemplateByShortcutFeature::onActionTriggered( bool isCheck
if ( reply == QMessageBox::No ) return;
QString fileName = RicSummaryPlotTemplateTools::selectPlotTemplatePath();
QString fileNameSelectedInUi = RicSummaryPlotTemplateTools::selectPlotTemplatePath();
if ( fileNameSelectedInUi.isEmpty() ) return;
fileName = fileNameSelectedInUi;
RiaApplication::instance()->preferences()->setDefaultPlotTemplatePath( fileName );
}

2
ApplicationCode/Commands/PlotTemplateCommands/RicSummaryPlotTemplateTools.cpp
View File

@ -240,8 +240,6 @@ QString RicSummaryPlotTemplateTools::htmlTextFromCount( const QString& itemText,
//--------------------------------------------------------------------------------------------------
QString RicSummaryPlotTemplateTools::selectPlotTemplatePath()
{
QString fileName;
RiuPlotMainWindow* plotwindow = RiaGuiApplication::instance()->mainPlotWindow();
RicSelectPlotTemplateUi* ui = RiaGuiApplication::instance()->project()->dialogData()->selectPlotTemplateUi();

4
ApplicationCode/Commands/SummaryPlotCommands/RicSummaryPlotFeatureImpl.cpp
View File

@ -659,9 +659,9 @@ void RicSummaryPlotFeatureImpl::createSummaryPlotsFromArgumentLine( const QStrin
// Needed to avoid unneccessary activation of sub windows (plots)
// which results in population of property editor, and missing deleteLater because we are outside any event
// loop when switching object. Results in stray widgets.
mpw->setBlockSlotSubWindowActivated( true );
mpw->setBlockSubWindowProjectTreeSelection( true );
RiuPlotMainWindowTools::showPlotMainWindow();
mpw->setBlockSlotSubWindowActivated( false );
mpw->setBlockSubWindowProjectTreeSelection( false );
RiuPlotMainWindowTools::setExpanded( lastPlotCreated );
RiuPlotMainWindowTools::selectAsCurrentItem( lastPlotCreated );

9
ApplicationCode/ProjectDataModel/Flow/RimWellFlowRateCurve.cpp
View File

@ -236,7 +236,7 @@ void RimWellFlowRateCurve::updateStackedPlotData()
stackedCurves = stackedCurveGroups[groupId()];
}
std::vector<double> allDepthValues = m_curveData->measuredDepths();
std::vector<double> allDepthValues = curveData()->measuredDepths();
std::vector<double> allStackedValues( allDepthValues.size() );
for ( RimWellFlowRateCurve* stCurve : stackedCurves )
@ -305,6 +305,9 @@ void RimWellFlowRateCurve::updateStackedPlotData()
polyLineStartStopIndices.front().second += 1;
}
auto minmax_it = std::minmax_element( stackedValues.begin(), stackedValues.end() );
this->setOverrideCurveDataXRange( *( minmax_it.first ), *( minmax_it.second ) );
m_qwtPlotCurve->setSamples( stackedValues.data(), depthValues.data(), static_cast<int>( depthValues.size() ) );
m_qwtPlotCurve->setLineSegmentStartStopIndices( polyLineStartStopIndices );
@ -344,9 +347,7 @@ void RimWellFlowRateCurve::setFlowValuesPrDepthValue( const QString&
const std::vector<double>& depthValues,
const std::vector<double>& flowRates )
{
m_curveData = new RigWellLogCurveData;
m_curveData->setValuesAndMD( flowRates, depthValues, RiaDefines::UNIT_NONE, false );
this->setValuesAndMD( flowRates, depthValues, RiaDefines::UNIT_NONE, false );
m_curveAutoName = curveName;
}

5
ApplicationCode/ProjectDataModel/RimContextCommandBuilder.cpp
View File

@ -893,9 +893,10 @@ caf::CmdFeatureMenuBuilder RimContextCommandBuilder::commandsFromSelection()
else if ( dynamic_cast<RimWellLogPlot*>( uiItem ) )
{
menuBuilder << "RicAsciiExportWellLogPlotFeature";
menuBuilder << "RicExportToLasFileFeature";
menuBuilder << "RicChangeDataSourceFeature";
}
else if ( dynamic_cast<RimWellLogCurve*>( uiItem ) || dynamic_cast<RimWellLogTrack*>( uiItem ) ||
dynamic_cast<RimWellLogPlot*>( uiItem ) )
else if ( dynamic_cast<RimWellLogCurve*>( uiItem ) || dynamic_cast<RimWellLogTrack*>( uiItem ) )
{
menuBuilder << "RicExportToLasFileFeature";
menuBuilder << "RicChangeDataSourceFeature";

72
ApplicationCode/ProjectDataModel/RimWellLogCurve.cpp
View File

@ -49,6 +49,10 @@ RimWellLogCurve::RimWellLogCurve()
m_qwtPlotCurve->setXAxis( QwtPlot::xTop );
m_qwtPlotCurve->setErrorBarsXAxis( QwtPlot::xTop );
m_qwtPlotCurve->setYAxis( QwtPlot::yLeft );
m_curveData = new RigWellLogCurveData;
m_curveDataXRange = std::make_pair( std::numeric_limits<double>::infinity(),
-std::numeric_limits<double>::infinity() );
}
//--------------------------------------------------------------------------------------------------
@ -67,25 +71,44 @@ bool RimWellLogCurve::xValueRangeInData( double* minimumValue, double* maximumVa
{
return false;
}
if ( m_curveData->xValues().empty() )
if ( m_curveDataXRange.first == -std::numeric_limits<double>::infinity() ||
m_curveDataXRange.second == std::numeric_limits<double>::infinity() )
{
return false;
}
*minimumValue = std::numeric_limits<double>::infinity();
*maximumValue = -std::numeric_limits<double>::infinity();
*minimumValue = m_curveDataXRange.first;
*maximumValue = m_curveDataXRange.second;
for ( double xValue : m_curveData->xValues() )
{
if ( RiaCurveDataTools::isValidValue( xValue, false ) )
{
*minimumValue = std::min( *minimumValue, xValue );
*maximumValue = std::max( *maximumValue, xValue );
}
}
return true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogCurve::setValuesAndMD( const std::vector<double>& xValues,
const std::vector<double>& measuredDepths,
RiaDefines::DepthUnitType depthUnit,
bool isExtractionCurve )
{
m_curveData->setValuesAndMD( xValues, measuredDepths, depthUnit, isExtractionCurve );
calculateCurveDataXRange();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogCurve::setValuesWithTVD( const std::vector<double>& xValues,
const std::vector<double>& measuredDepths,
const std::vector<double>& tvDepths,
RiaDefines::DepthUnitType depthUnit,
bool isExtractionCurve )
{
m_curveData->setValuesWithTVD( xValues, measuredDepths, tvDepths, depthUnit, isExtractionCurve );
calculateCurveDataXRange();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -127,3 +150,30 @@ void RimWellLogCurve::updateLegendsInPlot()
wellLogTrack->updateAllLegendItems();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogCurve::setOverrideCurveDataXRange( double minimumValue, double maximumValue )
{
m_curveDataXRange = std::make_pair( minimumValue, maximumValue );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogCurve::calculateCurveDataXRange()
{
// Invalidate range first
m_curveDataXRange = std::make_pair( std::numeric_limits<double>::infinity(),
-std::numeric_limits<double>::infinity() );
for ( double xValue : m_curveData->xValues() )
{
if ( RiaCurveDataTools::isValidValue( xValue, false ) )
{
m_curveDataXRange.first = std::min( m_curveDataXRange.first, xValue );
m_curveDataXRange.second = std::max( m_curveDataXRange.second, xValue );
}
}
}

19
ApplicationCode/ProjectDataModel/RimWellLogCurve.h
View File

@ -19,6 +19,7 @@
#pragma once
#include "RiaDefines.h"
#include "RimPlotCurve.h"
#include "cvfObject.h"
@ -40,6 +41,17 @@ public:
bool xValueRangeInData( double* minimumValue, double* maximumValue ) const;
void setValuesAndMD( const std::vector<double>& xValues,
const std::vector<double>& measuredDepths,
RiaDefines::DepthUnitType depthUnit,
bool isExtractionCurve );
void setValuesWithTVD( const std::vector<double>& xValues,
const std::vector<double>& measuredDepths,
const std::vector<double>& tvDepths,
RiaDefines::DepthUnitType depthUnit,
bool isExtractionCurve );
const RigWellLogCurveData* curveData() const;
virtual QString wellName() const = 0;
@ -52,7 +64,12 @@ public:
protected:
void updateZoomInParentPlot() override;
void updateLegendsInPlot() override;
void setOverrideCurveDataXRange( double minimumValue, double maximumValue );
protected:
private:
void calculateCurveDataXRange();
private:
cvf::ref<RigWellLogCurveData> m_curveData;
std::pair<double, double> m_curveDataXRange;
};

19
ApplicationCode/ProjectDataModel/RimWellLogExtractionCurve.cpp
View File

@ -349,19 +349,19 @@ void RimWellLogExtractionCurve::onLoadDataAndUpdate( bool updateParentPlot )
if ( wellLogPlot->depthType() == RimWellLogPlot::TRUE_VERTICAL_DEPTH )
{
m_qwtPlotCurve->setSamples( m_curveData->xPlotValues().data(),
m_curveData->trueDepthPlotValues( displayUnit ).data(),
static_cast<int>( m_curveData->xPlotValues().size() ) );
m_qwtPlotCurve->setSamples( curveData()->xPlotValues().data(),
curveData()->trueDepthPlotValues( displayUnit ).data(),
static_cast<int>( curveData()->xPlotValues().size() ) );
isUsingPseudoLength = false;
}
else if ( wellLogPlot->depthType() == RimWellLogPlot::MEASURED_DEPTH )
{
m_qwtPlotCurve->setSamples( m_curveData->xPlotValues().data(),
m_curveData->measuredDepthPlotValues( displayUnit ).data(),
static_cast<int>( m_curveData->xPlotValues().size() ) );
m_qwtPlotCurve->setSamples( curveData()->xPlotValues().data(),
curveData()->measuredDepthPlotValues( displayUnit ).data(),
static_cast<int>( curveData()->xPlotValues().size() ) );
}
m_qwtPlotCurve->setLineSegmentStartStopIndices( m_curveData->polylineStartStopIndices() );
m_qwtPlotCurve->setLineSegmentStartStopIndices( curveData()->polylineStartStopIndices() );
this->RimPlotCurve::updateCurvePresentation( updateParentPlot );
@ -497,16 +497,15 @@ void RimWellLogExtractionCurve::extractData( bool* isUsingPseudoLength )
geomExtractor->curveData( m_geomResultDefinition->resultAddress(), m_timeStep, &values );
}
m_curveData = new RigWellLogCurveData;
if ( values.size() && measuredDepthValues.size() )
{
if ( !tvDepthValues.size() )
{
m_curveData->setValuesAndMD( values, measuredDepthValues, depthUnit, true );
this->setValuesAndMD( values, measuredDepthValues, depthUnit, true );
}
else
{
m_curveData->setValuesWithTVD( values, measuredDepthValues, tvDepthValues, depthUnit, true );
this->setValuesWithTVD( values, measuredDepthValues, tvDepthValues, depthUnit, true );
}
}
}

38
ApplicationCode/ProjectDataModel/RimWellLogFileCurve.cpp
View File

@ -77,8 +77,6 @@ void RimWellLogFileCurve::onLoadDataAndUpdate( bool updateParentPlot )
if ( isCurveVisible() )
{
m_curveData = new RigWellLogCurveData;
RimWellLogPlot* wellLogPlot;
firstAncestorOrThisOfType( wellLogPlot );
CVF_ASSERT( wellLogPlot );
@ -100,11 +98,11 @@ void RimWellLogFileCurve::onLoadDataAndUpdate( bool updateParentPlot )
if ( values.size() == measuredDepthValues.size() && values.size() == tvdMslValues.size() )
{
m_curveData->setValuesWithTVD( values,
measuredDepthValues,
tvdMslValues,
wellLogFile->depthUnit(),
false );
this->setValuesWithTVD( values,
measuredDepthValues,
tvdMslValues,
wellLogFile->depthUnit(),
false );
canUseTvd = true;
}
}
@ -124,11 +122,11 @@ void RimWellLogFileCurve::onLoadDataAndUpdate( bool updateParentPlot )
if ( values.size() == trueVerticeldepthValues.size() &&
values.size() == measuredDepthValues.size() )
{
m_curveData->setValuesWithTVD( values,
measuredDepthValues,
trueVerticeldepthValues,
wellLogFile->depthUnit(),
false );
this->setValuesWithTVD( values,
measuredDepthValues,
trueVerticeldepthValues,
wellLogFile->depthUnit(),
false );
canUseTvd = true;
}
}
@ -152,7 +150,7 @@ void RimWellLogFileCurve::onLoadDataAndUpdate( bool updateParentPlot )
{
if ( values.size() == measuredDepthValues.size() )
{
m_curveData->setValuesAndMD( values, measuredDepthValues, wellLogFile->depthUnit(), false );
this->setValuesAndMD( values, measuredDepthValues, wellLogFile->depthUnit(), false );
}
}
}
@ -170,17 +168,17 @@ void RimWellLogFileCurve::onLoadDataAndUpdate( bool updateParentPlot )
}
if ( wellLogPlot && wellLogPlot->depthType() == RimWellLogPlot::TRUE_VERTICAL_DEPTH )
{
m_qwtPlotCurve->setSamples( m_curveData->xPlotValues().data(),
m_curveData->trueDepthPlotValues( displayUnit ).data(),
static_cast<int>( m_curveData->xPlotValues().size() ) );
m_qwtPlotCurve->setSamples( this->curveData()->xPlotValues().data(),
this->curveData()->trueDepthPlotValues( displayUnit ).data(),
static_cast<int>( this->curveData()->xPlotValues().size() ) );
}
else
{
m_qwtPlotCurve->setSamples( m_curveData->xPlotValues().data(),
m_curveData->measuredDepthPlotValues( displayUnit ).data(),
static_cast<int>( m_curveData->xPlotValues().size() ) );
m_qwtPlotCurve->setSamples( this->curveData()->xPlotValues().data(),
this->curveData()->measuredDepthPlotValues( displayUnit ).data(),
static_cast<int>( this->curveData()->xPlotValues().size() ) );
}
m_qwtPlotCurve->setLineSegmentStartStopIndices( m_curveData->polylineStartStopIndices() );
m_qwtPlotCurve->setLineSegmentStartStopIndices( this->curveData()->polylineStartStopIndices() );
if ( updateParentPlot )
{

22
ApplicationCode/ProjectDataModel/RimWellLogRftCurve.cpp
View File

@ -372,8 +372,6 @@ void RimWellLogRftCurve::onLoadDataAndUpdate( bool updateParentPlot )
if ( isCurveVisible() )
{
m_curveData = new RigWellLogCurveData;
RimWellLogPlot* wellLogPlot;
firstAncestorOrThisOfType( wellLogPlot );
CVF_ASSERT( wellLogPlot );
@ -435,11 +433,11 @@ void RimWellLogRftCurve::onLoadDataAndUpdate( bool updateParentPlot )
measuredDepthVector = tvDepthVector;
}
m_curveData->setValuesWithTVD( values,
measuredDepthVector,
tvDepthVector,
RiaEclipseUnitTools::depthUnit( unitSystem ),
false );
this->setValuesWithTVD( values,
measuredDepthVector,
tvDepthVector,
RiaEclipseUnitTools::depthUnit( unitSystem ),
false );
RiaDefines::DepthUnitType displayUnit = RiaDefines::UNIT_METER;
if ( wellLogPlot )
@ -451,8 +449,8 @@ void RimWellLogRftCurve::onLoadDataAndUpdate( bool updateParentPlot )
{
m_qwtPlotCurve->showErrorBars( showErrorBarsInObservedData );
m_qwtPlotCurve->setPerPointLabels( perPointLabels );
m_qwtPlotCurve->setSamplesFromXValuesAndYValues( m_curveData->xPlotValues(),
m_curveData->measuredDepthPlotValues( displayUnit ),
m_qwtPlotCurve->setSamplesFromXValuesAndYValues( this->curveData()->xPlotValues(),
this->curveData()->measuredDepthPlotValues( displayUnit ),
errors,
false,
RiuQwtPlotCurve::ERROR_ALONG_X_AXIS );
@ -486,14 +484,14 @@ void RimWellLogRftCurve::onLoadDataAndUpdate( bool updateParentPlot )
{
m_qwtPlotCurve->showErrorBars( showErrorBarsInObservedData );
m_qwtPlotCurve->setPerPointLabels( perPointLabels );
m_qwtPlotCurve->setSamplesFromXValuesAndYValues( m_curveData->xPlotValues(),
m_curveData->trueDepthPlotValues( displayUnit ),
m_qwtPlotCurve->setSamplesFromXValuesAndYValues( this->curveData()->xPlotValues(),
this->curveData()->trueDepthPlotValues( displayUnit ),
errors,
false,
RiuQwtPlotCurve::ERROR_ALONG_X_AXIS );
}
m_qwtPlotCurve->setLineSegmentStartStopIndices( m_curveData->polylineStartStopIndices() );
m_qwtPlotCurve->setLineSegmentStartStopIndices( this->curveData()->polylineStartStopIndices() );
if ( updateParentPlot )
{

184
ApplicationCode/UserInterface/RiuMainWindow.cpp
View File

@ -97,6 +97,8 @@
#include <QTreeView>
#include <QUndoStack>
#include <QDebug>
#include <algorithm>
//==================================================================================================
@ -1030,14 +1032,17 @@ QMdiSubWindow* RiuMainWindow::findMdiSubWindow( QWidget* viewer )
//--------------------------------------------------------------------------------------------------
RimViewWindow* RiuMainWindow::findViewWindowFromSubWindow( QMdiSubWindow* subWindow )
{
std::vector<RimViewWindow*> allViewWindows;
RiaApplication::instance()->project()->descendantsIncludingThisOfType( allViewWindows );
for ( RimViewWindow* viewWindow : allViewWindows )
if ( subWindow )
{
if ( viewWindow->viewWidget() == subWindow->widget() )
std::vector<RimViewWindow*> allViewWindows;
RiaApplication::instance()->project()->descendantsIncludingThisOfType( allViewWindows );
for ( RimViewWindow* viewWindow : allViewWindows )
{
return viewWindow;
if ( viewWindow->viewWidget() == subWindow->widget() )
{
return viewWindow;
}
}
}
return nullptr;
@ -1226,109 +1231,90 @@ void RiuMainWindow::slotViewFromBelow()
//--------------------------------------------------------------------------------------------------
void RiuMainWindow::slotSubWindowActivated( QMdiSubWindow* subWindow )
{
if ( !subWindow ) return;
if ( blockSlotSubWindowActivated() ) return;
if ( blockSubWindowActivation() ) return;
RimProject* proj = RiaApplication::instance()->project();
if ( !proj ) return;
Rim3dView* previousActiveReservoirView = RiaApplication::instance()->activeReservoirView();
Rim3dView* activatedView = dynamic_cast<Rim3dView*>( findViewWindowFromSubWindow( subWindow ) );
// Find the activated 3D view
if ( !activatedView ) return;
RiaApplication::instance()->setActiveReservoirView( activatedView );
Rim3dView* activatedView = nullptr;
std::vector<RimCase*> allCases;
proj->allCases( allCases );
for ( RimCase* reservoirCase : allCases )
if ( !blockSubWindowProjectTreeSelection() )
{
if ( reservoirCase == nullptr ) continue;
selectViewInProjectTree( previousActiveReservoirView, activatedView );
}
std::vector<Rim3dView*> views = reservoirCase->views();
slotRefreshViewActions();
refreshAnimationActions();
refreshDrawStyleActions();
}
size_t viewIdx;
for ( viewIdx = 0; viewIdx < views.size(); viewIdx++ )
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuMainWindow::selectViewInProjectTree( const Rim3dView* previousActiveReservoirView, Rim3dView* activatedView )
{
bool is3dViewCurrentlySelected = false;
if ( caf::SelectionManager::instance()->selectedItem() )
{
if ( caf::SelectionManager::instance()->selectedItemAncestorOfType<Rim3dView>() )
{
Rim3dView* riv = views[viewIdx];
if ( riv && riv->viewer() && riv->viewer()->layoutWidget() &&
riv->viewer()->layoutWidget()->parent() == subWindow )
{
activatedView = riv;
break;
}
is3dViewCurrentlySelected = true;
}
}
if ( is3dViewCurrentlySelected && ( previousActiveReservoirView != activatedView ) )
{
Rim3dView* previousActiveReservoirView = RiaApplication::instance()->activeReservoirView();
RiaApplication::instance()->setActiveReservoirView( activatedView );
QModelIndex newViewModelIndex = m_projectTreeView->findModelIndex( activatedView );
QModelIndex newSelectionIndex = newViewModelIndex;
bool is3dViewCurrentlySelected = false;
if ( caf::SelectionManager::instance()->selectedItem() )
if ( previousActiveReservoirView && is3dViewCurrentlySelected )
{
if ( caf::SelectionManager::instance()->selectedItemAncestorOfType<Rim3dView>() )
// Try to select the same entry in the new View, as was selected in the previous
QModelIndex previousViewModelIndex = m_projectTreeView->findModelIndex( previousActiveReservoirView );
QModelIndex currentSelectionIndex = m_projectTreeView->treeView()->selectionModel()->currentIndex();
if ( currentSelectionIndex != newViewModelIndex && currentSelectionIndex.isValid() )
{
is3dViewCurrentlySelected = true;
}
}
QVector<QModelIndex> route; // Contains all model indices from current selection up to previous view
if ( is3dViewCurrentlySelected && ( previousActiveReservoirView != activatedView ) )
{
QModelIndex newViewModelIndex = m_projectTreeView->findModelIndex( activatedView );
QModelIndex newSelectionIndex = newViewModelIndex;
QModelIndex tmpModelIndex = currentSelectionIndex;
if ( previousActiveReservoirView && is3dViewCurrentlySelected )
{
// Try to select the same entry in the new View, as was selected in the previous
QModelIndex previousViewModelIndex = m_projectTreeView->findModelIndex( previousActiveReservoirView );
QModelIndex currentSelectionIndex = m_projectTreeView->treeView()->selectionModel()->currentIndex();
if ( currentSelectionIndex != newViewModelIndex && currentSelectionIndex.isValid() )
while ( tmpModelIndex.isValid() && tmpModelIndex != previousViewModelIndex )
{
QVector<QModelIndex> route; // Contains all model indices from current selection up to previous view
// NB! Add model index to front of vector to be able to do a for-loop with correct ordering
route.push_front( tmpModelIndex );
QModelIndex tmpModelIndex = currentSelectionIndex;
tmpModelIndex = tmpModelIndex.parent();
}
while ( tmpModelIndex.isValid() && tmpModelIndex != previousViewModelIndex )
// Traverse model indices from new view index to currently selected item
int i;
for ( i = 0; i < route.size(); i++ )
{
QModelIndex tmp = route[i];
if ( newSelectionIndex.isValid() )
{
// NB! Add model index to front of vector to be able to do a for-loop with correct ordering
route.push_front( tmpModelIndex );
tmpModelIndex = tmpModelIndex.parent();
}
// Traverse model indices from new view index to currently selected item
int i;
for ( i = 0; i < route.size(); i++ )
{
QModelIndex tmp = route[i];
if ( newSelectionIndex.isValid() )
{
newSelectionIndex = m_projectTreeView->treeView()->model()->index( tmp.row(),
tmp.column(),
newSelectionIndex );
}
}
// Use view model index if anything goes wrong
if ( !newSelectionIndex.isValid() )
{
newSelectionIndex = newViewModelIndex;
newSelectionIndex = m_projectTreeView->treeView()->model()->index( tmp.row(),
tmp.column(),
newSelectionIndex );
}
}
}
m_projectTreeView->treeView()->setCurrentIndex( newSelectionIndex );
if ( newSelectionIndex != newViewModelIndex )
{
m_projectTreeView->treeView()->setExpanded( newViewModelIndex, true );
// Use view model index if anything goes wrong
if ( !newSelectionIndex.isValid() )
{
newSelectionIndex = newViewModelIndex;
}
}
}
slotRefreshViewActions();
refreshAnimationActions();
refreshDrawStyleActions();
m_projectTreeView->treeView()->setCurrentIndex( newSelectionIndex );
if ( newSelectionIndex != newViewModelIndex )
{
m_projectTreeView->treeView()->setExpanded( newViewModelIndex, true );
}
}
}
@ -1457,9 +1443,9 @@ void RiuMainWindow::selectedObjectsChanged()
// Set focus in MDI area to this window if it exists
if ( selectedReservoirView->viewer() )
{
setBlockSlotSubWindowActivated( true );
setBlockSubWindowProjectTreeSelection( true );
setActiveViewer( selectedReservoirView->viewer()->layoutWidget() );
setBlockSlotSubWindowActivated( false );
setBlockSubWindowProjectTreeSelection( false );
isActiveViewChanged = true;
}
@ -1976,7 +1962,7 @@ void RiuMainWindow::tileSubWindows()
}
// Perform stable sort of list so we first sort by window position but retain activation order
// for windows with the same position. Needs to be sorted in decreasing order for the workaround below.
// for windows with the same position.
windowList.sort( [this, viewLinker]( QMdiSubWindow* lhs, QMdiSubWindow* rhs ) {
RimViewWindow* lhsViewWindow = findViewWindowFromSubWindow( lhs );
RimViewWindow* rhsViewWindow = findViewWindowFromSubWindow( rhs );
@ -1994,28 +1980,36 @@ void RiuMainWindow::tileSubWindows()
return false;
}
}
return lhs->frameGeometry().topLeft().rx() > rhs->frameGeometry().topLeft().rx();
if ( lhs->frameGeometry().topLeft().ry() == rhs->frameGeometry().topLeft().ry() )
{
return lhs->frameGeometry().topLeft().rx() < rhs->frameGeometry().topLeft().rx();
}
return lhs->frameGeometry().topLeft().ry() < rhs->frameGeometry().topLeft().ry();
} );
// Based on workaround described here
// https://forum.qt.io/topic/50053/qmdiarea-tilesubwindows-always-places-widgets-in-activationhistoryorder-in-subwindowview-mode
bool prevActivationBlock = blockSlotSubWindowActivated();
// Force activation order so they end up in the order of the loop.
m_mdiArea->setActivationOrder( QMdiArea::ActivationHistoryOrder );
bool prevActivationBlock = blockSubWindowActivation();
QMdiSubWindow* a = m_mdiArea->activeSubWindow();
setBlockSlotSubWindowActivated( true );
for ( QMdiSubWindow* subWindow : windowList )
// Force activation order so they end up in the order of the loop.
m_mdiArea->setActivationOrder( QMdiArea::ActivationHistoryOrder );
setBlockSubWindowActivation( true );
// Activate in reverse order
for ( auto it = windowList.rbegin(); it != windowList.rend(); ++it )
{
m_mdiArea->setActiveSubWindow( subWindow );
m_mdiArea->setActiveSubWindow( *it );
}
m_mdiArea->tileSubWindows();
// Set back the original activation order to avoid messing with the standard ordering
m_mdiArea->setActivationOrder( currentActivationOrder );
m_mdiArea->setActiveSubWindow( a );
setBlockSlotSubWindowActivated( prevActivationBlock );
setBlockSubWindowActivation( prevActivationBlock );
storeSubWindowTiling( true );
}
@ -2034,6 +2028,7 @@ void RiuMainWindow::storeSubWindowTiling( bool tiled )
//--------------------------------------------------------------------------------------------------
void RiuMainWindow::clearWindowTiling()
{
setBlockSubWindowActivation( true );
QMdiArea::WindowOrder currentActivationOrder = m_mdiArea->activationOrder();
for ( QMdiSubWindow* subWindow : m_mdiArea->subWindowList( currentActivationOrder ) )
@ -2042,6 +2037,7 @@ void RiuMainWindow::clearWindowTiling()
subWindow->showNormal();
}
storeSubWindowTiling( false );
setBlockSubWindowActivation( false );
}
//--------------------------------------------------------------------------------------------------

4
ApplicationCode/UserInterface/RiuMainWindow.h
View File

@ -40,6 +40,7 @@ class QSpinBox;
class QTimer;
class QUndoView;
class Rim3dView;
class RimCase;
class RimViewWindow;
@ -230,9 +231,10 @@ private slots:
// Windows slots
void slotBuildWindowActions();
void slotSubWindowActivated( QMdiSubWindow* subWindow );
void selectViewInProjectTree( const Rim3dView* previousActiveReservoirView, Rim3dView* activatedView );
void selectedObjectsChanged();
void customMenuRequested( const QPoint& pos );

27
ApplicationCode/UserInterface/RiuMainWindowBase.cpp
View File

@ -42,7 +42,8 @@ RiuMainWindowBase::RiuMainWindowBase()
: m_projectTreeView( nullptr )
, m_allowActiveViewChangeFromSelection( true )
, m_showFirstVisibleWindowMaximized( true )
, m_blockSlotSubWindowActivated( false )
, m_blockSubWindowActivation( false )
, m_blockSubWindowProjectTreeSelection( false )
{
setDockNestingEnabled( true );
}
@ -216,17 +217,33 @@ void RiuMainWindowBase::enableShowFirstVisibleMdiWindowMaximized( bool enable )
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuMainWindowBase::setBlockSlotSubWindowActivated( bool block )
void RiuMainWindowBase::setBlockSubWindowActivation( bool block )
{
m_blockSlotSubWindowActivated = block;
m_blockSubWindowActivation = block;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RiuMainWindowBase::blockSlotSubWindowActivated() const
bool RiuMainWindowBase::blockSubWindowActivation() const
{
return m_blockSlotSubWindowActivated;
return m_blockSubWindowActivation;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuMainWindowBase::setBlockSubWindowProjectTreeSelection( bool block )
{
m_blockSubWindowProjectTreeSelection = block;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RiuMainWindowBase::blockSubWindowProjectTreeSelection() const
{
return m_blockSubWindowProjectTreeSelection;
}
//--------------------------------------------------------------------------------------------------

10
ApplicationCode/UserInterface/RiuMainWindowBase.h
View File

@ -75,8 +75,11 @@ public:
virtual void clearWindowTiling() = 0;
virtual bool subWindowsAreTiled() const = 0;
void setBlockSlotSubWindowActivated( bool block );
bool blockSlotSubWindowActivated() const;
void setBlockSubWindowActivation( bool block );
bool blockSubWindowActivation() const;
void setBlockSubWindowProjectTreeSelection( bool block );
bool blockSubWindowProjectTreeSelection() const;
protected:
void removeViewerFromMdiArea( QMdiArea* mdiArea, QWidget* viewer );
@ -94,5 +97,6 @@ private:
private:
bool m_showFirstVisibleWindowMaximized;
bool m_blockSlotSubWindowActivated;
bool m_blockSubWindowActivation;
bool m_blockSubWindowProjectTreeSelection;
};

4
ApplicationCode/UserInterface/RiuMdiArea.cpp
View File

@ -58,7 +58,7 @@ void RiuMdiArea::resizeEvent( QResizeEvent* resizeEvent )
}
RiuMainWindowBase* mainWindow = dynamic_cast<RiuMainWindowBase*>( window() );
mainWindow->setBlockSlotSubWindowActivated( true );
mainWindow->setBlockSubWindowActivation( true );
// Workaround for Qt bug #51761: https://bugreports.qt.io/browse/QTBUG-51761
// Set the first window to be the active window then perform resize event and set back.
@ -70,7 +70,7 @@ void RiuMdiArea::resizeEvent( QResizeEvent* resizeEvent )
setActiveSubWindow( a );
mainWindow->setBlockSlotSubWindowActivated( false );
mainWindow->setBlockSubWindowActivation( false );
for ( auto subWindow : subWindowList() )
{

55
ApplicationCode/UserInterface/RiuPlotMainWindow.cpp
View File

@ -446,7 +446,6 @@ void RiuPlotMainWindow::createDockPanels()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QMdiSubWindow* RiuPlotMainWindow::findMdiSubWindow( QWidget* viewer )
{
QList<QMdiSubWindow*> subws = m_mdiArea->subWindowList();
@ -462,6 +461,19 @@ QMdiSubWindow* RiuPlotMainWindow::findMdiSubWindow( QWidget* viewer )
return nullptr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimViewWindow* RiuPlotMainWindow::findViewWindowFromSubWindow( QMdiSubWindow* subWindow )
{
RimProject* proj = RiaApplication::instance()->project();
if ( subWindow && proj )
{
return RiuInterfaceToViewWindow::viewWindowFromWidget( subWindow->widget() );
}
return nullptr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -643,20 +655,16 @@ void RiuPlotMainWindow::setPdmRoot( caf::PdmObject* pdmRoot )
//--------------------------------------------------------------------------------------------------
void RiuPlotMainWindow::slotSubWindowActivated( QMdiSubWindow* subWindow )
{
if ( !subWindow ) return;
if ( blockSlotSubWindowActivated() ) return;
if ( blockSubWindowActivation() ) return;
RimProject* proj = RiaApplication::instance()->project();
if ( !proj ) return;
RimViewWindow* activatedView = findViewWindowFromSubWindow( subWindow );
// Select in Project Tree
if ( !activatedView ) return;
m_activePlotViewWindow = activatedView;
RimViewWindow* viewWindow = RiuInterfaceToViewWindow::viewWindowFromWidget( subWindow->widget() );
if ( viewWindow && viewWindow != m_activePlotViewWindow )
if ( !blockSubWindowProjectTreeSelection() )
{
selectAsCurrentItem( viewWindow );
m_activePlotViewWindow = viewWindow;
selectAsCurrentItem( activatedView );
}
updateWellLogPlotToolBar();
@ -752,9 +760,9 @@ void RiuPlotMainWindow::selectedObjectsChanged()
{
if ( selectedWindow->viewWidget() )
{
setBlockSlotSubWindowActivated( true );
setBlockSubWindowProjectTreeSelection( true );
setActiveViewer( selectedWindow->viewWidget() );
setBlockSlotSubWindowActivated( false );
setBlockSubWindowProjectTreeSelection( false );
}
m_activePlotViewWindow = selectedWindow;
@ -844,26 +852,35 @@ void RiuPlotMainWindow::tileSubWindows()
}
// Perform stable sort of list so we first sort by window position but retain activation order
// for windows with the same position. Needs to be sorted in decreasing order for workaround below.
// for windows with the same position.
windowList.sort( []( const QMdiSubWindow* lhs, const QMdiSubWindow* rhs ) {
return lhs->frameGeometry().topLeft().rx() > rhs->frameGeometry().topLeft().rx();
if ( lhs->frameGeometry().topLeft().ry() == rhs->frameGeometry().topLeft().ry() )
{
return lhs->frameGeometry().topLeft().rx() < rhs->frameGeometry().topLeft().rx();
}
return lhs->frameGeometry().topLeft().ry() < rhs->frameGeometry().topLeft().ry();
} );
// Based on workaround described here
// https://forum.qt.io/topic/50053/qmdiarea-tilesubwindows-always-places-widgets-in-activationhistoryorder-in-subwindowview-mode
QMdiSubWindow* a = m_mdiArea->activeSubWindow();
bool prevActivationBlock = blockSubWindowActivation();
// Force activation order so they end up in the order of the loop.
m_mdiArea->setActivationOrder( QMdiArea::ActivationHistoryOrder );
for ( QMdiSubWindow* subWindow : windowList )
QMdiSubWindow* a = m_mdiArea->activeSubWindow();
setBlockSubWindowActivation( true );
// Activate in reverse order
for ( auto it = windowList.rbegin(); it != windowList.rend(); ++it )
{
m_mdiArea->setActiveSubWindow( subWindow );
m_mdiArea->setActiveSubWindow( *it );
}
m_mdiArea->tileSubWindows();
// Set back the original activation order to avoid messing with the standard ordering
m_mdiArea->setActivationOrder( currentActivationOrder );
m_mdiArea->setActiveSubWindow( a );
setBlockSubWindowActivation( prevActivationBlock );
storeSubWindowTiling( true );
}
@ -882,6 +899,7 @@ void RiuPlotMainWindow::storeSubWindowTiling( bool tiled )
//--------------------------------------------------------------------------------------------------
void RiuPlotMainWindow::clearWindowTiling()
{
setBlockSubWindowActivation( true );
QMdiArea::WindowOrder currentActivationOrder = m_mdiArea->activationOrder();
for ( QMdiSubWindow* subWindow : m_mdiArea->subWindowList( currentActivationOrder ) )
@ -890,6 +908,7 @@ void RiuPlotMainWindow::clearWindowTiling()
subWindow->showNormal();
}
storeSubWindowTiling( false );
setBlockSubWindowActivation( false );
}
//--------------------------------------------------------------------------------------------------

1
ApplicationCode/UserInterface/RiuPlotMainWindow.h
View File

@ -73,6 +73,7 @@ public:
bool isAnyMdiSubWindowVisible();
QMdiSubWindow* findMdiSubWindow( QWidget* viewer ) override;
RimViewWindow* findViewWindowFromSubWindow( QMdiSubWindow* subWindow );
QList<QMdiSubWindow*> subWindowList( QMdiArea::WindowOrder order );
void setWidthOfMdiWindow( QWidget* mdiWindowWidget, int newWidth );

8
ApplicationCode/UserInterface/RiuWellLogPlot.cpp
View File

@ -315,6 +315,14 @@ void RiuWellLogPlot::keyPressEvent( QKeyEvent* keyEvent )
m_plotDefinition->handleKeyPressEvent( keyEvent );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuWellLogPlot::resizeEvent( QResizeEvent* event )
{
QWidget::resizeEvent( event );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

1
ApplicationCode/UserInterface/RiuWellLogPlot.h
View File

@ -75,6 +75,7 @@ protected:
void changeEvent( QEvent* event ) override;
void contextMenuEvent( QContextMenuEvent* ) override;
void keyPressEvent( QKeyEvent* keyEvent ) override;
void resizeEvent( QResizeEvent* event ) override;
QSize sizeHint() const override;