QgsMapCanvasRendererSync::QgsMapCanvasRendererSync( QgsMapCanvas* canvas, QgsMapRenderer* renderer )
: QObject( canvas )
, mCanvas( canvas )
, mRenderer( renderer )
, mSyncingExtent( false )
{
connect( mCanvas, SIGNAL( extentsChanged() ), this, SLOT( onExtentC2R() ) );
connect( mRenderer, SIGNAL( extentsChanged() ), this, SLOT( onExtentR2C() ) );
connect( mCanvas, SIGNAL( mapUnitsChanged() ), this, SLOT( onMapUnitsC2R() ) );
connect( mRenderer, SIGNAL( mapUnitsChanged() ), this, SLOT( onMapUnitsR2C() ) );
connect( mCanvas, SIGNAL( rotationChanged( double ) ), this, SLOT( onMapRotationC2R() ) );
connect( mRenderer, SIGNAL( rotationChanged( double ) ), this, SLOT( onMapRotationR2C() ) );
connect( mCanvas, SIGNAL( hasCrsTransformEnabledChanged( bool ) ), this, SLOT( onCrsTransformC2R() ) );
connect( mRenderer, SIGNAL( hasCrsTransformEnabled( bool ) ), this, SLOT( onCrsTransformR2C() ) );
connect( mCanvas, SIGNAL( destinationCrsChanged() ), this, SLOT( onDestCrsC2R() ) );
connect( mRenderer, SIGNAL( destinationSrsChanged() ), this, SLOT( onDestCrsR2C() ) );
connect( mCanvas, SIGNAL( layersChanged() ), this, SLOT( onLayersC2R() ) );
// TODO: layers R2C ? (should not happen!)
}
void QgsStatusBarCoordinatesWidget::setMapCanvas( QgsMapCanvas *mapCanvas )
{
if ( mMapCanvas )
{
disconnect( mMapCanvas, SIGNAL( xyCoordinates( const QgsPoint & ) ), this, SLOT( showMouseCoordinates( const QgsPoint & ) ) );
disconnect( mMapCanvas, SIGNAL( extentsChanged() ), this, SLOT( showExtent() ) );
}
mMapCanvas = mapCanvas;
connect( mMapCanvas, SIGNAL( xyCoordinates( const QgsPoint & ) ), this, SLOT( showMouseCoordinates( const QgsPoint & ) ) );
connect( mMapCanvas, SIGNAL( extentsChanged() ), this, SLOT( showExtent() ) );
}
void QgsSelectedFeature::setSelectedFeature( QgsFeatureId featureId, QgsVectorLayer* vlayer, QgsMapCanvas* canvas )
{
mFeatureId = featureId;
mVlayer = vlayer;
mCanvas = canvas;
delete mRubberBand;
mRubberBand = 0;
delete mGeometry;
mGeometry = 0;
// signal changing of current layer
connect( QgisApp::instance()->legend(), SIGNAL( currentLayerChanged( QgsMapLayer* ) ), this, SLOT( currentLayerChanged( QgsMapLayer* ) ) );
// feature was deleted
connect( mVlayer, SIGNAL( featureDeleted( QgsFeatureId ) ), this, SLOT( featureDeleted( QgsFeatureId ) ) );
// projection or extents changed
connect( canvas->mapRenderer(), SIGNAL( destinationSrsChanged() ), this, SLOT( updateVertexMarkersPosition() ) );
connect( canvas, SIGNAL( extentsChanged() ), this, SLOT( updateVertexMarkersPosition() ) );
// geometry was changed
connect( mVlayer, SIGNAL( geometryChanged( QgsFeatureId, QgsGeometry & ) ), this, SLOT( geometryChanged( QgsFeatureId, QgsGeometry & ) ) );
replaceVertexMap();
}
void QgsAttributeTableDialog::on_mZoomMapToSelectedRowsButton_clicked()
{
QSettings settings;
bool canvasFeatures = settings.value( "/qgis/attributeTableBehaviour", 0 ).toInt() == 2;
if ( canvasFeatures )
{
disconnect( QgisApp::instance()->mapCanvas(), SIGNAL( extentsChanged() ), mModel, SLOT( layerModified() ) );
}
QgisApp::instance()->mapCanvas()->zoomToSelected( mLayer );
if ( canvasFeatures )
{
connect( QgisApp::instance()->mapCanvas(), SIGNAL( extentsChanged() ), mModel, SLOT( layerModified() ) );
}
}
void QgsSelectedFeature::setSelectedFeature( QgsFeatureId featureId, QgsVectorLayer* vlayer, QgsMapCanvas* canvas )
{
mFeatureId = featureId;
mVlayer = vlayer;
mCanvas = canvas;
delete mGeometry;
mGeometry = nullptr;
// signal changing of current layer
connect( QgisApp::instance()->layerTreeView(), SIGNAL( currentLayerChanged( QgsMapLayer* ) ), this, SLOT( currentLayerChanged( QgsMapLayer* ) ) );
// feature was deleted
connect( mVlayer, SIGNAL( featureDeleted( QgsFeatureId ) ), this, SLOT( featureDeleted( QgsFeatureId ) ) );
// rolling back
connect( mVlayer, SIGNAL( beforeRollBack() ), this, SLOT( beforeRollBack() ) );
// projection or extents changed
connect( canvas, SIGNAL( destinationCrsChanged() ), this, SLOT( updateVertexMarkersPosition() ) );
connect( canvas, SIGNAL( extentsChanged() ), this, SLOT( updateVertexMarkersPosition() ) );
// geometry was changed
connect( mVlayer, SIGNAL( geometryChanged( QgsFeatureId, QgsGeometry & ) ), this, SLOT( geometryChanged( QgsFeatureId, QgsGeometry & ) ) );
replaceVertexMap();
}
void QgsAttributeTableFilterModel::setFilterMode( FilterMode filterMode )
{
if ( filterMode != mFilterMode )
{
if ( filterMode == ShowVisible )
{
connect( mCanvas, SIGNAL( extentsChanged() ), SLOT( extentsChanged() ) );
generateListOfVisibleFeatures();
}
else
{
disconnect( SLOT( extentsChanged() ) );
}
mFilterMode = filterMode;
announcedInvalidateFilter();
}
}
void QgsMapCanvas::setExtent( QgsRectangle const & r )
{
QgsRectangle current = extent();
if ( r == current )
return;
if ( r.isEmpty() )
{
if ( !mSettings.hasValidSettings() )
{
// we can't even just move the map center
QgsDebugMsg( "Empty extent - ignoring" );
return;
}
// ### QGIS 3: do not allow empty extent - require users to call setCenter() explicitly
QgsDebugMsg( "Empty extent - keeping old scale with new center!" );
setCenter( r.center() );
}
else
{
mSettings.setExtent( r );
}
emit extentsChanged();
updateScale();
if ( mLastExtent.size() > 20 )
mLastExtent.removeAt( 0 );
//clear all extent items after current index
for ( int i = mLastExtent.size() - 1; i > mLastExtentIndex; i-- )
{
mLastExtent.removeAt( i );
}
mLastExtent.append( extent() );
// adjust history to no more than 20
if ( mLastExtent.size() > 20 )
{
mLastExtent.removeAt( 0 );
}
// the last item is the current extent
mLastExtentIndex = mLastExtent.size() - 1;
// update controls' enabled state
emit zoomLastStatusChanged( mLastExtentIndex > 0 );
emit zoomNextStatusChanged( mLastExtentIndex < mLastExtent.size() - 1 );
// notify canvas items of change
updateCanvasItemPositions();
} // setExtent
QgsMapOverviewCanvas::QgsMapOverviewCanvas( QWidget * parent, QgsMapCanvas* mapCanvas )
: QWidget( parent )
, mMapCanvas( mapCanvas )
, mJob( 0 )
{
setObjectName( "theOverviewCanvas" );
mPanningWidget = new QgsPanningWidget( this );
mSettings.setFlag( QgsMapSettings::DrawLabeling, false );
connect( mMapCanvas, SIGNAL( extentsChanged() ), this, SLOT( drawExtentRect() ) );
}
QgsMapCanvasSnappingUtils::QgsMapCanvasSnappingUtils( QgsMapCanvas* canvas, QObject* parent )
: QgsSnappingUtils( parent )
, mCanvas( canvas )
, mProgress( nullptr )
{
connect( canvas, SIGNAL( extentsChanged() ), this, SLOT( canvasMapSettingsChanged() ) );
connect( canvas, SIGNAL( destinationCrsChanged() ), this, SLOT( canvasMapSettingsChanged() ) );
connect( canvas, SIGNAL( layersChanged() ), this, SLOT( canvasMapSettingsChanged() ) );
connect( canvas, SIGNAL( currentLayerChanged( QgsMapLayer* ) ), this, SLOT( canvasCurrentLayerChanged() ) );
canvasMapSettingsChanged();
canvasCurrentLayerChanged();
}
void QgsMapCanvas::zoomToNextExtent()
{
if ( mLastExtentIndex < mLastExtent.size() - 1 )
{
mLastExtentIndex++;
mSettings.setExtent( mLastExtent[mLastExtentIndex] );
emit extentsChanged();
updateScale();
refresh();
// update controls' enabled state
emit zoomLastStatusChanged( mLastExtentIndex > 0 );
emit zoomNextStatusChanged( mLastExtentIndex < mLastExtent.size() - 1 );
// notify canvas items of change
updateCanvasItemPositions();
}
}// zoomToNextExtent
void QgsMapCanvas::setRotation( double degrees )
{
if ( !rotationEnabled() )
return;
double current = rotation();
if ( degrees == current )
return;
mSettings.setRotation( degrees );
emit rotationChanged( degrees );
emit extentsChanged(); // visible extent changes with rotation
// notify canvas items of change (needed?)
updateCanvasItemPositions();
} // setRotation
QgsMapCanvasTracer::QgsMapCanvasTracer( QgsMapCanvas* canvas, QgsMessageBar* messageBar )
: mCanvas( canvas )
, mMessageBar( messageBar )
, mLastMessage( nullptr )
, mActionEnableTracing( nullptr )
{
sTracers.insert( canvas, this );
// when things change we just invalidate the graph - and set up new parameters again only when necessary
connect( canvas, SIGNAL( destinationCrsChanged() ), this, SLOT( invalidateGraph() ) );
connect( canvas, SIGNAL( layersChanged() ), this, SLOT( invalidateGraph() ) );
connect( canvas, SIGNAL( extentsChanged() ), this, SLOT( invalidateGraph() ) );
connect( canvas, SIGNAL( currentLayerChanged( QgsMapLayer* ) ), this, SLOT( onCurrentLayerChanged() ) );
connect( canvas->snappingUtils(), SIGNAL( configChanged() ), this, SLOT( invalidateGraph() ) );
// arbitrarily chosen limit that should allow for fairly fast initialization
// of the underlying graph structure
setMaxFeatureCount( QSettings().value( "/qgis/digitizing/tracing_max_feature_count", 10000 ).toInt() );
}
bool QgsMapRenderer::setExtent( const QgsRectangle& extent )
{
//remember the previous extent
mLastExtent = mExtent;
// Don't allow zooms where the current extent is so small that it
// can't be accurately represented using a double (which is what
// currentExtent uses). Excluding 0 avoids a divide by zero and an
// infinite loop when rendering to a new canvas. Excluding extents
// greater than 1 avoids doing unnecessary calculations.
// The scheme is to compare the width against the mean x coordinate
// (and height against mean y coordinate) and only allow zooms where
// the ratio indicates that there is more than about 12 significant
// figures (there are about 16 significant figures in a double).
if ( extent.width() > 0 &&
extent.height() > 0 &&
extent.width() < 1 &&
extent.height() < 1 )
{
// Use abs() on the extent to avoid the case where the extent is
// symmetrical about 0.
double xMean = ( qAbs( extent.xMinimum() ) + qAbs( extent.xMaximum() ) ) * 0.5;
double yMean = ( qAbs( extent.yMinimum() ) + qAbs( extent.yMaximum() ) ) * 0.5;
double xRange = extent.width() / xMean;
double yRange = extent.height() / yMean;
static const double minProportion = 1e-12;
if ( xRange < minProportion || yRange < minProportion )
return false;
}
mExtent = extent;
if ( !extent.isEmpty() )
adjustExtentToSize();
emit extentsChanged();
return true;
}
void QgsMapCanvas::resizeEvent( QResizeEvent * e )
{
QGraphicsView::resizeEvent( e );
mResizeTimer->start( 500 );
QSize lastSize = viewport()->size();
mSettings.setOutputSize( lastSize );
mMapRenderer->setOutputSize( lastSize, mSettings.outputDpi() );
mScene->setSceneRect( QRectF( 0, 0, lastSize.width(), lastSize.height() ) );
moveCanvasContents( true );
// notify canvas items of change
updateCanvasItemPositions();
updateScale();
//refresh();
emit extentsChanged();
}
QgsAttributeTableDialog::QgsAttributeTableDialog( QgsVectorLayer *theLayer, QWidget *parent, Qt::WindowFlags flags )
: QDialog( parent, flags ), mDock( NULL )
{
mLayer = theLayer;
setupUi( this );
setAttribute( Qt::WA_DeleteOnClose );
QSettings settings;
restoreGeometry( settings.value( "/Windows/BetterAttributeTable/geometry" ).toByteArray() );
mView->setLayer( mLayer );
mFilterModel = ( QgsAttributeTableFilterModel * ) mView->model();
mModel = ( QgsAttributeTableModel * )(( QgsAttributeTableFilterModel * )mView->model() )->sourceModel();
mQuery = query;
mColumnBox = columnBox;
columnBoxInit();
bool myDockFlag = settings.value( "/qgis/dockAttributeTable", false ).toBool();
if ( myDockFlag )
{
mDock = new QgsAttributeTableDock( tr( "Attribute table - %1 (%n Feature(s))", "feature count", mModel->rowCount() ).arg( mLayer->name() ), QgisApp::instance() );
mDock->setAllowedAreas( Qt::BottomDockWidgetArea | Qt::TopDockWidgetArea );
mDock->setWidget( this );
connect( this, SIGNAL( destroyed() ), mDock, SLOT( close() ) );
QgisApp::instance()->addDockWidget( Qt::BottomDockWidgetArea, mDock );
}
updateTitle();
mRemoveSelectionButton->setIcon( QgisApp::getThemeIcon( "/mActionUnselectAttributes.png" ) );
mSelectedToTopButton->setIcon( QgisApp::getThemeIcon( "/mActionSelectedToTop.png" ) );
mCopySelectedRowsButton->setIcon( QgisApp::getThemeIcon( "/mActionCopySelected.png" ) );
mZoomMapToSelectedRowsButton->setIcon( QgisApp::getThemeIcon( "/mActionZoomToSelected.png" ) );
mInvertSelectionButton->setIcon( QgisApp::getThemeIcon( "/mActionInvertSelection.png" ) );
mToggleEditingButton->setIcon( QgisApp::getThemeIcon( "/mActionToggleEditing.png" ) );
mSaveEditsButton->setIcon( QgisApp::getThemeIcon( "/mActionSaveEdits.png" ) );
mDeleteSelectedButton->setIcon( QgisApp::getThemeIcon( "/mActionDeleteSelected.png" ) );
mOpenFieldCalculator->setIcon( QgisApp::getThemeIcon( "/mActionCalculateField.png" ) );
mAddAttribute->setIcon( QgisApp::getThemeIcon( "/mActionNewAttribute.png" ) );
mRemoveAttribute->setIcon( QgisApp::getThemeIcon( "/mActionDeleteAttribute.png" ) );
// toggle editing
bool canChangeAttributes = mLayer->dataProvider()->capabilities() & QgsVectorDataProvider::ChangeAttributeValues;
bool canDeleteFeatures = mLayer->dataProvider()->capabilities() & QgsVectorDataProvider::DeleteFeatures;
bool canAddAttributes = mLayer->dataProvider()->capabilities() & QgsVectorDataProvider::AddAttributes;
bool canDeleteAttributes = mLayer->dataProvider()->capabilities() & QgsVectorDataProvider::DeleteAttributes;
bool canAddFeatures = mLayer->dataProvider()->capabilities() & QgsVectorDataProvider::AddFeatures;
mToggleEditingButton->setCheckable( true );
mToggleEditingButton->setChecked( mLayer->isEditable() );
mToggleEditingButton->setEnabled( canChangeAttributes && !mLayer->isReadOnly() );
mSaveEditsButton->setEnabled( canChangeAttributes && mLayer->isEditable() );
mOpenFieldCalculator->setEnabled( canChangeAttributes && mLayer->isEditable() );
mDeleteSelectedButton->setEnabled( canDeleteFeatures && mLayer->isEditable() );
mAddAttribute->setEnabled( canAddAttributes && mLayer->isEditable() );
mRemoveAttribute->setEnabled( canDeleteAttributes && mLayer->isEditable() );
mAddFeature->setEnabled( canAddFeatures && mLayer->isEditable() && mLayer->geometryType() == QGis::NoGeometry );
mAddFeature->setHidden( !canAddFeatures || mLayer->geometryType() != QGis::NoGeometry );
// info from table to application
connect( this, SIGNAL( editingToggled( QgsMapLayer * ) ), QgisApp::instance(), SLOT( toggleEditing( QgsMapLayer * ) ) );
connect( this, SIGNAL( saveEdits( QgsMapLayer * ) ), QgisApp::instance(), SLOT( saveEdits( QgsMapLayer * ) ) );
// info from layer to table
connect( mLayer, SIGNAL( editingStarted() ), this, SLOT( editingToggled() ) );
connect( mLayer, SIGNAL( editingStopped() ), this, SLOT( editingToggled() ) );
connect( searchButton, SIGNAL( clicked() ), this, SLOT( search() ) );
connect( mAddFeature, SIGNAL( clicked() ), this, SLOT( addFeature() ) );
connect( mLayer, SIGNAL( selectionChanged() ), this, SLOT( updateSelectionFromLayer() ) );
connect( mLayer, SIGNAL( layerDeleted() ), this, SLOT( close() ) );
connect( mView->verticalHeader(), SIGNAL( sectionClicked( int ) ), this, SLOT( updateRowSelection( int ) ) );
connect( mView->verticalHeader(), SIGNAL( sectionPressed( int ) ), this, SLOT( updateRowPressed( int ) ) );
connect( mModel, SIGNAL( modelChanged() ), this, SLOT( updateSelection() ) );
if ( settings.value( "/qgis/attributeTableBehaviour", 0 ).toInt() == 2 )
{
connect( QgisApp::instance()->mapCanvas(), SIGNAL( extentsChanged() ), mModel, SLOT( layerModified() ) );
}
mLastClickedHeaderIndex = 0;
mSelectionModel = new QItemSelectionModel( mFilterModel );
updateSelectionFromLayer();
//make sure to show all recs on first load
on_cbxShowSelectedOnly_toggled( false );
}
RgShortestPathWidget::RgShortestPathWidget( QWidget* theParent, RoadGraphPlugin *thePlugin ) : QDockWidget( theParent ), mPlugin( thePlugin )
{
setWindowTitle( tr( "Shortest path" ) );
setObjectName( "ShortestPathDock" );
setAllowedAreas( Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea );
QWidget *myWidget = new QWidget( this );
setWidget( myWidget );
QVBoxLayout *v = new QVBoxLayout( myWidget );
QHBoxLayout *h = NULL;
QLabel *l = NULL;
l = new QLabel( tr( "Start" ), myWidget );
v->addWidget( l );
h = new QHBoxLayout();
mFrontPointLineEdit = new QLineEdit( myWidget );
mFrontPointLineEdit->setReadOnly( true );
QToolButton *selectFrontPoint = new QToolButton( myWidget );
selectFrontPoint->setCheckable( true );
selectFrontPoint->setIcon( QPixmap( ":/roadgraph/coordinate_capture.png" ) );
h->addWidget( mFrontPointLineEdit );
h->addWidget( selectFrontPoint );
v->addLayout( h );
l = new QLabel( tr( "Stop" ), myWidget );
v->addWidget( l );
h = new QHBoxLayout();
mBackPointLineEdit = new QLineEdit( myWidget );
mBackPointLineEdit->setReadOnly( true );
QToolButton *selectBackPoint = new QToolButton( myWidget );
selectBackPoint->setCheckable( true );
selectBackPoint->setIcon( QPixmap( ":/roadgraph/coordinate_capture.png" ) );
h->addWidget( mBackPointLineEdit );
h->addWidget( selectBackPoint );
v->addLayout( h );
h = new QHBoxLayout();
l = new QLabel( tr( "Criterion" ), myWidget );
mCriterionName = new QComboBox( myWidget );
mCriterionName->insertItem( 0, tr( "Length" ) );
mCriterionName->insertItem( 1, tr( "Time" ) );
h->addWidget( l );
h->addWidget( mCriterionName );
v->addLayout( h );
h = new QHBoxLayout();
l = new QLabel( tr( "Length" ), myWidget );
mPathCostLineEdit = new QLineEdit( myWidget );
mPathCostLineEdit->setReadOnly( true );
h->addWidget( l );
h->addWidget( mPathCostLineEdit );
v->addLayout( h );
h = new QHBoxLayout();
l = new QLabel( tr( "Time" ), myWidget );
mPathTimeLineEdit = new QLineEdit( myWidget );
mPathTimeLineEdit->setReadOnly( true );
h->addWidget( l );
h->addWidget( mPathTimeLineEdit );
v->addLayout( h );
h = new QHBoxLayout();
mCalculate = new QPushButton( tr( "Calculate" ), myWidget );
h->addWidget( mCalculate );
QPushButton *pbExport = new QPushButton( tr( "Export" ), myWidget );
h->addWidget( pbExport );
connect( pbExport, SIGNAL( clicked( bool ) ), this, SLOT( exportPath() ) );
mClear = new QPushButton( tr( "Clear" ), myWidget );
h->addWidget( mClear );
v->addLayout( h );
h = new QHBoxLayout();
QPushButton *helpButton = new QPushButton( tr( "Help" ), this );
helpButton->setIcon( style()->standardIcon( QStyle::SP_DialogHelpButton ) );
h->addWidget( helpButton );
v->addLayout( h );
v->addStretch();
mFrontPointMapTool = new QgsMapToolEmitPoint( mPlugin->iface()->mapCanvas() );
mFrontPointMapTool->setButton( selectFrontPoint );
mBackPointMapTool = new QgsMapToolEmitPoint( mPlugin->iface()->mapCanvas() );
mBackPointMapTool->setButton( selectBackPoint );
connect( selectFrontPoint, SIGNAL( clicked( bool ) ), this, SLOT( onSelectFrontPoint() ) );
connect( mFrontPointMapTool, SIGNAL( canvasClicked( const QgsPoint&, Qt::MouseButton ) ),
this, SLOT( setFrontPoint( const QgsPoint& ) ) );
connect( selectBackPoint, SIGNAL( clicked( bool ) ), this, SLOT( onSelectBackPoint() ) );
connect( mBackPointMapTool, SIGNAL( canvasClicked( const QgsPoint&, Qt::MouseButton ) ),
this, SLOT( setBackPoint( const QgsPoint& ) ) );
connect( helpButton, SIGNAL( clicked( bool ) ), this, SLOT( helpRequested() ) );
connect( mCalculate, SIGNAL( clicked( bool ) ), this, SLOT( findingPath() ) );
connect( mClear, SIGNAL( clicked( bool ) ), this, SLOT( clear() ) );
mrbFrontPoint = new QgsRubberBand( mPlugin->iface()->mapCanvas(), true );
mrbFrontPoint->setColor( Qt::green );
mrbFrontPoint->setWidth( 2 );
mrbBackPoint = new QgsRubberBand( mPlugin->iface()->mapCanvas(), true );
mrbBackPoint->setColor( Qt::red );
mrbBackPoint->setWidth( 2 );
mrbPath = new QgsRubberBand( mPlugin->iface()->mapCanvas(), false );
mrbPath->setWidth( 2 );
connect( mPlugin->iface()->mapCanvas(), SIGNAL( extentsChanged() ), this, SLOT( mapCanvasExtentsChanged() ) );
} //RgShortestPathWidget::RgShortestPathWidget()
void PlotItem::paint (QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget*)
{
const auto& rect = option->rect;
#else
void PlotItem::paint (QPainter *painter)
{
const auto& rect = contentsBoundingRect ().toRect ();
#endif
QwtPlot plot;
plot.setFrameShape (QFrame::NoFrame);
plot.enableAxis (QwtPlot::yLeft, LeftAxisEnabled_);
plot.enableAxis (QwtPlot::xBottom, BottomAxisEnabled_);
plot.setAxisTitle (QwtPlot::yLeft, LeftAxisTitle_);
plot.setAxisTitle (QwtPlot::xBottom, BottomAxisTitle_);
plot.resize (rect.size ());
auto setPaletteColor = [&plot] (const QColor& color, QPalette::ColorRole role) -> void
{
if (!color.isValid ())
return;
auto pal = plot.palette ();
pal.setColor (role, { color });
plot.setPalette (pal);
};
setPaletteColor (BackgroundColor_, QPalette::Window);
setPaletteColor (TextColor_, QPalette::WindowText);
setPaletteColor (TextColor_, QPalette::Text);
if (!PlotTitle_.isEmpty ())
plot.setTitle (QwtText { PlotTitle_ });
if (MinYValue_ < MaxYValue_)
{
plot.setAxisAutoScale (QwtPlot::yLeft, false);
plot.setAxisScale (QwtPlot::yLeft, MinYValue_, MaxYValue_);
}
plot.setAutoFillBackground (false);
plot.setCanvasBackground (Qt::transparent);
if (YGridEnabled_)
{
auto grid = new QwtPlotGrid;
grid->enableYMin (YMinorGridEnabled_);
grid->enableX (false);
#if QWT_VERSION >= 0x060100
grid->setMajorPen (QPen (GridLinesColor_, 1, Qt::SolidLine));
grid->setMinorPen (QPen (GridLinesColor_, 1, Qt::DashLine));
#else
grid->setMajPen (QPen (GridLinesColor_, 1, Qt::SolidLine));
grid->setMinPen (QPen (GridLinesColor_, 1, Qt::DashLine));
#endif
grid->attach (&plot);
}
auto items = Multipoints_;
if (items.isEmpty ())
items.push_back ({ Color_, Points_ });
if (MinXValue_ < MaxXValue_)
plot.setAxisScale (QwtPlot::xBottom, MinXValue_, MaxXValue_);
else if (const auto ptsCount = items.first ().Points_.size ())
plot.setAxisScale (QwtPlot::xBottom, 0, ptsCount - 1);
std::vector<std::unique_ptr<QwtPlotCurve>> curves;
for (const auto& item : items)
{
curves.emplace_back (new QwtPlotCurve);
const auto curve = curves.back ().get ();
curve->setPen (QPen (item.Color_));
auto transpColor = item.Color_;
transpColor.setAlphaF (Alpha_);
curve->setBrush (transpColor);
curve->setRenderHint (QwtPlotItem::RenderAntialiased);
curve->attach (&plot);
curve->setSamples (item.Points_.toVector ());
}
plot.replot ();
QwtPlotRenderer {}.render (&plot, painter, rect);
const auto xExtent = CalcXExtent (plot);
const auto yExtent = CalcYExtent (plot);
if (xExtent != XExtent_ || yExtent != YExtent_)
{
XExtent_ = xExtent;
YExtent_ = yExtent;
emit extentsChanged ();
}
}
