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

Multiaxis: add support for Qwt multiaxis plot

Browse Source
This commit is contained in:
Magne Sjaastad 2022-03-24 12:53:06 +01:00 committed by Kristian Bendiksen
parent 22d6e3f853
commit dde0487024
31 changed files with 281 additions and 257 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
ApplicationLibCode/Commands/RicGridStatisticsDialog.cpp
View File

@ -195,16 +195,16 @@ void RicGridStatisticsDialog::setHistogramData( RimGridView* view )
// Axis
double xAxisSize = histogramData.max - histogramData.min;
double xAxisExtension = xAxisSize * 0.02;
m_historgramPlot->setAxisScale( QwtPlot::xBottom,
m_historgramPlot->setAxisScale( QwtAxis::XBottom,
histogramData.min - xAxisExtension,
histogramData.max + xAxisExtension );
m_aggregatedPlot->setAxisScale( QwtPlot::xBottom,
m_aggregatedPlot->setAxisScale( QwtAxis::XBottom,
histogramData.min - xAxisExtension,
histogramData.max + xAxisExtension );
// Set y axis label area width
m_historgramPlot->axisScaleDraw( QwtPlot::yLeft )->setMinimumExtent( 60 );
m_aggregatedPlot->axisScaleDraw( QwtPlot::yLeft )->setMinimumExtent( 60 );
m_historgramPlot->axisScaleDraw( QwtAxis::YLeft )->setMinimumExtent( 60 );
m_aggregatedPlot->axisScaleDraw( QwtAxis::YLeft )->setMinimumExtent( 60 );
// Samples
hist->setSamples( histSamples );

6
ApplicationLibCode/ProjectDataModel/AnalysisPlots/RimAnalysisPlot.cpp
View File

@ -164,7 +164,7 @@ RimAnalysisPlot::RimAnalysisPlot()
CAF_PDM_InitFieldNoDefault( &m_valueAxisProperties, "ValueAxisProperties", "ValueAxisProperties" );
m_valueAxisProperties.uiCapability()->setUiTreeHidden( true );
m_valueAxisProperties = new RimPlotAxisProperties;
m_valueAxisProperties->setNameAndAxis( "Value-Axis", RiuQwtPlotTools::fromQwtPlotAxis( QwtPlot::yLeft ) );
m_valueAxisProperties->setNameAndAxis( "Value-Axis", RiuQwtPlotTools::fromQwtPlotAxis( QwtAxis::YLeft ) );
m_valueAxisProperties->enableRangeSettings( false );
CAF_PDM_InitFieldNoDefault( &m_plotDataFilterCollection, "PlotDataFilterCollection", "PlotDataFilterCollection" );
@ -910,7 +910,7 @@ void RimAnalysisPlot::onAxisSelected( int axis, bool toggle )
RiuPlotMainWindowTools::showPlotMainWindow();
caf::PdmObject* itemToSelect = nullptr;
if ( axis == QwtPlot::yLeft )
if ( axis == QwtAxis::YLeft )
{
if ( m_barOrientation == BARS_VERTICAL )
{
@ -921,7 +921,7 @@ void RimAnalysisPlot::onAxisSelected( int axis, bool toggle )
itemToSelect = this;
}
}
else if ( axis == QwtPlot::xBottom )
else if ( axis == QwtAxis::XBottom )
{
if ( m_barOrientation == BARS_HORIZONTAL )
{

10
ApplicationLibCode/ProjectDataModel/CorrelationPlots/RimCorrelationMatrixPlot.cpp
View File

@ -400,8 +400,8 @@ void RimCorrelationMatrixPlot::updateAxes()
{
if ( !m_plotWidget ) return;
m_plotWidget->qwtPlot()->setAxisScaleDraw( QwtPlot::yLeft, new TextScaleDraw( m_resultLabels ) );
m_plotWidget->qwtPlot()->setAxisScaleEngine( QwtPlot::yLeft, new RiuQwtLinearScaleEngine );
m_plotWidget->qwtPlot()->setAxisScaleDraw( QwtAxis::YLeft, new TextScaleDraw( m_resultLabels ) );
m_plotWidget->qwtPlot()->setAxisScaleEngine( QwtAxis::YLeft, new RiuQwtLinearScaleEngine );
m_plotWidget->setAxisTitleText( RiuPlotAxis::defaultLeft(), "Result Vector" );
m_plotWidget->setAxisTitleEnabled( RiuPlotAxis::defaultLeft(), true );
m_plotWidget->setAxisFontsAndAlignment( RiuPlotAxis::defaultLeft(),
@ -421,8 +421,8 @@ void RimCorrelationMatrixPlot::updateAxes()
auto scaleDraw = new TextScaleDraw( m_paramLabels );
scaleDraw->setLabelRotation( 30.0 );
m_plotWidget->qwtPlot()->setAxisScaleDraw( QwtPlot::xBottom, scaleDraw );
m_plotWidget->qwtPlot()->setAxisScaleEngine( QwtPlot::xBottom, new RiuQwtLinearScaleEngine );
m_plotWidget->qwtPlot()->setAxisScaleDraw( QwtAxis::XBottom, scaleDraw );
m_plotWidget->qwtPlot()->setAxisScaleEngine( QwtAxis::XBottom, new RiuQwtLinearScaleEngine );
m_plotWidget->setAxisTitleText( RiuPlotAxis::defaultBottom(), "Ensemble Parameter" );
m_plotWidget->setAxisTitleEnabled( RiuPlotAxis::defaultBottom(), true );
m_plotWidget->setAxisFontsAndAlignment( RiuPlotAxis::defaultBottom(),
@ -440,7 +440,7 @@ void RimCorrelationMatrixPlot::updateAxes()
0.0,
(double)m_paramLabels.size() );
m_plotWidget->qwtPlot()->setAxisLabelAlignment( QwtPlot::xBottom, Qt::AlignRight );
m_plotWidget->qwtPlot()->setAxisLabelAlignment( QwtAxis::XBottom, Qt::AlignRight );
}
template <typename KeyType, typename ValueType>

4
ApplicationLibCode/ProjectDataModel/GridCrossPlots/RimGridCrossPlot.cpp
View File

@ -376,11 +376,11 @@ void RimGridCrossPlot::onAxisSelected( int axis, bool toggle )
{
RiuPlotMainWindowTools::showPlotMainWindow();
RimPlotAxisProperties* properties = nullptr;
if ( axis == QwtPlot::yLeft )
if ( axis == QwtAxis::YLeft )
{
properties = m_yAxisProperties;
}
else if ( axis == QwtPlot::xBottom )
else if ( axis == QwtAxis::XBottom )
{
properties = m_xAxisProperties;
}

6
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryPlot.cpp
View File

@ -382,15 +382,15 @@ void RimSummaryPlot::onAxisSelected( int axis, bool toggle )
RiuPlotMainWindowTools::showPlotMainWindow();
caf::PdmObject* itemToSelect = nullptr;
if ( axis == QwtPlot::yLeft )
if ( axis == QwtAxis::YLeft )
{
itemToSelect = m_leftYAxisProperties_OBSOLETE;
}
else if ( axis == QwtPlot::yRight )
else if ( axis == QwtAxis::YRight )
{
itemToSelect = m_rightYAxisProperties_OBSOLETE;
}
else if ( axis == QwtPlot::xBottom )
else if ( axis == QwtAxis::XBottom )
{
if ( m_isCrossPlot )
{

2
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryPlotAxisFormatter.cpp
View File

@ -143,7 +143,7 @@ void RimSummaryPlotAxisFormatter::applyAxisPropertiesToPlot( RiuPlotWidget* plot
auto qwtPlotWidget = dynamic_cast<RiuQwtPlotWidget*>( plotWidget );
if ( qwtPlotWidget )
{
QwtPlot::Axis qwtAxisId = RiuQwtPlotTools::toQwtPlotAxis( axis.axis() );
auto qwtAxisId = RiuQwtPlotTools::toQwtPlotAxis( axis );
if ( m_axisProperties->numberFormat == RimPlotAxisProperties::NUMBER_FORMAT_AUTO &&
m_axisProperties->scaleFactor() == 1.0 )

32
ApplicationLibCode/ProjectDataModel/WellLog/RimWellLogTrack.cpp
View File

@ -823,11 +823,11 @@ void RimWellLogTrack::updatePropertyValueAxisAndGridTickIntervals()
this->firstAncestorOrThisOfTypeAsserted( wellLogPlot );
if ( wellLogPlot->depthOrientation() == RimDepthTrackPlot::DepthOrientation::VERTICAL )
{
m_plotWidget->qwtPlot()->setAxisScaleDiv( QwtPlot::xTop, div );
m_plotWidget->qwtPlot()->setAxisScaleDiv( QwtAxis::XTop, div );
}
else
{
m_plotWidget->qwtPlot()->setAxisScaleDiv( QwtPlot::yLeft, div );
m_plotWidget->qwtPlot()->setAxisScaleDiv( QwtAxis::YLeft, div );
}
}
else if ( m_explicitTickIntervals )
@ -1256,13 +1256,13 @@ void RimWellLogTrack::onLoadDataAndUpdate()
if ( wellLogPlot->depthOrientation() == RimDepthTrackPlot::DepthOrientation::VERTICAL )
{
m_plotWidget->setAxisEnabled( QwtPlot::xTop, true );
m_plotWidget->setAxisEnabled( QwtPlot::xBottom, false );
m_plotWidget->setAxisEnabled( QwtAxis::XTop, true );
m_plotWidget->setAxisEnabled( QwtAxis::XBottom, false );
}
else
{
m_plotWidget->setAxisEnabled( QwtPlot::xTop, false );
m_plotWidget->setAxisEnabled( QwtPlot::xBottom, true );
m_plotWidget->setAxisEnabled( QwtAxis::XTop, false );
m_plotWidget->setAxisEnabled( QwtAxis::XBottom, true );
}
}
@ -2034,17 +2034,17 @@ void RimWellLogTrack::updateAxisScaleEngine()
if ( m_isLogarithmicScaleEnabled )
{
m_plotWidget->qwtPlot()->setAxisScaleEngine( QwtPlot::xTop, new QwtLogScaleEngine );
m_plotWidget->qwtPlot()->setAxisScaleEngine( QwtAxis::XTop, new QwtLogScaleEngine );
// NB! Must assign scale engine to bottom in order to make QwtPlotGrid work
m_plotWidget->qwtPlot()->setAxisScaleEngine( QwtPlot::xBottom, new QwtLogScaleEngine );
m_plotWidget->qwtPlot()->setAxisScaleEngine( QwtAxis::XBottom, new QwtLogScaleEngine );
}
else
{
m_plotWidget->qwtPlot()->setAxisScaleEngine( QwtPlot::xTop, new RiuQwtLinearScaleEngine );
m_plotWidget->qwtPlot()->setAxisScaleEngine( QwtAxis::XTop, new RiuQwtLinearScaleEngine );
// NB! Must assign scale engine to bottom in order to make QwtPlotGrid work
m_plotWidget->qwtPlot()->setAxisScaleEngine( QwtPlot::xBottom, new RiuQwtLinearScaleEngine );
m_plotWidget->qwtPlot()->setAxisScaleEngine( QwtAxis::XBottom, new RiuQwtLinearScaleEngine );
}
}
else
@ -2053,17 +2053,17 @@ void RimWellLogTrack::updateAxisScaleEngine()
if ( m_isLogarithmicScaleEnabled )
{
m_plotWidget->qwtPlot()->setAxisScaleEngine( QwtPlot::yLeft, new QwtLogScaleEngine );
m_plotWidget->qwtPlot()->setAxisScaleEngine( QwtAxis::YLeft, new QwtLogScaleEngine );
// NB! Must assign scale engine to bottom in order to make QwtPlotGrid work
m_plotWidget->qwtPlot()->setAxisScaleEngine( QwtPlot::yRight, new QwtLogScaleEngine );
m_plotWidget->qwtPlot()->setAxisScaleEngine( QwtAxis::YRight, new QwtLogScaleEngine );
}
else
{
m_plotWidget->qwtPlot()->setAxisScaleEngine( QwtPlot::yLeft, new RiuQwtLinearScaleEngine );
m_plotWidget->qwtPlot()->setAxisScaleEngine( QwtAxis::YLeft, new RiuQwtLinearScaleEngine );
// NB! Must assign scale engine to bottom in order to make QwtPlotGrid work
m_plotWidget->qwtPlot()->setAxisScaleEngine( QwtPlot::yRight, new RiuQwtLinearScaleEngine );
m_plotWidget->qwtPlot()->setAxisScaleEngine( QwtAxis::YRight, new RiuQwtLinearScaleEngine );
}
}
}
@ -2125,12 +2125,12 @@ void RimWellLogTrack::handleWheelEvent( QWheelEvent* wheelEvent )
if ( wellLogPlot->depthOrientation() == RimDepthTrackPlot::DepthOrientation::VERTICAL )
{
QwtScaleMap scaleMap = m_plotWidget->qwtPlot()->canvasMap( QwtPlot::yLeft );
QwtScaleMap scaleMap = m_plotWidget->qwtPlot()->canvasMap( QwtAxis::YLeft );
zoomCenter = scaleMap.invTransform( position.y() );
}
else
{
QwtScaleMap scaleMap = m_plotWidget->qwtPlot()->canvasMap( QwtPlot::xTop );
QwtScaleMap scaleMap = m_plotWidget->qwtPlot()->canvasMap( QwtAxis::XTop );
zoomCenter = scaleMap.invTransform( position.x() );
}

8
ApplicationLibCode/UserInterface/AnalysisPlots/RiuGroupedBarChartBuilder.cpp
View File

@ -670,13 +670,13 @@ void RiuGroupedBarChartBuilder::addBarChartToPlot( QwtPlot* plot, Qt::Orientatio
// Set up the axis to contain group texts and tick marks
{
QwtPlot::Axis axis = QwtPlot::xBottom;
QwtPlot::Axis valueAxis = QwtPlot::yLeft;
QwtAxis::Position axis = QwtAxis::XBottom;
QwtAxis::Position valueAxis = QwtAxis::YLeft;
if ( barOrientation == Qt::Horizontal )
{
axis = QwtPlot::yLeft;
valueAxis = QwtPlot::xBottom;
axis = QwtAxis::YLeft;
valueAxis = QwtAxis::XBottom;
}
QwtScaleDiv groupAxisScaleDiv( 0, currentBarPosition );

4
ApplicationLibCode/UserInterface/RiuDockedQwtPlot.cpp
View File

@ -39,7 +39,7 @@ RiuDockedQwtPlot::RiuDockedQwtPlot( QWidget* parent /*= nullptr*/ )
//--------------------------------------------------------------------------------------------------
void RiuDockedQwtPlot::applyFontSizes( bool replot /*= false*/ )
{
std::set<QwtPlot::Axis> allAxes = { QwtPlot::xBottom, QwtPlot::yLeft, QwtPlot::xTop, QwtPlot::yRight };
std::set<QwtAxis::Position> allAxes = { QwtAxis::XBottom, QwtAxis::YLeft, QwtAxis::XTop, QwtAxis::YRight };
caf::FontTools::FontSize fontSize = RiaPreferences::current()->defaultPlotFontSize();
@ -54,7 +54,7 @@ void RiuDockedQwtPlot::applyFontSizes( bool replot /*= false*/ )
titleText.setFont( font );
this->setTitle( titleText );
for ( QwtPlot::Axis axis : allAxes )
for ( QwtAxis::Position axis : allAxes )
{
QwtText text = this->axisTitle( axis );
QFont axisTitleFont = text.font();

20
ApplicationLibCode/UserInterface/RiuFlowCharacteristicsPlot.cpp
View File

@ -99,20 +99,20 @@ RiuFlowCharacteristicsPlot::RiuFlowCharacteristicsPlot( RimFlowCharacteristicsPl
caf::FontTools::RelativeSize::Small );
{
QwtText axisTitle = m_sweepEffPlot->axisTitle( QwtPlot::xBottom );
QwtText axisTitle = m_sweepEffPlot->axisTitle( QwtAxis::XBottom );
auto font = axisTitle.font();
font.setPointSize( legendFontSize );
axisTitle.setFont( font );
axisTitle.setText( "Dimensionless Time" );
m_sweepEffPlot->setAxisTitle( QwtPlot::xBottom, axisTitle );
m_sweepEffPlot->setAxisTitle( QwtAxis::XBottom, axisTitle );
}
{
QwtText axisTitle = m_sweepEffPlot->axisTitle( QwtPlot::yLeft );
QwtText axisTitle = m_sweepEffPlot->axisTitle( QwtAxis::YLeft );
auto font = axisTitle.font();
font.setPointSize( legendFontSize );
axisTitle.setFont( font );
axisTitle.setText( "Sweep Efficiency" );
m_sweepEffPlot->setAxisTitle( QwtPlot::yLeft, axisTitle );
m_sweepEffPlot->setAxisTitle( QwtAxis::YLeft, axisTitle );
}
RiuQwtPlotTools::setCommonPlotBehaviour( m_flowCapVsStorageCapPlot );
@ -121,20 +121,20 @@ RiuFlowCharacteristicsPlot::RiuFlowCharacteristicsPlot( RimFlowCharacteristicsPl
m_flowCapVsStorageCapPlot->setTitle( "Flow Capacity vs Storage Capacity" );
{
QwtText axisTitle = m_flowCapVsStorageCapPlot->axisTitle( QwtPlot::xBottom );
QwtText axisTitle = m_flowCapVsStorageCapPlot->axisTitle( QwtAxis::XBottom );
auto font = axisTitle.font();
font.setPointSize( legendFontSize );
axisTitle.setFont( font );
axisTitle.setText( "Storage Capacity [C]" );
m_flowCapVsStorageCapPlot->setAxisTitle( QwtPlot::xBottom, axisTitle );
m_flowCapVsStorageCapPlot->setAxisTitle( QwtAxis::XBottom, axisTitle );
}
{
QwtText axisTitle = m_flowCapVsStorageCapPlot->axisTitle( QwtPlot::yLeft );
QwtText axisTitle = m_flowCapVsStorageCapPlot->axisTitle( QwtAxis::YLeft );
auto font = axisTitle.font();
font.setPointSize( legendFontSize );
axisTitle.setFont( font );
axisTitle.setText( "Flow Capacity [F]" );
m_flowCapVsStorageCapPlot->setAxisTitle( QwtPlot::yLeft, axisTitle );
m_flowCapVsStorageCapPlot->setAxisTitle( QwtAxis::YLeft, axisTitle );
}
}
@ -282,8 +282,8 @@ void RiuFlowCharacteristicsPlot::removeAllCurves()
//--------------------------------------------------------------------------------------------------
void zoomAllInPlot( QwtPlot* plot )
{
plot->setAxisAutoScale( QwtPlot::xBottom, true );
plot->setAxisAutoScale( QwtPlot::yLeft, true );
plot->setAxisAutoScale( QwtAxis::XBottom, true );
plot->setAxisAutoScale( QwtAxis::YLeft, true );
plot->replot();
}

4
ApplicationLibCode/UserInterface/RiuGridCrossQwtPlot.cpp
View File

@ -70,7 +70,7 @@ RiuGridCrossQwtPlot::RiuGridCrossQwtPlot( RimGridCrossPlot* plot, QWidget* paren
// Attach a zoomer for the right axis
m_zoomerRight = new RiuQwtPlotZoomer( qwtPlot()->canvas() );
m_zoomerRight->setAxes( QwtPlot::xTop, QwtPlot::yRight );
m_zoomerRight->setAxes( QwtAxis::XTop, QwtAxis::YRight );
m_zoomerRight->setTrackerMode( QwtPicker::AlwaysOff );
m_zoomerRight->initMousePattern( 1 );
@ -200,7 +200,7 @@ void RiuGridCrossQwtPlot::onPlotItemSelected( std::shared_ptr<RiuPlotItem> plotI
{
QPointF sample = curve->sample( pointNumber );
m_selectedPointMarker->setValue( sample );
m_selectedPointMarker->setAxes( QwtPlot::xBottom, QwtPlot::yLeft );
m_selectedPointMarker->setAxes( QwtAxis::XBottom, QwtAxis::YLeft );
m_selectedPointMarker->attach( qwtPlot() );
QString curveName, xAxisName, yAxisName;
if ( curveText( curve, &curveName, &xAxisName, &yAxisName ) )

16
ApplicationLibCode/UserInterface/RiuMohrsCirclePlot.cpp
View File

@ -70,13 +70,11 @@ RiuMohrsCirclePlot::RiuMohrsCirclePlot( QWidget* parent )
{
RiuQwtPlotTools::setCommonPlotBehaviour( this );
enableAxis( QwtPlot::xBottom, true );
enableAxis( QwtPlot::yLeft, true );
enableAxis( QwtPlot::xTop, false );
enableAxis( QwtPlot::yRight, false );
setAxesCount( QwtAxis::XBottom, 1 );
setAxesCount( QwtAxis::YLeft, 1 );
setAxisTitle( QwtPlot::xBottom, "Effective Normal Stress" );
setAxisTitle( QwtPlot::yLeft, "Shear Stress" );
setAxisTitle( QwtAxis::XBottom, "Effective Normal Stress" );
setAxisTitle( QwtAxis::YLeft, "Shear Stress" );
applyFontSizes( false );
@ -459,7 +457,7 @@ void RiuMohrsCirclePlot::updateTransparentCurvesOnPrincipals()
qVectorPoints.push_back( QPointF( mohrCircleInfo.principals[2], 0 ) );
transparentCurve->setSamples( qVectorPoints );
transparentCurve->setYAxis( QwtPlot::yLeft );
transparentCurve->setYAxis( QwtAxis::YLeft );
transparentCurve->setStyle( QwtPlotCurve::NoCurve );
transparentCurve->setLegendAttribute( QwtPlotCurve::LegendNoAttribute );
@ -715,8 +713,8 @@ void RiuMohrsCirclePlot::setAxesScaleAndReplot()
yMaxDisplayed = heightToKeepAspectRatio;
}
this->setAxisScale( QwtPlot::yLeft, 0, yMaxDisplayed );
this->setAxisScale( QwtPlot::xBottom, xMin, xMaxDisplayed );
this->setAxisScale( QwtAxis::YLeft, 0, yMaxDisplayed );
this->setAxisScale( QwtAxis::XBottom, xMin, xMaxDisplayed );
this->replot();
}

6
ApplicationLibCode/UserInterface/RiuMultiPlotPage.cpp
View File

@ -709,9 +709,9 @@ int RiuMultiPlotPage::alignCanvasTops()
int row = visibleIndex / rowAndColumnCount.second;
if ( plotWidgets[visibleIndex]->axisEnabled( RiuPlotAxis::defaultTop() ) )
{
QFont font = qwtPlotWidget->qwtPlot()->axisFont( QwtPlot::xTop );
QFont font = qwtPlotWidget->qwtPlot()->axisFont( QwtAxis::XTop );
maxExtents[row] = std::max( maxExtents[row],
qwtPlotWidget->qwtPlot()->axisScaleDraw( QwtPlot::xTop )->extent( font ) );
qwtPlotWidget->qwtPlot()->axisScaleDraw( QwtAxis::XTop )->extent( font ) );
}
}
}
@ -722,7 +722,7 @@ int RiuMultiPlotPage::alignCanvasTops()
if ( qwtPlotWidget )
{
int row = visibleIndex / rowAndColumnCount.second;
qwtPlotWidget->qwtPlot()->axisScaleDraw( QwtPlot::xTop )->setMinimumExtent( maxExtents[row] );
qwtPlotWidget->qwtPlot()->axisScaleDraw( QwtAxis::XTop )->setMinimumExtent( maxExtents[row] );
if ( legends[visibleIndex] )
{
legends[visibleIndex]->adjustSize();

8
ApplicationLibCode/UserInterface/RiuPlotAnnotationTool.cpp
View File

@ -96,7 +96,7 @@ void RiuPlotAnnotationTool::attachNamedRegions( QwtPlot*
shading->setBrush( brush );
shading->attach( m_plot );
shading->setZ( -100.0 );
shading->setXAxis( QwtPlot::xTop );
shading->setXAxis( QwtAxis::XTop );
m_horizontalMarkers.push_back( std::move( shading ) );
}
@ -335,7 +335,7 @@ void RiuPlotAnnotationTool::horizontalRange( const QString& nam
shading->setBrush( brush );
shading->attach( m_plot );
shading->setZ( -100.0 );
shading->setXAxis( QwtPlot::xBottom );
shading->setXAxis( QwtAxis::XBottom );
m_horizontalMarkers.push_back( std::move( shading ) );
QwtPlotMarker* line( new QwtPlotMarker() );
@ -370,7 +370,7 @@ void RiuPlotAnnotationTool::verticalRange( const QString& name,
shading->setBrush( brush );
shading->attach( m_plot );
shading->setZ( -100.0 );
shading->setXAxis( QwtPlot::xBottom );
shading->setXAxis( QwtAxis::XBottom );
m_verticalMarkers.push_back( std::move( shading ) );
QStringList labels = name.split( " - " );
@ -414,7 +414,7 @@ void RiuPlotAnnotationTool::verticalLine( QwtPlotMarker* line,
curvePen.setColor( color );
curvePen.setWidth( 1 );
line->setAxes( QwtPlot::xBottom, QwtPlot::yLeft );
line->setAxes( QwtAxis::XBottom, QwtAxis::YLeft );
line->setLineStyle( QwtPlotMarker::VLine );
line->setLinePen( curvePen );
line->setXValue( xValue );

20
ApplicationLibCode/UserInterface/RiuPvtPlotPanel.cpp
View File

@ -143,22 +143,22 @@ void RiuPvtPlotWidget::setPlotDefaults( QwtPlot* plot )
// Axis number font
{
QFont axisFont = plot->axisFont( QwtPlot::xBottom );
QFont axisFont = plot->axisFont( QwtAxis::XBottom );
axisFont.setPointSize( 8 );
plot->setAxisFont( QwtPlot::xBottom, axisFont );
plot->setAxisFont( QwtPlot::yLeft, axisFont );
plot->setAxisFont( QwtAxis::XBottom, axisFont );
plot->setAxisFont( QwtAxis::YLeft, axisFont );
}
// Axis title font
{
QwtText axisTitle = plot->axisTitle( QwtPlot::xBottom );
QwtText axisTitle = plot->axisTitle( QwtAxis::XBottom );
QFont axisTitleFont = axisTitle.font();
axisTitleFont.setPointSize( 8 );
axisTitleFont.setBold( false );
axisTitle.setFont( axisTitleFont );
axisTitle.setRenderFlags( Qt::AlignRight );
plot->setAxisTitle( QwtPlot::xBottom, axisTitle );
plot->setAxisTitle( QwtPlot::yLeft, axisTitle );
plot->setAxisTitle( QwtAxis::XBottom, axisTitle );
plot->setAxisTitle( QwtAxis::YLeft, axisTitle );
}
// Title font
@ -170,8 +170,8 @@ void RiuPvtPlotWidget::setPlotDefaults( QwtPlot* plot )
plot->setTitle( plotTitle );
}
plot->setAxisMaxMinor( QwtPlot::xBottom, 2 );
plot->setAxisMaxMinor( QwtPlot::yLeft, 3 );
plot->setAxisMaxMinor( QwtAxis::XBottom, 2 );
plot->setAxisMaxMinor( QwtAxis::YLeft, 3 );
plot->plotLayout()->setAlignCanvasToScales( true );
}
@ -310,9 +310,9 @@ void RiuPvtPlotWidget::plotCurves( RiaDefines::EclipseUnitSystem
m_qwtPlot->setTitle( plotTitle );
m_qwtPlot->setAxisTitle( QwtPlot::xBottom,
m_qwtPlot->setAxisTitle( QwtAxis::XBottom,
QString( "Pressure [%1]" ).arg( RiaEclipseUnitTools::unitStringPressure( unitSystem ) ) );
m_qwtPlot->setAxisTitle( QwtPlot::yLeft, yAxisTitle );
m_qwtPlot->setAxisTitle( QwtAxis::YLeft, yAxisTitle );
updateTrackerPlotMarkerAndLabelFromPicker();

26
ApplicationLibCode/UserInterface/RiuQwtCurvePointTracker.cpp
View File

@ -103,8 +103,8 @@ QwtText RiuQwtCurvePointTracker::trackerText( const QPoint& pos ) const
if ( m_plot )
{
QwtPlot::Axis relatedYAxis = QwtPlot::yLeft;
QwtPlot::Axis relatedXAxis = QwtPlot::xBottom;
QwtAxis::Position relatedYAxis = QwtAxis::YLeft;
QwtAxis::Position relatedXAxis = QwtAxis::XBottom;
QString curveInfoText;
QString mainAxisValueString;
@ -136,12 +136,12 @@ QwtText RiuQwtCurvePointTracker::trackerText( const QPoint& pos ) const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QPointF RiuQwtCurvePointTracker::closestCurvePoint( const QPoint& cursorPosition,
QString* curveInfoText,
QString* valueAxisValueString,
QString* mainAxisValueString,
QwtPlot::Axis* relatedXAxis,
QwtPlot::Axis* relatedYAxis ) const
QPointF RiuQwtCurvePointTracker::closestCurvePoint( const QPoint& cursorPosition,
QString* curveInfoText,
QString* valueAxisValueString,
QString* mainAxisValueString,
QwtAxis::Position* relatedXAxis,
QwtAxis::Position* relatedYAxis ) const
{
QPointF samplePoint;
@ -170,8 +170,8 @@ QPointF RiuQwtCurvePointTracker::closestCurvePoint( const QPoint& cursorPositio
{
samplePoint = closestCurve->sample( closestPointSampleIndex );
if ( relatedXAxis ) *relatedXAxis = static_cast<QwtPlot::Axis>( closestCurve->xAxis() );
if ( relatedYAxis ) *relatedYAxis = static_cast<QwtPlot::Axis>( closestCurve->yAxis() );
if ( relatedXAxis ) *relatedXAxis = static_cast<QwtAxis::Position>( closestCurve->xAxis().pos );
if ( relatedYAxis ) *relatedYAxis = static_cast<QwtAxis::Position>( closestCurve->yAxis().pos );
}
if ( mainAxisValueString )
@ -227,9 +227,9 @@ QPointF RiuQwtCurvePointTracker::closestCurvePoint( const QPoint& cursorPositio
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuQwtCurvePointTracker::updateClosestCurvePointMarker( const QPointF& closestPoint,
QwtPlot::Axis relatedXAxis,
QwtPlot::Axis relatedYAxis ) const
void RiuQwtCurvePointTracker::updateClosestCurvePointMarker( const QPointF& closestPoint,
QwtAxis::Position relatedXAxis,
QwtAxis::Position relatedYAxis ) const
{
bool replotRequired = false;

18
ApplicationLibCode/UserInterface/RiuQwtCurvePointTracker.h
View File

@ -42,15 +42,15 @@ protected:
void removeMarkerOnFocusLeave();
QwtText trackerText( const QPoint& pos ) const override;
QPointF closestCurvePoint( const QPoint& cursorPosition,
QString* curveInfoText,
QString* valueAxisValueString,
QString* mainAxisValueString,
QwtPlot::Axis* relatedXAxis,
QwtPlot::Axis* relatedYAxis ) const;
void updateClosestCurvePointMarker( const QPointF& closestPoint,
QwtPlot::Axis relatedXAxis,
QwtPlot::Axis relatedYAxis ) const;
QPointF closestCurvePoint( const QPoint& cursorPosition,
QString* curveInfoText,
QString* valueAxisValueString,
QString* mainAxisValueString,
QwtAxis::Position* relatedXAxis,
QwtAxis::Position* relatedYAxis ) const;
void updateClosestCurvePointMarker( const QPointF& closestPoint,
QwtAxis::Position relatedXAxis,
QwtAxis::Position relatedYAxis ) const;
QPointer<QwtPlot> m_plot;
QwtPlotMarker* m_plotMarker;

4
ApplicationLibCode/UserInterface/RiuQwtPlotCurve.cpp
View File

@ -479,7 +479,7 @@ void RiuQwtPlotCurve::setSamplesFromXYErrorValues( const std::vector<double>&
//--------------------------------------------------------------------------------------------------
void RiuQwtPlotCurve::setXAxis( RiuPlotAxis axis )
{
QwtPlotCurve::setXAxis( RiuQwtPlotTools::toQwtPlotAxis( axis.axis() ) );
QwtPlotCurve::setXAxis( RiuQwtPlotTools::toQwtPlotAxis( axis ) );
}
//--------------------------------------------------------------------------------------------------
@ -487,7 +487,7 @@ void RiuQwtPlotCurve::setXAxis( RiuPlotAxis axis )
//--------------------------------------------------------------------------------------------------
void RiuQwtPlotCurve::setYAxis( RiuPlotAxis axis )
{
QwtPlotCurve::setYAxis( RiuQwtPlotTools::toQwtPlotAxis( axis.axis() ) );
QwtPlotCurve::setYAxis( RiuQwtPlotTools::toQwtPlotAxis( axis ) );
}
//--------------------------------------------------------------------------------------------------

84
ApplicationLibCode/UserInterface/RiuQwtPlotTools.cpp
View File

@ -21,6 +21,7 @@
#include "RiaColorTools.h"
#include "RiaPreferences.h"
#include "RiaQDateTimeTools.h"
#include "RiuPlotAxis.h"
#include "RimPlotCurve.h"
@ -38,6 +39,7 @@
#include "qwt_plot_shapeitem.h"
#include "qwt_scale_widget.h"
#include "qwt_axis.h"
#include <QRegExp>
#include <vector>
@ -70,18 +72,18 @@ void RiuQwtPlotTools::setCommonPlotBehaviour( QwtPlot* plot )
// Axis number font
int axisFontSize = caf::FontTools::absolutePointSize( RiaPreferences::current()->defaultPlotFontSize(),
caf::FontTools::RelativeSize::Medium );
QFont axisFont = plot->axisFont( QwtPlot::xBottom );
QFont axisFont = plot->axisFont( QwtAxis::XBottom );
axisFont.setPixelSize( caf::FontTools::pointSizeToPixelSize( axisFontSize ) );
plot->setAxisFont( QwtPlot::xBottom, axisFont );
plot->setAxisFont( QwtPlot::xTop, axisFont );
plot->setAxisFont( QwtPlot::yLeft, axisFont );
plot->setAxisFont( QwtPlot::yRight, axisFont );
plot->setAxisFont( QwtAxis::XBottom, axisFont );
plot->setAxisFont( QwtAxis::XTop, axisFont );
plot->setAxisFont( QwtAxis::YLeft, axisFont );
plot->setAxisFont( QwtAxis::YRight, axisFont );
// Axis title font
std::vector<QwtPlot::Axis> axes = { QwtPlot::xBottom, QwtPlot::xTop, QwtPlot::yLeft, QwtPlot::yRight };
std::vector<QwtAxis::Position> axes = { QwtAxis::XBottom, QwtAxis::XTop, QwtAxis::YLeft, QwtAxis::YRight };
for ( QwtPlot::Axis axis : axes )
for ( QwtAxis::Position axis : axes )
{
QwtText axisTitle = plot->axisTitle( axis );
QFont axisTitleFont = axisTitle.font();
@ -118,18 +120,16 @@ void RiuQwtPlotTools::setCommonPlotBehaviour( QwtPlot* plot )
//--------------------------------------------------------------------------------------------------
void RiuQwtPlotTools::setDefaultAxes( QwtPlot* plot )
{
plot->enableAxis( QwtPlot::xBottom, true );
plot->enableAxis( QwtPlot::yLeft, true );
plot->enableAxis( QwtPlot::xTop, false );
plot->enableAxis( QwtPlot::yRight, false );
plot->setAxesCount( QwtAxis::XBottom, 1 );
plot->setAxesCount( QwtAxis::YLeft, 1 );
plot->axisWidget( QwtPlot::xBottom )->setMargin( 0 );
plot->axisWidget( QwtPlot::yLeft )->setMargin( 0 );
plot->axisWidget( QwtPlot::xTop )->setMargin( 0 );
plot->axisWidget( QwtPlot::yRight )->setMargin( 0 );
plot->axisWidget( QwtAxis::XBottom )->setMargin( 0 );
plot->axisWidget( QwtAxis::YLeft )->setMargin( 0 );
plot->axisWidget( QwtAxis::XTop )->setMargin( 0 );
plot->axisWidget( QwtAxis::YRight )->setMargin( 0 );
plot->setAxisMaxMinor( QwtPlot::xBottom, 2 );
plot->setAxisMaxMinor( QwtPlot::yLeft, 3 );
plot->setAxisMaxMinor( QwtAxis::XBottom, 2 );
plot->setAxisMaxMinor( QwtAxis::YLeft, 3 );
}
//--------------------------------------------------------------------------------------------------
@ -159,8 +159,8 @@ void RiuQwtPlotTools::enableDateBasedBottomXAxis( QwtPlot*
}
QwtDateScaleEngine* scaleEngine = new QwtDateScaleEngine( Qt::UTC );
plot->setAxisScaleEngine( QwtPlot::xBottom, scaleEngine );
plot->setAxisScaleDraw( QwtPlot::xBottom, scaleDraw );
plot->setAxisScaleEngine( QwtAxis::XBottom, scaleEngine );
plot->setAxisScaleDraw( QwtAxis::XBottom, scaleDraw );
}
//--------------------------------------------------------------------------------------------------
@ -248,31 +248,45 @@ QwtPlotShapeItem* RiuQwtPlotTools::createBoxShape( const QString& label,
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QwtPlot::Axis RiuQwtPlotTools::toQwtPlotAxis( RiaDefines::PlotAxis axis )
QwtAxisId RiuQwtPlotTools::toQwtPlotAxis( RiuPlotAxis axis )
{
if ( axis == RiaDefines::PlotAxis::PLOT_AXIS_LEFT )
return QwtPlot::yLeft;
else if ( axis == RiaDefines::PlotAxis::PLOT_AXIS_RIGHT )
return QwtPlot::yRight;
else if ( axis == RiaDefines::PlotAxis::PLOT_AXIS_BOTTOM )
return QwtPlot::xBottom;
QwtAxis::Position qwtPosition = toQwtPlotAxisEnum( axis.axis() );
return QwtPlot::xTop;
return { qwtPosition, axis.index() };
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaDefines::PlotAxis RiuQwtPlotTools::fromQwtPlotAxis( QwtPlot::Axis axis )
QwtAxis::Position RiuQwtPlotTools::toQwtPlotAxisEnum( RiaDefines::PlotAxis riaPlotAxis )
{
if ( axis == QwtPlot::yLeft )
return RiaDefines::PlotAxis::PLOT_AXIS_LEFT;
else if ( axis == QwtPlot::yRight )
return RiaDefines::PlotAxis::PLOT_AXIS_RIGHT;
else if ( axis == QwtPlot::xBottom )
return RiaDefines::PlotAxis::PLOT_AXIS_BOTTOM;
if ( riaPlotAxis == RiaDefines::PlotAxis::PLOT_AXIS_LEFT )
return QwtAxis::YLeft;
else if ( riaPlotAxis == RiaDefines::PlotAxis::PLOT_AXIS_RIGHT )
return QwtAxis::YRight;
else if ( riaPlotAxis == RiaDefines::PlotAxis::PLOT_AXIS_BOTTOM )
return QwtAxis::XBottom;
else if ( riaPlotAxis == RiaDefines::PlotAxis::PLOT_AXIS_TOP )
return QwtAxis::XTop;
return RiaDefines::PlotAxis::PLOT_AXIS_TOP;
return QwtAxis::YLeft;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaDefines::PlotAxis RiuQwtPlotTools::fromQwtPlotAxis( QwtAxis::Position axis )
{
if ( axis == QwtAxis::YLeft )
return RiaDefines::PlotAxis::PLOT_AXIS_LEFT;
else if ( axis == QwtAxis::YRight )
return RiaDefines::PlotAxis::PLOT_AXIS_RIGHT;
else if ( axis == QwtAxis::XBottom )
return RiaDefines::PlotAxis::PLOT_AXIS_BOTTOM;
else if ( axis == QwtAxis::XTop )
return RiaDefines::PlotAxis::PLOT_AXIS_TOP;
return RiaDefines::PlotAxis::PLOT_AXIS_LEFT;
}
//--------------------------------------------------------------------------------------------------

11
ApplicationLibCode/UserInterface/RiuQwtPlotTools.h
View File

@ -20,6 +20,7 @@
#include "RiaDateTimeDefines.h"
#include "RiaPlotDefines.h"
#include <qwt_axis_id.h>
#include <qwt_date.h>
#include <qwt_plot.h>
#include <qwt_plot_shapeitem.h>
@ -27,6 +28,8 @@
class RiuQwtPlotLegend;
class RimPlotCurve;
class RiuPlotAxis;
class RiuQwtPlotTools
{
public:
@ -62,11 +65,13 @@ public:
QColor color,
Qt::BrushStyle brushStyle = Qt::SolidPattern );
static QwtPlot::Axis toQwtPlotAxis( RiaDefines::PlotAxis );
static RiaDefines::PlotAxis fromQwtPlotAxis( QwtPlot::Axis );
static void updateLegendData( RiuQwtPlotLegend* legend, const std::vector<RimPlotCurve*>& curves );
static QList<QwtLegendData> createLegendData( const std::vector<RimPlotCurve*>& curves );
static QwtAxisId toQwtPlotAxis( RiuPlotAxis riuPlotAxis );
static QwtAxis::Position toQwtPlotAxisEnum( RiaDefines::PlotAxis riaPlotAxis );
static RiaDefines::PlotAxis fromQwtPlotAxis( QwtAxis::Position );
};
//--------------------------------------------------------------------------------------------------
@ -90,7 +95,7 @@ PlotShapeItemType* RiuQwtPlotTools::createBoxShapeT( const QString& label,
polygon.push_back( QPointF( startX, endY ) );
polygon.push_back( QPointF( startX, startY ) );
columnShape->setPolygon( polygon );
columnShape->setXAxis( QwtPlot::xBottom );
columnShape->setXAxis( QwtAxis::XBottom );
columnShape->setBrush( QBrush( color, brushStyle ) );
columnShape->setLegendMode( QwtPlotShapeItem::LegendShape );
columnShape->setLegendIconSize( QSize( 16, 16 ) );

14
ApplicationLibCode/UserInterface/RiuQwtPlotWheelZoomer.cpp
View File

@ -47,7 +47,7 @@ RiuQwtPlotWheelZoomer::RiuQwtPlotWheelZoomer( QwtPlot* plot )
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuQwtPlotWheelZoomer::zoomOnAxis( QwtPlot* plot, QwtPlot::Axis axis, double zoomFactor, int eventPos )
void RiuQwtPlotWheelZoomer::zoomOnAxis( QwtPlot* plot, QwtAxis::Position axis, double zoomFactor, int eventPos )
{
QwtScaleMap scaleMap = plot->canvasMap( axis );
double zoomCenter = scaleMap.invTransform( eventPos );
@ -75,7 +75,7 @@ void RiuQwtPlotWheelZoomer::zoomOnAxis( QwtPlot* plot, QwtPlot::Axis axis, doubl
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RiuQwtPlotWheelZoomer::axisIsLogarithmic( QwtPlot::Axis axis ) const
bool RiuQwtPlotWheelZoomer::axisIsLogarithmic( QwtAxis::Position axis ) const
{
auto it = m_axesAreLogarithmic.find( axis );
return it != m_axesAreLogarithmic.end() ? it->second : false;
@ -96,10 +96,10 @@ bool RiuQwtPlotWheelZoomer::eventFilter( QObject* watched, QEvent* event )
}
auto position = caf::position( wheelEvent );
zoomOnAxis( m_plot, QwtPlot::xBottom, zoomFactor, position.x() );
zoomOnAxis( m_plot, QwtPlot::xTop, zoomFactor, position.x() );
zoomOnAxis( m_plot, QwtPlot::yLeft, zoomFactor, position.y() );
zoomOnAxis( m_plot, QwtPlot::yRight, zoomFactor, position.y() );
zoomOnAxis( m_plot, QwtAxis::XBottom, zoomFactor, position.x() );
zoomOnAxis( m_plot, QwtAxis::XTop, zoomFactor, position.x() );
zoomOnAxis( m_plot, QwtAxis::YLeft, zoomFactor, position.y() );
zoomOnAxis( m_plot, QwtAxis::YRight, zoomFactor, position.y() );
m_plot->replot();
emit zoomUpdated();
@ -111,7 +111,7 @@ bool RiuQwtPlotWheelZoomer::eventFilter( QObject* watched, QEvent* event )
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuQwtPlotWheelZoomer::setAxisIsLogarithmic( QwtPlot::Axis axis, bool logarithmic )
void RiuQwtPlotWheelZoomer::setAxisIsLogarithmic( QwtAxis::Position axis, bool logarithmic )
{
m_axesAreLogarithmic[axis] = logarithmic;
}

8
ApplicationLibCode/UserInterface/RiuQwtPlotWheelZoomer.h
View File

@ -33,17 +33,17 @@ public:
bool eventFilter( QObject* watched, QEvent* event ) override;
void setAxisIsLogarithmic( QwtPlot::Axis axis, bool logarithmic );
void setAxisIsLogarithmic( QwtAxis::Position axis, bool logarithmic );
signals:
void zoomUpdated();
private:
void zoomOnAxis( QwtPlot* plot, QwtPlot::Axis axis, double zoomFactor, int eventPos );
bool axisIsLogarithmic( QwtPlot::Axis axis ) const;
void zoomOnAxis( QwtPlot* plot, QwtAxis::Position axis, double zoomFactor, int eventPos );
bool axisIsLogarithmic( QwtAxis::Position axis ) const;
private:
QwtPlot* m_plot;
std::map<QwtPlot::Axis, bool> m_axesAreLogarithmic;
std::map<QwtAxis::Position, bool> m_axesAreLogarithmic;
};

96
ApplicationLibCode/UserInterface/RiuQwtPlotWidget.cpp
View File

@ -121,7 +121,7 @@ int RiuQwtPlotWidget::axisTitleFontSize( RiuPlotAxis axis ) const
{
if ( axisEnabled( axis ) )
{
return m_plot->axisFont( RiuQwtPlotTools::toQwtPlotAxis( axis.axis() ) ).pointSize();
return m_plot->axisFont( RiuQwtPlotTools::toQwtPlotAxis( axis ) ).pointSize();
}
return -1;
}
@ -133,7 +133,7 @@ int RiuQwtPlotWidget::axisValueFontSize( RiuPlotAxis axis ) const
{
if ( axisEnabled( axis ) )
{
return m_plot->axisTitle( RiuQwtPlotTools::toQwtPlotAxis( axis.axis() ) ).font().pointSize();
return m_plot->axisTitle( RiuQwtPlotTools::toQwtPlotAxis( axis ) ).font().pointSize();
}
return -1;
}
@ -148,7 +148,7 @@ void RiuQwtPlotWidget::setAxisFontsAndAlignment( RiuPlotAxis axis, int titleFont
// Axis number font
int qwtAxis = RiuQwtPlotTools::toQwtPlotAxis( axis.axis() );
auto qwtAxis = RiuQwtPlotTools::toQwtPlotAxis( axis );
QFont axisFont = m_plot->axisFont( qwtAxis );
axisFont.setPixelSize( valueFontPixelSize );
axisFont.setBold( false );
@ -300,7 +300,7 @@ void RiuQwtPlotWidget::clearLegend()
//--------------------------------------------------------------------------------------------------
std::pair<double, double> RiuQwtPlotWidget::axisRange( RiuPlotAxis axis ) const
{
QwtInterval interval = m_plot->axisScaleDiv( RiuQwtPlotTools::toQwtPlotAxis( axis.axis() ) ).interval();
QwtInterval interval = m_plot->axisScaleDiv( RiuQwtPlotTools::toQwtPlotAxis( axis ) ).interval();
return std::make_pair( interval.minValue(), interval.maxValue() );
}
@ -310,7 +310,7 @@ std::pair<double, double> RiuQwtPlotWidget::axisRange( RiuPlotAxis axis ) const
void RiuQwtPlotWidget::setAxisRange( RiuPlotAxis axis, double min, double max )
{
// Note: Especially the Y-axis may be inverted
if ( m_plot->axisScaleEngine( RiuQwtPlotTools::toQwtPlotAxis( axis.axis() ) )->testAttribute( QwtScaleEngine::Inverted ) )
if ( m_plot->axisScaleEngine( RiuQwtPlotTools::toQwtPlotAxis( axis ) )->testAttribute( QwtScaleEngine::Inverted ) )
{
setAxisScale( axis, max, min );
}
@ -325,7 +325,7 @@ void RiuQwtPlotWidget::setAxisRange( RiuPlotAxis axis, double min, double max )
//--------------------------------------------------------------------------------------------------
void RiuQwtPlotWidget::setAxisInverted( RiuPlotAxis axis, bool isInverted )
{
m_plot->axisScaleEngine( RiuQwtPlotTools::toQwtPlotAxis( axis.axis() ) )->setAttribute( QwtScaleEngine::Inverted, isInverted );
m_plot->axisScaleEngine( RiuQwtPlotTools::toQwtPlotAxis( axis ) )->setAttribute( QwtScaleEngine::Inverted, isInverted );
}
//--------------------------------------------------------------------------------------------------
@ -333,10 +333,8 @@ void RiuQwtPlotWidget::setAxisInverted( RiuPlotAxis axis, bool isInverted )
//--------------------------------------------------------------------------------------------------
void RiuQwtPlotWidget::setAxisLabelsAndTicksEnabled( RiuPlotAxis axis, bool enableLabels, bool enableTicks )
{
m_plot->axisScaleDraw( RiuQwtPlotTools::toQwtPlotAxis( axis.axis() ) )
->enableComponent( QwtAbstractScaleDraw::Ticks, enableTicks );
m_plot->axisScaleDraw( RiuQwtPlotTools::toQwtPlotAxis( axis.axis() ) )
->enableComponent( QwtAbstractScaleDraw::Labels, enableLabels );
m_plot->axisScaleDraw( RiuQwtPlotTools::toQwtPlotAxis( axis ) )->enableComponent( QwtAbstractScaleDraw::Ticks, enableTicks );
m_plot->axisScaleDraw( RiuQwtPlotTools::toQwtPlotAxis( axis ) )->enableComponent( QwtAbstractScaleDraw::Labels, enableLabels );
recalculateAxisExtents( axis );
}
@ -346,11 +344,11 @@ void RiuQwtPlotWidget::setAxisLabelsAndTicksEnabled( RiuPlotAxis axis, bool enab
void RiuQwtPlotWidget::enableGridLines( RiuPlotAxis axis, bool majorGridLines, bool minorGridLines )
{
QwtPlotItemList plotItems = m_plot->itemList( QwtPlotItem::Rtti_PlotGrid );
QwtPlot::Axis qwtAxis = RiuQwtPlotTools::toQwtPlotAxis( axis.axis() );
auto qwtAxis = RiuQwtPlotTools::toQwtPlotAxis( axis );
for ( QwtPlotItem* plotItem : plotItems )
{
QwtPlotGrid* grid = static_cast<QwtPlotGrid*>( plotItem );
if ( qwtAxis == QwtPlot::xTop || qwtAxis == QwtPlot::xBottom )
if ( qwtAxis == QwtAxis::XTop || qwtAxis == QwtAxis::XBottom )
{
grid->setXAxis( qwtAxis );
grid->enableX( majorGridLines );
@ -376,7 +374,7 @@ void RiuQwtPlotWidget::setMajorAndMinorTickIntervals( RiuPlotAxis axis,
double minValue,
double maxValue )
{
QwtPlot::Axis qwtAxis = RiuQwtPlotTools::toQwtPlotAxis( axis.axis() );
auto qwtAxis = RiuQwtPlotTools::toQwtPlotAxis( axis );
RiuQwtLinearScaleEngine* scaleEngine = dynamic_cast<RiuQwtLinearScaleEngine*>( m_plot->axisScaleEngine( qwtAxis ) );
if ( scaleEngine )
{
@ -398,7 +396,7 @@ void RiuQwtPlotWidget::setMajorAndMinorTickIntervalsAndRange( RiuPlotAxis axis,
double rangeMin,
double rangeMax )
{
QwtPlot::Axis qwtAxis = RiuQwtPlotTools::toQwtPlotAxis( axis.axis() );
auto qwtAxis = RiuQwtPlotTools::toQwtPlotAxis( axis );
RiuQwtLinearScaleEngine* scaleEngine = dynamic_cast<RiuQwtLinearScaleEngine*>( m_plot->axisScaleEngine( qwtAxis ) );
if ( scaleEngine )
{
@ -418,10 +416,10 @@ void RiuQwtPlotWidget::setMajorAndMinorTickIntervalsAndRange( RiuPlotAxis axis,
//--------------------------------------------------------------------------------------------------
void RiuQwtPlotWidget::setAutoTickIntervalCounts( RiuPlotAxis axis, int maxMajorTickIntervalCount, int maxMinorTickIntervalCount )
{
m_plot->setAxisMaxMajor( RiuQwtPlotTools::toQwtPlotAxis( axis.axis() ), maxMajorTickIntervalCount );
m_plot->setAxisMaxMinor( RiuQwtPlotTools::toQwtPlotAxis( axis.axis() ), maxMinorTickIntervalCount );
m_plot->setAxisMaxMajor( RiuQwtPlotTools::toQwtPlotAxis( axis ), maxMajorTickIntervalCount );
m_plot->setAxisMaxMinor( RiuQwtPlotTools::toQwtPlotAxis( axis ), maxMinorTickIntervalCount );
// Reapply axis limits to force Qwt to use the tick settings.
QwtInterval currentRange = m_plot->axisInterval( RiuQwtPlotTools::toQwtPlotAxis( axis.axis() ) );
QwtInterval currentRange = m_plot->axisInterval( RiuQwtPlotTools::toQwtPlotAxis( axis ) );
setAxisScale( axis, currentRange.minValue(), currentRange.maxValue() );
}
@ -430,7 +428,7 @@ void RiuQwtPlotWidget::setAutoTickIntervalCounts( RiuPlotAxis axis, int maxMajor
//--------------------------------------------------------------------------------------------------
double RiuQwtPlotWidget::majorTickInterval( RiuPlotAxis axis ) const
{
QwtScaleDiv scaleDiv = m_plot->axisScaleDiv( RiuQwtPlotTools::toQwtPlotAxis( axis.axis() ) );
QwtScaleDiv scaleDiv = m_plot->axisScaleDiv( RiuQwtPlotTools::toQwtPlotAxis( axis ) );
QList<double> majorTicks = scaleDiv.ticks( QwtScaleDiv::MajorTick );
if ( majorTicks.size() < 2 ) return 0.0;
@ -442,7 +440,7 @@ double RiuQwtPlotWidget::majorTickInterval( RiuPlotAxis axis ) const
//--------------------------------------------------------------------------------------------------
double RiuQwtPlotWidget::minorTickInterval( RiuPlotAxis axis ) const
{
QwtScaleDiv scaleDiv = m_plot->axisScaleDiv( QwtPlot::xTop );
QwtScaleDiv scaleDiv = m_plot->axisScaleDiv( QwtAxis::XTop );
QList<double> minorTicks = scaleDiv.ticks( QwtScaleDiv::MinorTick );
if ( minorTicks.size() < 2 ) return 0.0;
@ -457,8 +455,8 @@ int RiuQwtPlotWidget::axisExtent( RiuPlotAxis axis ) const
auto [rangeMin, rangeMax] = axisRange( axis );
if ( std::abs( rangeMax - rangeMin ) < 1.0e-14 ) return 0;
int lineExtent = 0;
QwtPlot::Axis qwtAxis = RiuQwtPlotTools::toQwtPlotAxis( axis.axis() );
int lineExtent = 0;
auto qwtAxis = RiuQwtPlotTools::toQwtPlotAxis( axis );
if ( m_plot->axisScaleDraw( qwtAxis )->hasComponent( QwtAbstractScaleDraw::Ticks ) )
{
@ -467,7 +465,7 @@ int RiuQwtPlotWidget::axisExtent( RiuPlotAxis axis ) const
if ( m_plot->axisScaleDraw( qwtAxis )->hasComponent( QwtAbstractScaleDraw::Labels ) )
{
QFont tickLabelFont = m_plot->axisFont( RiuQwtPlotTools::toQwtPlotAxis( axis.axis() ) );
QFont tickLabelFont = m_plot->axisFont( RiuQwtPlotTools::toQwtPlotAxis( axis ) );
// Make space for a fairly long value label
QSize labelSize = QFontMetrics( tickLabelFont ).boundingRect( QString( "9.9e-9" ) ).size();
@ -655,9 +653,9 @@ void RiuQwtPlotWidget::applyPlotTitleToQwt()
//--------------------------------------------------------------------------------------------------
void RiuQwtPlotWidget::applyAxisTitleToQwt( RiuPlotAxis axis )
{
QString titleToApply = m_axisTitlesEnabled[axis] ? m_axisTitles[axis] : QString( "" );
QwtPlot::Axis qwtAxis = RiuQwtPlotTools::toQwtPlotAxis( axis.axis() );
QwtText axisTitle = m_plot->axisTitle( qwtAxis );
QString titleToApply = m_axisTitlesEnabled[axis] ? m_axisTitles[axis] : QString( "" );
auto qwtAxis = RiuQwtPlotTools::toQwtPlotAxis( axis );
QwtText axisTitle = m_plot->axisTitle( qwtAxis );
if ( titleToApply != axisTitle.text() )
{
axisTitle.setText( titleToApply );
@ -780,7 +778,7 @@ RimViewWindow* RiuQwtPlotWidget::ownerViewWindow() const
void RiuQwtPlotWidget::onAxisSelected( QwtScaleWidget* scale, bool toggleItemInSelection )
{
int axisId = -1;
for ( int i = 0; i < QwtPlot::axisCnt; ++i )
for ( int i = 0; i < QwtAxis::AxisPositions; ++i )
{
if ( scale == m_plot->axisWidget( i ) )
{
@ -795,8 +793,8 @@ void RiuQwtPlotWidget::onAxisSelected( QwtScaleWidget* scale, bool toggleItemInS
//--------------------------------------------------------------------------------------------------
void RiuQwtPlotWidget::recalculateAxisExtents( RiuPlotAxis axis )
{
QwtPlot::Axis qwtAxis = RiuQwtPlotTools::toQwtPlotAxis( axis.axis() );
if ( qwtAxis == QwtPlot::yLeft || qwtAxis == QwtPlot::yRight )
auto qwtAxis = RiuQwtPlotTools::toQwtPlotAxis( axis );
if ( qwtAxis.pos == QwtAxis::YLeft || qwtAxis.pos == QwtAxis::YRight )
{
int extent = axisExtent( axis );
m_plot->axisScaleDraw( qwtAxis )->setMinimumExtent( extent );
@ -845,8 +843,8 @@ void RiuQwtPlotWidget::findClosestPlotItem( const QPoint& pos,
else if ( ( *it )->rtti() == QwtPlotItem::Rtti_PlotShape )
{
QwtPlotShapeItem* shapeItem = static_cast<QwtPlotShapeItem*>( *it );
QPointF scalePos( m_plot->invTransform( QwtPlot::xBottom, pos.x() ),
m_plot->invTransform( QwtPlot::yLeft, pos.y() ) );
QPointF scalePos( m_plot->invTransform( QwtAxis::XBottom, pos.x() ),
m_plot->invTransform( QwtAxis::YLeft, pos.y() ) );
if ( shapeItem->shape().boundingRect().contains( scalePos ) )
{
*closestItem = *it;
@ -856,8 +854,8 @@ void RiuQwtPlotWidget::findClosestPlotItem( const QPoint& pos,
else if ( ( *it )->rtti() == QwtPlotItem::Rtti_PlotBarChart )
{
QwtPlotBarChart* barChart = static_cast<QwtPlotBarChart*>( *it );
QPointF scalePos( m_plot->invTransform( QwtPlot::xBottom, pos.x() ),
m_plot->invTransform( QwtPlot::yLeft, pos.y() ) );
QPointF scalePos( m_plot->invTransform( QwtAxis::XBottom, pos.x() ),
m_plot->invTransform( QwtAxis::YLeft, pos.y() ) );
bool horizontal = barChart->orientation() == Qt::Horizontal;
for ( size_t i = 0; i < barChart->dataSize(); ++i )
@ -1055,6 +1053,13 @@ QwtPlot* RiuQwtPlotWidget::qwtPlot() const
//--------------------------------------------------------------------------------------------------
void RiuQwtPlotWidget::ensureAxisIsCreated( RiuPlotAxis axis )
{
int requiredCount = axis.index() + 1;
auto qwtAxisId = RiuQwtPlotTools::toQwtPlotAxis( axis );
if ( requiredCount > m_plot->axesCount( qwtAxisId.pos ) )
{
m_plot->setAxesCount( qwtAxisId.pos, requiredCount );
}
}
//--------------------------------------------------------------------------------------------------
@ -1062,7 +1067,9 @@ void RiuQwtPlotWidget::ensureAxisIsCreated( RiuPlotAxis axis )
//--------------------------------------------------------------------------------------------------
void RiuQwtPlotWidget::enableAxis( RiuPlotAxis axis, bool isEnabled )
{
m_plot->enableAxis( RiuQwtPlotTools::toQwtPlotAxis( axis.axis() ), isEnabled );
ensureAxisIsCreated( axis );
m_plot->setAxisVisible( RiuQwtPlotTools::toQwtPlotAxis( axis ), isEnabled );
}
//--------------------------------------------------------------------------------------------------
@ -1070,7 +1077,7 @@ void RiuQwtPlotWidget::enableAxis( RiuPlotAxis axis, bool isEnabled )
//--------------------------------------------------------------------------------------------------
bool RiuQwtPlotWidget::axisEnabled( RiuPlotAxis axis ) const
{
return m_plot->axisEnabled( RiuQwtPlotTools::toQwtPlotAxis( axis.axis() ) );
return m_plot->isAxisVisible( RiuQwtPlotTools::toQwtPlotAxis( axis ) );
}
//--------------------------------------------------------------------------------------------------
@ -1078,7 +1085,7 @@ bool RiuQwtPlotWidget::axisEnabled( RiuPlotAxis axis ) const
//--------------------------------------------------------------------------------------------------
void RiuQwtPlotWidget::setAxisMaxMinor( RiuPlotAxis axis, int maxMinor )
{
m_plot->setAxisMaxMinor( RiuQwtPlotTools::toQwtPlotAxis( axis.axis() ), maxMinor );
m_plot->setAxisMaxMinor( RiuQwtPlotTools::toQwtPlotAxis( axis ), maxMinor );
}
//--------------------------------------------------------------------------------------------------
@ -1086,7 +1093,7 @@ void RiuQwtPlotWidget::setAxisMaxMinor( RiuPlotAxis axis, int maxMinor )
//--------------------------------------------------------------------------------------------------
void RiuQwtPlotWidget::setAxisMaxMajor( RiuPlotAxis axis, int maxMajor )
{
m_plot->setAxisMaxMajor( RiuQwtPlotTools::toQwtPlotAxis( axis.axis() ), maxMajor );
m_plot->setAxisMaxMajor( RiuQwtPlotTools::toQwtPlotAxis( axis ), maxMajor );
}
//--------------------------------------------------------------------------------------------------
@ -1103,7 +1110,7 @@ void RiuQwtPlotWidget::removeEventFilter()
//--------------------------------------------------------------------------------------------------
void RiuQwtPlotWidget::setAxisAutoScale( RiuPlotAxis axis, bool autoScale )
{
m_plot->setAxisAutoScale( RiuQwtPlotTools::toQwtPlotAxis( axis.axis() ), autoScale );
m_plot->setAxisAutoScale( RiuQwtPlotTools::toQwtPlotAxis( axis ), autoScale );
}
//--------------------------------------------------------------------------------------------------
@ -1111,7 +1118,7 @@ void RiuQwtPlotWidget::setAxisAutoScale( RiuPlotAxis axis, bool autoScale )
//--------------------------------------------------------------------------------------------------
void RiuQwtPlotWidget::setAxisScale( RiuPlotAxis axis, double min, double max )
{
m_plot->setAxisScale( RiuQwtPlotTools::toQwtPlotAxis( axis.axis() ), min, max );
m_plot->setAxisScale( RiuQwtPlotTools::toQwtPlotAxis( axis ), min, max );
}
//--------------------------------------------------------------------------------------------------
@ -1119,7 +1126,7 @@ void RiuQwtPlotWidget::setAxisScale( RiuPlotAxis axis, double min, double max )
//--------------------------------------------------------------------------------------------------
RiuQwtPlotWidget::AxisScaleType RiuQwtPlotWidget::axisScaleType( RiuPlotAxis axis ) const
{
QwtPlot::Axis qwtAxis = RiuQwtPlotTools::toQwtPlotAxis( axis.axis() );
auto qwtAxis = RiuQwtPlotTools::toQwtPlotAxis( axis );
QwtLogScaleEngine* logScaleEngine = dynamic_cast<QwtLogScaleEngine*>( m_plot->axisScaleEngine( qwtAxis ) );
QwtDateScaleEngine* dateScaleEngine = dynamic_cast<QwtDateScaleEngine*>( m_plot->axisScaleEngine( qwtAxis ) );
@ -1136,7 +1143,7 @@ RiuQwtPlotWidget::AxisScaleType RiuQwtPlotWidget::axisScaleType( RiuPlotAxis axi
//--------------------------------------------------------------------------------------------------
void RiuQwtPlotWidget::setAxisScaleType( RiuPlotAxis axis, RiuQwtPlotWidget::AxisScaleType axisScaleType )
{
QwtPlot::Axis qwtAxis = RiuQwtPlotTools::toQwtPlotAxis( axis.axis() );
auto qwtAxis = RiuQwtPlotTools::toQwtPlotAxis( axis );
if ( axisScaleType == AxisScaleType::LOGARITHMIC ) m_plot->setAxisScaleEngine( qwtAxis, new QwtLogScaleEngine );
if ( axisScaleType == AxisScaleType::LINEAR ) m_plot->setAxisScaleEngine( qwtAxis, new QwtLinearScaleEngine );
@ -1156,8 +1163,11 @@ void RiuQwtPlotWidget::updateAxes()
//--------------------------------------------------------------------------------------------------
RiuPlotAxis RiuQwtPlotWidget::createNextPlotAxis( RiaDefines::PlotAxis axis )
{
// Qwt does not support multiaxis. Just use the default on the given side.
return RiuPlotAxis( axis );
auto qwtAxis = RiuQwtPlotTools::toQwtPlotAxisEnum( axis );
auto count = m_plot->axesCount( qwtAxis );
return RiuPlotAxis( axis, count );
}
//--------------------------------------------------------------------------------------------------
@ -1190,7 +1200,7 @@ const QColor& RiuQwtPlotWidget::backgroundColor() const
//--------------------------------------------------------------------------------------------------
bool RiuQwtPlotWidget::isMultiAxisSupported() const
{
return false;
return true;
}
//--------------------------------------------------------------------------------------------------

2
ApplicationLibCode/UserInterface/RiuQwtScalePicker.cpp
View File

@ -15,7 +15,7 @@
RiuQwtScalePicker::RiuQwtScalePicker( QwtPlot* plot )
: QObject( plot )
{
for ( uint i = 0; i < QwtPlot::axisCnt; i++ )
for ( uint i = 0; i < QwtAxis::AxisPositions; i++ )
{
QwtScaleWidget* scaleWidget = plot->axisWidget( i );
if ( scaleWidget ) scaleWidget->installEventFilter( this );

49
ApplicationLibCode/UserInterface/RiuRelativePermeabilityPlotPanel.cpp
View File

@ -178,13 +178,11 @@ void RiuRelativePermeabilityPlotPanel::setPlotDefaults( QwtPlot* plot )
plot->setTitle( plotTitle );
}
plot->enableAxis( QwtPlot::xBottom, true );
plot->enableAxis( QwtPlot::yLeft, true );
plot->enableAxis( QwtPlot::xTop, false );
plot->enableAxis( QwtPlot::yRight, false );
plot->setAxesCount( QwtAxis::XBottom, 1 );
plot->setAxesCount( QwtAxis::YLeft, 1 );
plot->setAxisMaxMinor( QwtPlot::xBottom, 2 );
plot->setAxisMaxMinor( QwtPlot::yLeft, 3 );
plot->setAxisMaxMinor( QwtAxis::XBottom, 2 );
plot->setAxisMaxMinor( QwtAxis::YLeft, 3 );
QwtLegend* legend = new QwtLegend( plot );
plot->insertLegend( legend, QwtPlot::BottomLegend );
@ -306,8 +304,8 @@ void RiuRelativePermeabilityPlotPanel::addTransparentCurve( QwtPlot*
curveLeftAxis->setSamples( pointsOnLeftAxis );
curveRightAxis->setSamples( pointsOnRightAxis );
curveLeftAxis->setYAxis( QwtPlot::yLeft );
curveRightAxis->setYAxis( QwtPlot::yRight );
curveLeftAxis->setYAxis( QwtAxis::YLeft );
curveRightAxis->setYAxis( QwtAxis::YRight );
curveLeftAxis->setStyle( QwtPlotCurve::NoCurve );
curveRightAxis->setStyle( QwtPlotCurve::NoCurve );
@ -460,7 +458,10 @@ void RiuRelativePermeabilityPlotPanel::plotCurvesInQwt( RiaDefines::EclipseUnitS
}
}
plot->enableAxis( QwtPlot::yRight, shouldEnableRightYAxis );
if ( shouldEnableRightYAxis )
plot->setAxesCount( QwtAxis::YRight, 1 );
else
plot->setAxesCount( QwtAxis::YRight, 0 );
addTransparentCurve( plot, points, axes, logScaleLeftAxis );
@ -476,44 +477,44 @@ void RiuRelativePermeabilityPlotPanel::plotCurvesInQwt( RiaDefines::EclipseUnitS
if ( logScaleLeftAxis )
{
if ( !dynamic_cast<QwtLogScaleEngine*>( plot->axisScaleEngine( QwtPlot::yLeft ) ) )
if ( !dynamic_cast<QwtLogScaleEngine*>( plot->axisScaleEngine( QwtAxis::YLeft ) ) )
{
plot->setAxisScaleEngine( QwtPlot::yLeft, new QwtLogScaleEngine );
plot->setAxisScaleEngine( QwtAxis::YLeft, new QwtLogScaleEngine );
}
}
else
{
if ( !dynamic_cast<QwtLinearScaleEngine*>( plot->axisScaleEngine( QwtPlot::yLeft ) ) )
if ( !dynamic_cast<QwtLinearScaleEngine*>( plot->axisScaleEngine( QwtAxis::YLeft ) ) )
{
plot->setAxisScaleEngine( QwtPlot::yLeft, new QwtLinearScaleEngine );
plot->setAxisScaleEngine( QwtAxis::YLeft, new QwtLinearScaleEngine );
}
}
if ( fixedXAxis )
{
plot->setAxisScale( QwtPlot::xBottom, 0.0, 1.0 );
plot->setAxisAutoScale( QwtPlot::xBottom, false );
plot->setAxisScale( QwtAxis::XBottom, 0.0, 1.0 );
plot->setAxisAutoScale( QwtAxis::XBottom, false );
}
else
{
plot->setAxisAutoScale( QwtPlot::xBottom, true );
plot->setAxisAutoScale( QwtAxis::XBottom, true );
}
if ( fixedLeftYAxis )
{
if ( logScaleLeftAxis )
{
plot->setAxisScale( QwtPlot::yLeft, 1.0e-6, 1.0 );
plot->setAxisScale( QwtAxis::YLeft, 1.0e-6, 1.0 );
}
else
{
plot->setAxisScale( QwtPlot::yLeft, 0.0, 1.0 );
plot->setAxisScale( QwtAxis::YLeft, 0.0, 1.0 );
}
plot->setAxisAutoScale( QwtPlot::yLeft, false );
plot->setAxisAutoScale( QwtAxis::YLeft, false );
}
else
{
plot->setAxisAutoScale( QwtPlot::yLeft, true );
plot->setAxisAutoScale( QwtAxis::YLeft, true );
}
QString titleStr = "Relative Permeability";
@ -523,9 +524,9 @@ void RiuRelativePermeabilityPlotPanel::plotCurvesInQwt( RiaDefines::EclipseUnitS
}
plot->setTitle( titleStr );
plot->setAxisTitle( QwtPlot::xBottom, determineXAxisTitleFromCurveCollection( curveArr ) );
plot->setAxisTitle( QwtPlot::yLeft, "Kr" );
plot->setAxisTitle( QwtPlot::yRight, QString( "Pc [%1]" ).arg( RiaEclipseUnitTools::unitStringPressure( unitSystem ) ) );
plot->setAxisTitle( QwtAxis::XBottom, determineXAxisTitleFromCurveCollection( curveArr ) );
plot->setAxisTitle( QwtAxis::YLeft, "Kr" );
plot->setAxisTitle( QwtAxis::YRight, QString( "Pc [%1]" ).arg( RiaEclipseUnitTools::unitStringPressure( unitSystem ) ) );
plot->replot();
}
@ -626,7 +627,7 @@ void RiuRelativePermeabilityPlotPanel::addCurveConstSaturationIntersectionMarker
if ( whichYAxis == RIGHT_YAXIS )
{
pointMarker->setYAxis( QwtPlot::yRight );
pointMarker->setYAxis( QwtAxis::YRight );
}
myPlotMarkers->push_back( pointMarker );

12
ApplicationLibCode/UserInterface/RiuResultQwtPlot.cpp
View File

@ -88,7 +88,7 @@ void RiuResultQwtPlot::addCurve( const RimCase* rimCase,
plotCurve->attach( this );
m_plotCurves.push_back( plotCurve );
this->setAxisScale( QwtPlot::xTop, QwtDate::toDouble( dateTimes.front() ), QwtDate::toDouble( dateTimes.back() ) );
this->setAxisScale( QwtAxis::XTop, QwtDate::toDouble( dateTimes.front() ), QwtDate::toDouble( dateTimes.back() ) );
this->applyFontSizes( false );
this->replot();
@ -185,18 +185,16 @@ void RiuResultQwtPlot::setDefaults()
{
RiuQwtPlotTools::setCommonPlotBehaviour( this );
enableAxis( QwtPlot::xBottom, true );
enableAxis( QwtPlot::yLeft, true );
enableAxis( QwtPlot::xTop, false );
enableAxis( QwtPlot::yRight, false );
setAxesCount( QwtAxis::XBottom, 1 );
setAxesCount( QwtAxis::YLeft, 1 );
QString dateFormat = RiaPreferences::current()->dateFormat();
QString timeFormat = RiaPreferences::current()->timeFormat();
RiuQwtPlotTools::enableDateBasedBottomXAxis( this, dateFormat, timeFormat );
setAxisMaxMinor( QwtPlot::xBottom, 2 );
setAxisMaxMinor( QwtPlot::yLeft, 3 );
setAxisMaxMinor( QwtAxis::XBottom, 2 );
setAxisMaxMinor( QwtAxis::YLeft, 3 );
applyFontSizes( false );

6
ApplicationLibCode/UserInterface/RiuSummaryQwtPlot.cpp
View File

@ -87,7 +87,7 @@ RiuSummaryQwtPlot::RiuSummaryQwtPlot( RimSummaryPlot* plot, QWidget* parent /*=
// Attach a zoomer for the right axis
m_zoomerRight = new RiuQwtPlotZoomer( m_plotWidget->qwtPlot()->canvas() );
m_zoomerRight->setAxes( QwtPlot::xTop, QwtPlot::yRight );
m_zoomerRight->setAxes( QwtAxis::XTop, QwtAxis::YRight );
m_zoomerRight->setTrackerMode( QwtPicker::AlwaysOff );
m_zoomerRight->initMousePattern( 1 );
@ -138,8 +138,8 @@ void RiuSummaryQwtPlot::useDateBasedTimeAxis( const QString& d
//--------------------------------------------------------------------------------------------------
void RiuSummaryQwtPlot::useTimeBasedTimeAxis()
{
m_plotWidget->qwtPlot()->setAxisScaleEngine( QwtPlot::xBottom, new QwtLinearScaleEngine() );
m_plotWidget->qwtPlot()->setAxisScaleDraw( QwtPlot::xBottom, new QwtScaleDraw() );
m_plotWidget->qwtPlot()->setAxisScaleEngine( QwtAxis::XBottom, new QwtLinearScaleEngine() );
m_plotWidget->qwtPlot()->setAxisScaleDraw( QwtAxis::XBottom, new QwtScaleDraw() );
}
//--------------------------------------------------------------------------------------------------

36
ApplicationLibCode/UserInterface/RiuTofAccumulatedPhaseFractionsPlot.cpp
View File

@ -192,7 +192,7 @@ void RiuTofAccumulatedPhaseFractionsPlot::setSamples( std::vector<double> xSampl
{
maxVal = std::max( val, maxVal );
}
setAxisScale( QwtPlot::xBottom, 0, maxVal );
setAxisScale( QwtAxis::XBottom, 0, maxVal );
updateAxes();
}
replot();
@ -204,16 +204,14 @@ void RiuTofAccumulatedPhaseFractionsPlot::setSamples( std::vector<double> xSampl
void RiuTofAccumulatedPhaseFractionsPlot::setDefaults()
{
setCommonPlotBehaviour( this );
setAxisTitle( QwtPlot::xBottom, "Years" );
setAxisTitle( QwtAxis::XBottom, "Years" );
enableAxis( QwtPlot::xBottom, true );
enableAxis( QwtPlot::yLeft, true );
setAxisScale( QwtPlot::yLeft, 0, 1, 0.2 );
enableAxis( QwtPlot::xTop, false );
enableAxis( QwtPlot::yRight, false );
setAxesCount( QwtAxis::XBottom, 1 );
setAxesCount( QwtAxis::YLeft, 1 );
setAxisScale( QwtAxis::YLeft, 0, 1, 0.2 );
setAxisMaxMinor( QwtPlot::xBottom, 2 );
setAxisMaxMinor( QwtPlot::yLeft, 3 );
setAxisMaxMinor( QwtAxis::XBottom, 2 );
setAxisMaxMinor( QwtAxis::YLeft, 3 );
QSizePolicy sizePolicy( QSizePolicy::Preferred, QSizePolicy::Preferred );
sizePolicy.setHeightForWidth( true );
@ -255,26 +253,26 @@ void RiuTofAccumulatedPhaseFractionsPlot::setCommonPlotBehaviour( QwtPlot* plot
grid->setPen( gridPen );
// Axis number font
QFont axisFont = plot->axisFont( QwtPlot::xBottom );
QFont axisFont = plot->axisFont( QwtAxis::XBottom );
axisFont.setPointSize( 10 );
plot->setAxisFont( QwtPlot::xBottom, axisFont );
plot->setAxisFont( QwtPlot::xTop, axisFont );
plot->setAxisFont( QwtPlot::yLeft, axisFont );
plot->setAxisFont( QwtPlot::yRight, axisFont );
plot->setAxisFont( QwtAxis::XBottom, axisFont );
plot->setAxisFont( QwtAxis::XTop, axisFont );
plot->setAxisFont( QwtAxis::YLeft, axisFont );
plot->setAxisFont( QwtAxis::YRight, axisFont );
// Axis title font
QwtText axisTitle = plot->axisTitle( QwtPlot::xBottom );
QwtText axisTitle = plot->axisTitle( QwtAxis::XBottom );
QFont axisTitleFont = axisTitle.font();
axisTitleFont.setPointSize( 10 );
axisTitleFont.setBold( false );
axisTitle.setFont( axisTitleFont );
axisTitle.setRenderFlags( Qt::AlignRight );
plot->setAxisTitle( QwtPlot::xBottom, axisTitle );
plot->setAxisTitle( QwtPlot::xTop, axisTitle );
plot->setAxisTitle( QwtPlot::yLeft, axisTitle );
plot->setAxisTitle( QwtPlot::yRight, axisTitle );
plot->setAxisTitle( QwtAxis::XBottom, axisTitle );
plot->setAxisTitle( QwtAxis::XTop, axisTitle );
plot->setAxisTitle( QwtAxis::YLeft, axisTitle );
plot->setAxisTitle( QwtAxis::YRight, axisTitle );
// Enable mouse tracking and event filter

14
ApplicationLibCode/UserInterface/RiuWellLogTrack.cpp
View File

@ -58,8 +58,8 @@ protected:
if ( m_plot )
{
QwtPlot::Axis relatedYAxis = QwtPlot::yLeft;
QwtPlot::Axis relatedXAxis = QwtPlot::xTop;
QwtAxis::Position relatedYAxis = QwtAxis::YLeft;
QwtAxis::Position relatedXAxis = QwtAxis::XTop;
QString curveInfoText;
QString depthAxisValueString;
@ -135,10 +135,10 @@ static WellLogCurveInfoTextProvider wellLogCurveInfoTextProvider;
RiuWellLogTrack::RiuWellLogTrack( RimWellLogTrack* track, QWidget* parent /*= nullptr */ )
: RiuQwtPlotWidget( track, parent )
{
setAxisEnabled( QwtPlot::yLeft, true );
setAxisEnabled( QwtPlot::yRight, false );
setAxisEnabled( QwtPlot::xTop, true );
setAxisEnabled( QwtPlot::xBottom, true );
setAxisEnabled( QwtAxis::YLeft, true );
setAxisEnabled( QwtAxis::YRight, false );
setAxisEnabled( QwtAxis::XTop, true );
setAxisEnabled( QwtAxis::XBottom, true );
new RiuWellLogCurvePointTracker( this->qwtPlot(), &wellLogCurveInfoTextProvider, track );
}
@ -153,7 +153,7 @@ RiuWellLogTrack::~RiuWellLogTrack()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuWellLogTrack::setAxisEnabled( QwtPlot::Axis axis, bool enabled )
void RiuWellLogTrack::setAxisEnabled( QwtAxis::Position axis, bool enabled )
{
RiuPlotAxis plotAxis = RiuPlotAxis( RiuQwtPlotTools::fromQwtPlotAxis( axis ) );
RiuQwtPlotWidget::enableAxis( plotAxis, enabled );

2
ApplicationLibCode/UserInterface/RiuWellLogTrack.h
View File

@ -38,5 +38,5 @@ public:
RiuWellLogTrack( RimWellLogTrack* track, QWidget* parent = nullptr );
~RiuWellLogTrack() override;
void setAxisEnabled( QwtPlot::Axis axis, bool enabled );
void setAxisEnabled( QwtAxis::Position axis, bool enabled );
};

2
ThirdParty/qwt vendored

@ -1 +1 @@
Subproject commit b207fdae66a346cb36c78acefaff1ae6d93416c9
Subproject commit d948bfa23d4b628ccff5f5039b9e70515f8a3db9