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 branch 'dev' into annotation-items

Browse Source
This commit is contained in:
Magne Sjaastad 2019-03-18 09:08:56 +01:00
commit 7f0532999a
17 changed files with 325 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
ApplicationCode/Application/RiaDefines.cpp
View File

@ -464,6 +464,14 @@ double RiaDefines::minimumDefaultValuePlot()
return -10.0;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RiaDefines::minimumDefaultLogValuePlot()
{
return 1.0;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

1
ApplicationCode/Application/RiaDefines.h
View File

@ -135,6 +135,7 @@ namespace RiaDefines
};
double minimumDefaultValuePlot();
double minimumDefaultLogValuePlot();
double maximumDefaultValuePlot();
enum PhaseType {

10
ApplicationCode/Commands/ApplicationCommands/RicExitApplicationFeature.cpp
View File

@ -19,8 +19,10 @@
#include "RicExitApplicationFeature.h"
#include "RiaApplication.h"
#include "RiuMainWindow.h"
#include <QAction>
#include <QDebug>
CAF_CMD_SOURCE_INIT(RicExitApplicationFeature, "RicExitApplicationFeature");
@ -42,7 +44,13 @@ void RicExitApplicationFeature::onActionTriggered(bool isChecked)
RiaApplication* app = RiaApplication::instance();
if (!app->askUserToSaveModifiedProject()) return;
app->closeAllWindows();
// Hide all windows first to make sure they get closed properly
for (QWidget* topLevelWidget : app->topLevelWidgets())
{
topLevelWidget->hide();
}
// Close just the main window, it'll take care of closing the plot window
app->mainWindow()->close();
}
//--------------------------------------------------------------------------------------------------

2
ApplicationCode/Commands/GridCrossPlotCommands/RicSwapGridCrossPlotCurveSetAxesFeature.cpp
View File

@ -40,7 +40,7 @@ void RicSwapGridCrossPlotCurveSetAxesFeature::onActionTriggered(bool isChecked)
else if (caf::SelectionManager::instance()->selectedItemOfType<RimGridCrossPlot>())
{
auto plot = caf::SelectionManager::instance()->selectedItemOfType<RimGridCrossPlot>();
plot->swapAllAxisProperties();
plot->swapAxes();
}
}

104
ApplicationCode/ProjectDataModel/GridCrossPlots/RimGridCrossPlot.cpp
View File

@ -269,7 +269,7 @@ void RimGridCrossPlot::detachAllCurves()
//--------------------------------------------------------------------------------------------------
void RimGridCrossPlot::updateAxisScaling()
{
updateAxisDisplay();
loadDataAndUpdate();
}
//--------------------------------------------------------------------------------------------------
@ -383,13 +383,11 @@ void RimGridCrossPlot::onLoadDataAndUpdate()
for (auto curveSet : m_crossPlotCurveSets)
{
curveSet->loadDataAndUpdate(false);
curveSet->updateConnectedEditors();
}
updateCurveNamesAndPlotTitle();
updateAllRequiredEditors();
updatePlot();
updatePlot();
}
//--------------------------------------------------------------------------------------------------
@ -525,13 +523,29 @@ void RimGridCrossPlot::updateCurveNamesAndPlotTitle()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimGridCrossPlot::swapAllAxisProperties()
void RimGridCrossPlot::swapAxes()
{
RimPlotAxisProperties* xAxisProperties = m_xAxisProperties();
RimPlotAxisProperties* yAxisProperties = m_yAxisProperties();
QString tmpName = xAxisProperties->name();
QwtPlot::Axis tmpAxis = xAxisProperties->qwtPlotAxisType();
xAxisProperties->setNameAndAxis(yAxisProperties->name(), yAxisProperties->qwtPlotAxisType());
yAxisProperties->setNameAndAxis(tmpName, tmpAxis);
m_xAxisProperties.removeChildObject(xAxisProperties);
m_yAxisProperties.removeChildObject(yAxisProperties);
m_yAxisProperties = xAxisProperties;
m_xAxisProperties = yAxisProperties;
for (auto curveSet : m_crossPlotCurveSets)
{
curveSet->swapAxisProperties(false);
}
loadDataAndUpdate();
updateAxisDisplay();
}
//--------------------------------------------------------------------------------------------------
@ -562,7 +576,6 @@ QString RimGridCrossPlot::asciiDataForPlotExport(int curveSetIndex) const
formatter.setTableRowLineAppendText("");
formatter.setColumnSpacing(3);
m_crossPlotCurveSets[curveSetIndex]->exportFormattedData(formatter);
formatter.tableCompleted();
return asciiData;
@ -581,6 +594,22 @@ RiuGridCrossQwtPlot* RimGridCrossPlot::qwtPlot() const
return m_qwtPlot;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimGridCrossPlot::isXAxisLogarithmic() const
{
return m_xAxisProperties->isLogarithmicScaleEnabled();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimGridCrossPlot::isYAxisLogarithmic() const
{
return m_yAxisProperties->isLogarithmicScaleEnabled();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -676,6 +705,25 @@ void RimGridCrossPlot::updateAxisInQwt(RiaDefines::PlotAxis axisType)
m_qwtPlot->setAxisScaleEngine(axisProperties->qwtPlotAxisType(), new QwtLogScaleEngine);
m_qwtPlot->setAxisMaxMinor(axisProperties->qwtPlotAxisType(), 5);
}
if (axisProperties->isAutoZoom())
{
std::vector<const QwtPlotCurve*> plotCurves = visibleQwtCurves();
double min, max;
RimPlotAxisLogRangeCalculator logRangeCalculator(qwtAxisId, plotCurves);
logRangeCalculator.computeAxisRange(&min, &max);
if (axisProperties->isAxisInverted())
{
std::swap(min, max);
}
m_qwtPlot->setAxisScale(qwtAxisId, min, max);
}
else
{
m_qwtPlot->setAxisScale(qwtAxisId, axisProperties->visibleRangeMin, axisProperties->visibleRangeMax);
}
}
else
{
@ -686,19 +734,17 @@ void RimGridCrossPlot::updateAxisInQwt(RiaDefines::PlotAxis axisType)
m_qwtPlot->setAxisScaleEngine(axisProperties->qwtPlotAxisType(), new QwtLinearScaleEngine);
m_qwtPlot->setAxisMaxMinor(axisProperties->qwtPlotAxisType(), 3);
}
if (axisProperties->isAutoZoom())
{
m_qwtPlot->setAxisAutoScale(qwtAxisId);
}
else
{
m_qwtPlot->setAxisScale(qwtAxisId, axisProperties->visibleRangeMin, axisProperties->visibleRangeMax);
}
}
m_qwtPlot->axisScaleEngine(axisProperties->qwtPlotAxisType())->setAttribute(QwtScaleEngine::Inverted, axisProperties->isAxisInverted());
if (axisProperties->isAutoZoom())
{
m_qwtPlot->setAxisAutoScale(qwtAxisId);
}
else
{
m_qwtPlot->setAxisScale(qwtAxisId, axisProperties->visibleRangeMin, axisProperties->visibleRangeMax);
}
}
else
{
@ -731,6 +777,28 @@ void RimGridCrossPlot::updateAxisFromQwt(RiaDefines::PlotAxis axisType)
axisProperties->updateConnectedEditors();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<const QwtPlotCurve*> RimGridCrossPlot::visibleQwtCurves() const
{
std::vector<const QwtPlotCurve*> plotCurves;
for (auto curveSet : m_crossPlotCurveSets)
{
if (curveSet->isChecked())
{
for (auto curve : curveSet->curves())
{
if (curve->isCurveVisible())
{
plotCurves.push_back(curve->qwtPlotCurve());
}
}
}
}
return plotCurves;
}
//--------------------------------------------------------------------------------------------------
/// Name Configuration
///

8
ApplicationCode/ProjectDataModel/GridCrossPlots/RimGridCrossPlot.h
View File

@ -70,10 +70,12 @@ public:
void detachAllCurves();
void performAutoNameUpdate() override;
void updateCurveNamesAndPlotTitle();
void swapAllAxisProperties();
void swapAxes();
QString asciiTitleForPlotExport(int curveSetIndex) const;
QString asciiDataForPlotExport(int curveSetIndex) const;
RiuGridCrossQwtPlot* qwtPlot() const;
bool isXAxisLogarithmic() const;
bool isYAxisLogarithmic() const;
public:
// Rim2dPlotInterface overrides
@ -96,13 +98,13 @@ protected:
bool* useOptionsOnly) override;
void updatePlot();
void updateCurveNames();
QString xAxisParameterString() const;
QString yAxisParameterString() const;
void updateAxisInQwt(RiaDefines::PlotAxis axisType);
void updateAxisFromQwt(RiaDefines::PlotAxis axisType);
std::vector<const QwtPlotCurve*> visibleQwtCurves() const;
private:
caf::PdmField<bool> m_showLegend;
@ -115,7 +117,7 @@ private:
caf::PdmChildArrayField<RimGridCrossPlotCurveSet*> m_crossPlotCurveSets;
QPointer<RiuGridCrossQwtPlot> m_qwtPlot;
};

60
ApplicationCode/ProjectDataModel/GridCrossPlots/RimGridCrossPlotCurveSet.cpp
View File

@ -406,6 +406,10 @@ void RimGridCrossPlotCurveSet::onLoadDataAndUpdate(bool updateParentPlot)
RigEclipseCrossPlotResult result = RigEclipseCrossPlotDataExtractor::extract(
eclipseCase->eclipseCaseData(), m_timeStep(), xAddress, yAddress, m_grouping(), groupAddress, timeStepCellVisibilityMap);
if (isXAxisLogarithmic() || isYAxisLogarithmic())
{
filterInvalidCurveValues(&result);
}
createCurves(result);
if (updateParentPlot)
@ -877,6 +881,26 @@ void RimGridCrossPlotCurveSet::exportFormattedData(RifEclipseDataTableFormatter&
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimGridCrossPlotCurveSet::isXAxisLogarithmic() const
{
RimGridCrossPlot* parent = nullptr;
firstAncestorOrThisOfTypeAsserted(parent);
return parent->isXAxisLogarithmic();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimGridCrossPlotCurveSet::isYAxisLogarithmic() const
{
RimGridCrossPlot* parent = nullptr;
firstAncestorOrThisOfTypeAsserted(parent);
return parent->isYAxisLogarithmic();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -1001,6 +1025,42 @@ bool RimGridCrossPlotCurveSet::hasMultipleTimeSteps() const
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimGridCrossPlotCurveSet::filterInvalidCurveValues(RigEclipseCrossPlotResult* result)
{
bool xLog = isXAxisLogarithmic();
bool yLog = isYAxisLogarithmic();
if (xLog || yLog)
{
RigEclipseCrossPlotResult validResult;
for (size_t i = 0; i < result->xValues.size(); ++i)
{
double xValue = result->xValues[i];
double yValue = result->yValues[i];
bool invalid = (xLog && xValue <= 0.0) || (yLog && yValue <= 0.0);
if (!invalid)
{
validResult.xValues.push_back(xValue);
validResult.yValues.push_back(yValue);
if (i < result->groupValuesContinuous.size())
{
validResult.groupValuesContinuous.push_back(result->groupValuesContinuous[i]);
}
if (i < result->groupValuesDiscrete.size())
{
validResult.groupValuesDiscrete.push_back(result->groupValuesDiscrete[i]);
}
}
}
*result = validResult;
}
}
CAF_PDM_SOURCE_INIT(RimGridCrossPlotCurveSetNameConfig, "RimGridCrossPlotCurveSetNameConfig");
//--------------------------------------------------------------------------------------------------

5
ApplicationCode/ProjectDataModel/GridCrossPlots/RimGridCrossPlotCurveSet.h
View File

@ -117,6 +117,9 @@ public:
void swapAxisProperties(bool updatePlot);
void exportFormattedData(RifEclipseDataTableFormatter& formatter) const;
bool isXAxisLogarithmic() const;
bool isYAxisLogarithmic() const;
protected:
void initAfterRead() override;
void onLoadDataAndUpdate(bool updateParentPlot);
@ -139,6 +142,7 @@ protected:
void defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName = "") override;
bool hasMultipleTimeSteps() const;
void filterInvalidCurveValues(RigEclipseCrossPlotResult* result);
private:
caf::PdmPtrField<RimCase*> m_case;
@ -154,4 +158,5 @@ private:
caf::PdmChildArrayField<RimGridCrossPlotCurve*> m_crossPlotCurves;
std::map<int, RigEclipseCrossPlotResult> m_groupedResults;
};

3
ApplicationCode/ProjectDataModel/RimEclipseCellColors.cpp
View File

@ -239,12 +239,11 @@ void RimEclipseCellColors::uiTreeOrdering(caf::PdmUiTreeOrdering& uiTreeOrdering
//--------------------------------------------------------------------------------------------------
void RimEclipseCellColors::setReservoirView(RimEclipseView* ownerReservoirView)
{
m_reservoirView = ownerReservoirView;
if (ownerReservoirView)
{
this->setEclipseCase(ownerReservoirView->eclipseCase());
}
m_reservoirView = ownerReservoirView;
}
//--------------------------------------------------------------------------------------------------

102
ApplicationCode/ProjectDataModel/RimPlotAxisProperties.cpp
View File

@ -20,14 +20,19 @@
#include "RimPlotAxisProperties.h"
#include "RiaDefines.h"
#include "RigStatisticsCalculator.h"
#include "RimRiuQwtPlotOwnerInterface.h"
#include "RimPlotAxisAnnotation.h"
#include "cafPdmUiSliderEditor.h"
#include "cvfVector2.h"
#include <cmath>
#include <qwt_plot_curve.h>
// clang-format off
namespace caf
{
@ -229,6 +234,14 @@ QwtPlot::Axis RimPlotAxisProperties::qwtPlotAxisType() const
return m_axis;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RimPlotAxisProperties::name() const
{
return m_name;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -373,3 +386,92 @@ caf::PdmFieldHandle* RimPlotAxisProperties::objectToggleField()
{
return &m_isActive;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimPlotAxisLogRangeCalculator::RimPlotAxisLogRangeCalculator(QwtPlot::Axis axis,
const std::vector<const QwtPlotCurve*>& qwtCurves)
: m_axis(axis)
, m_curves(qwtCurves)
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPlotAxisLogRangeCalculator::computeAxisRange(double* minPositive, double* max) const
{
double minPosValue = HUGE_VAL;
double maxValue = -HUGE_VAL;
for (const QwtPlotCurve* curve : m_curves)
{
double minPosCurveValue = HUGE_VAL;
double maxCurveValue = -HUGE_VAL;
if (curveValueRange(curve, &minPosCurveValue, &maxCurveValue))
{
if (minPosCurveValue < minPosValue)
{
CVF_ASSERT(minPosCurveValue > 0.0);
minPosValue = minPosCurveValue;
}
if (maxCurveValue > maxValue)
{
maxValue = maxCurveValue;
}
}
}
if (minPosValue == HUGE_VAL)
{
minPosValue = RiaDefines::minimumDefaultLogValuePlot();
maxValue = RiaDefines::maximumDefaultValuePlot();
}
*minPositive = minPosValue;
*max = maxValue;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimPlotAxisLogRangeCalculator::curveValueRange(const QwtPlotCurve* qwtCurve, double* minPositive, double* max) const
{
if (!qwtCurve) return false;
if (qwtCurve->data()->size() < 1)
{
return false;
}
float minPosF = std::numeric_limits<float>::infinity();
float maxF = -std::numeric_limits<float>::infinity();
int axisValueIndex = 0;
if (m_axis == QwtPlot::yLeft || m_axis == QwtPlot::yRight)
{
axisValueIndex = 1;
}
for (size_t i = 0; i < qwtCurve->dataSize(); ++i)
{
QPointF sample = qwtCurve->sample((int) i);
cvf::Vec2f vec(sample.x(), sample.y());
float value = vec[axisValueIndex];
if (value == HUGE_VALF) continue;
maxF = std::max(maxF, value);
if (value > 0.0f && value < minPosF)
{
minPosF = value;
}
}
*minPositive = minPosF;
*max = maxF;
return true;
}

24
ApplicationCode/ProjectDataModel/RimPlotAxisProperties.h
View File

@ -59,7 +59,9 @@ public:
void setEnableTitleTextSettings(bool enable);
void setNameAndAxis(const QString& name, QwtPlot::Axis axis);
QwtPlot::Axis qwtPlotAxisType() const;
QString name() const;
RiaDefines::PlotAxis plotAxisType() const;
bool useAutoTitle() const;
bool showDescription() const;
@ -117,3 +119,25 @@ private:
caf::PdmChildArrayField<RimPlotAxisAnnotation*> m_annotations;
};
class QwtPlotCurve;
//==================================================================================================
///
///
//==================================================================================================
class RimPlotAxisLogRangeCalculator
{
public:
RimPlotAxisLogRangeCalculator(QwtPlot::Axis axis,
const std::vector<const QwtPlotCurve*>& qwtCurves);
void computeAxisRange(double* minPositive, double* max) const;
private:
bool curveValueRange(const QwtPlotCurve* qwtCurve, double* minPositive, double* max) const;
private:
QwtPlot::Axis m_axis;
const std::vector<const QwtPlotCurve*> m_curves;
};

85
ApplicationCode/ProjectDataModel/Summary/RimSummaryCurvesCalculator.cpp
View File

@ -18,8 +18,6 @@
#include "RimSummaryCurvesCalculator.h"
#include "RigStatisticsCalculator.h"
#include "RiaDefines.h"
#include "RimSummaryCurve.h"
#include "RimPlotAxisProperties.h"
@ -319,86 +317,3 @@ std::string RimSummaryPlotYAxisFormatter::shortCalculationName(const std::string
return calculationShortName.toStdString();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimSummaryPlotYAxisRangeCalculator::RimSummaryPlotYAxisRangeCalculator(
const std::vector<QwtPlotCurve*>& qwtCurves,
const std::vector<double>& yValuesForAllCurves)
:
m_singleCurves(qwtCurves),
m_yValuesForAllCurves(yValuesForAllCurves)
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryPlotYAxisRangeCalculator::computeYRange(double* min, double* max) const
{
double minValue = HUGE_VAL;
double maxValue = -HUGE_VAL;
for (QwtPlotCurve* curve : m_singleCurves)
{
double minCurveValue = HUGE_VAL;
double maxCurveValue = -HUGE_VAL;
if (curveValueRangeY(curve, &minCurveValue, &maxCurveValue))
{
if (minCurveValue < minValue)
{
minValue = minCurveValue;
}
if (maxCurveValue > maxValue)
{
maxValue = maxCurveValue;
}
}
}
if (minValue == HUGE_VAL)
{
minValue = RiaDefines::minimumDefaultValuePlot();
maxValue = RiaDefines::maximumDefaultValuePlot();
}
// For logarithmic auto scaling, compute positive curve value closest to zero and use
// this value as the plot visible minimum
double pos = HUGE_VAL;
double neg = -HUGE_VAL;
RigStatisticsCalculator::posNegClosestToZero(m_yValuesForAllCurves, pos, neg);
if (pos != HUGE_VAL)
{
minValue = pos;
}
*min = minValue;
*max = maxValue;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimSummaryPlotYAxisRangeCalculator::curveValueRangeY(const QwtPlotCurve* qwtCurve, double* min, double* max) const
{
if (!qwtCurve) return false;
if (qwtCurve->data()->size() < 1)
{
return false;
}
*min = qwtCurve->minYValue();
*max = qwtCurve->maxYValue();
return true;
}

21
ApplicationCode/ProjectDataModel/Summary/RimSummaryCurvesCalculator.h
View File

@ -22,6 +22,8 @@
#include <vector>
#include <set>
#include <qwt_plot.h>
class RimAsciiDataCurve;
class RimSummaryCurve;
class RimPlotAxisProperties;
@ -46,26 +48,9 @@ private:
static std::string shortCalculationName(const std::string& calculationName);
private:
RimPlotAxisProperties* m_axisProperties;
RimPlotAxisProperties* m_axisProperties;
const std::vector<RimSummaryCurve*> m_summaryCurves;
const std::vector<RimAsciiDataCurve*> m_asciiDataCurves;
const std::set<QString> m_timeHistoryCurveQuantities;
};
class RimSummaryPlotYAxisRangeCalculator
{
public:
RimSummaryPlotYAxisRangeCalculator( const std::vector<QwtPlotCurve*>& qwtCurves,
const std::vector<double>& yValuesForAllCurves);
void computeYRange(double* min, double* max) const;
private:
bool curveValueRangeY(const QwtPlotCurve* qwtCurve, double* min, double* max) const;
private:
const std::vector<QwtPlotCurve*> m_singleCurves;
const std::vector<double> m_yValuesForAllCurves;
};

21
ApplicationCode/ProjectDataModel/Summary/RimSummaryPlot.cpp
View File

@ -54,6 +54,7 @@
#include "qwt_plot_curve.h"
#include "qwt_plot_renderer.h"
#include "qwt_plot_textlabel.h"
#include "qwt_scale_engine.h"
#include <QDateTime>
#include <QString>
@ -634,33 +635,31 @@ void RimSummaryPlot::updateZoomForAxis(RiaDefines::PlotAxis plotAxis)
{
if (yAxisProps->isLogarithmicScaleEnabled)
{
std::vector<double> yValues;
std::vector<QwtPlotCurve*> plotCurves;
std::vector<const QwtPlotCurve*> plotCurves;
for (RimSummaryCurve* c : visibleSummaryCurvesForAxis(plotAxis))
{
std::vector<double> curveValues = c->valuesY();
yValues.insert(yValues.end(), curveValues.begin(), curveValues.end());
plotCurves.push_back(c->qwtPlotCurve());
}
for (RimGridTimeHistoryCurve* c : visibleTimeHistoryCurvesForAxis(plotAxis))
{
std::vector<double> curveValues = c->yValues();
yValues.insert(yValues.end(), curveValues.begin(), curveValues.end());
plotCurves.push_back(c->qwtPlotCurve());
}
for (RimAsciiDataCurve* c : visibleAsciiDataCurvesForAxis(plotAxis))
{
std::vector<double> curveValues = c->yValues();
yValues.insert(yValues.end(), curveValues.begin(), curveValues.end());
plotCurves.push_back(c->qwtPlotCurve());
}
double min, max;
RimSummaryPlotYAxisRangeCalculator calc(plotCurves, yValues);
calc.computeYRange(&min, &max);
RimPlotAxisLogRangeCalculator calc(QwtPlot::yLeft, plotCurves);
calc.computeAxisRange(&min, &max);
if (yAxisProps->isAxisInverted())
{
std::swap(min, max);
}
m_qwtPlot->setAxisScale(yAxisProps->qwtPlotAxisType(), min, max);
}
@ -673,6 +672,8 @@ void RimSummaryPlot::updateZoomForAxis(RiaDefines::PlotAxis plotAxis)
{
m_qwtPlot->setAxisScale(yAxisProps->qwtPlotAxisType(), yAxisProps->visibleRangeMin(), yAxisProps->visibleRangeMax());
}
m_qwtPlot->axisScaleEngine(yAxisProps->qwtPlotAxisType())->setAttribute(QwtScaleEngine::Inverted, yAxisProps->isAxisInverted());
}
}

4
Fwk/AppFwk/cafUserInterface/cafPdmUiTableViewDelegate.cpp
View File

@ -117,7 +117,11 @@ bool PdmUiTableViewDelegate::isEditorOpen() const
//--------------------------------------------------------------------------------------------------
void PdmUiTableViewDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
{
#if QT_VERSION_MAJOR > 4
QStyleOptionViewItem viewItemOption(option);
#else
QStyleOptionViewItemV4 viewItemOption(option);
#endif
QVariant fgText = index.data(Qt::ForegroundRole);

4
Fwk/AppFwk/cafUserInterface/cafPdmUiTreeSelectionEditor.cpp
View File

@ -164,7 +164,11 @@ private:
QRect r = rect();
QPalette pal = palette();
#if QT_VERSION_MAJOR > 4
QStyleOptionFrame panel;
#else
QStyleOptionFrameV2 panel;
#endif
initStyleOption(&panel);
style()->drawPrimitive(QStyle::PE_PanelLineEdit, &panel, &p, this);
r = style()->subElementRect(QStyle::SE_LineEditContents, &panel, this);

2
ResInsightVersion.cmake
View File

@ -10,7 +10,7 @@ set(RESINSIGHT_VERSION_TEXT "-dev")
# Must be unique and increasing within one combination of major/minor/patch version
# The uniqueness of this text is independent of RESINSIGHT_VERSION_TEXT
# Format of text must be ".xx"
set(RESINSIGHT_DEV_VERSION ".03")
set(RESINSIGHT_DEV_VERSION ".04")
# https://github.com/CRAVA/crava/tree/master/libs/nrlib
set(NRLIB_GITHUB_SHA "ba35d4359882f1c6f5e9dc30eb95fe52af50fd6f")