QgsFeatureRenderer* QgsFeatureRenderer::loadSld( const QDomNode &node, QgsWkbTypes::GeometryType geomType, QString &errorMessage )
{
QDomElement element = node.toElement();
if ( element.isNull() )
return nullptr;
// get the UserStyle element
QDomElement userStyleElem = element.firstChildElement( "UserStyle" );
if ( userStyleElem.isNull() )
{
// UserStyle element not found, nothing will be rendered
errorMessage = "Info: UserStyle element not found.";
return nullptr;
}
// get the FeatureTypeStyle element
QDomElement featTypeStyleElem = userStyleElem.firstChildElement( "FeatureTypeStyle" );
if ( featTypeStyleElem.isNull() )
{
errorMessage = "Info: FeatureTypeStyle element not found.";
return nullptr;
}
// use the RuleRenderer when more rules are present or the rule
// has filters or min/max scale denominators set,
// otherwise use the SingleSymbol renderer
bool needRuleRenderer = false;
int ruleCount = 0;
QDomElement ruleElem = featTypeStyleElem.firstChildElement( "Rule" );
while ( !ruleElem.isNull() )
{
ruleCount++;
// more rules present, use the RuleRenderer
if ( ruleCount > 1 )
{
QgsDebugMsg( "more Rule elements found: need a RuleRenderer" );
needRuleRenderer = true;
break;
}
QDomElement ruleChildElem = ruleElem.firstChildElement();
while ( !ruleChildElem.isNull() )
{
// rule has filter or min/max scale denominator, use the RuleRenderer
if ( ruleChildElem.localName() == "Filter" ||
ruleChildElem.localName() == "MinScaleDenominator" ||
ruleChildElem.localName() == "MaxScaleDenominator" )
{
QgsDebugMsg( "Filter or Min/MaxScaleDenominator element found: need a RuleRenderer" );
needRuleRenderer = true;
break;
}
ruleChildElem = ruleChildElem.nextSiblingElement();
}
if ( needRuleRenderer )
{
break;
}
ruleElem = ruleElem.nextSiblingElement( "Rule" );
}
QString rendererType;
if ( needRuleRenderer )
{
rendererType = "RuleRenderer";
}
else
{
rendererType = "singleSymbol";
}
QgsDebugMsg( QString( "Instantiating a '%1' renderer..." ).arg( rendererType ) );
// create the renderer and return it
QgsRendererAbstractMetadata* m = QgsRendererRegistry::instance()->rendererMetadata( rendererType );
if ( !m )
{
errorMessage = QString( "Error: Unable to get metadata for '%1' renderer." ).arg( rendererType );
return nullptr;
}
QgsFeatureRenderer* r = m->createRendererFromSld( featTypeStyleElem, geomType );
return r;
}
void QgsPointDisplacementRendererWidget::on_mRendererSettingsButton_clicked()
{
if ( !mRenderer )
return;
QgsRendererAbstractMetadata* m = QgsRendererRegistry::instance()->rendererMetadata( mRenderer->embeddedRenderer()->type() );
if ( m )
{
QgsRendererWidget* w = m->createRendererWidget( mLayer, mStyle, mRenderer->embeddedRenderer()->clone() );
w->setPanelTitle( tr( "Renderer settings" ) );
QgsSymbolWidgetContext context = mContext;
QgsExpressionContextScope scope;
scope.addVariable( QgsExpressionContextScope::StaticVariable( QgsExpressionContext::EXPR_CLUSTER_COLOR, "", true ) );
scope.addVariable( QgsExpressionContextScope::StaticVariable( QgsExpressionContext::EXPR_CLUSTER_SIZE, 0, true ) );
QList< QgsExpressionContextScope > scopes = context.additionalExpressionContextScopes();
scopes << scope;
context.setAdditionalExpressionContextScopes( scopes );
w->setContext( context );
connect( w, SIGNAL( widgetChanged() ), this, SLOT( updateRendererFromWidget() ) );
openPanel( w );
}
}
QgsFeatureRenderer* QgsFeatureRenderer::load( QDomElement& element )
{
// <renderer-v2 type=""> ... </renderer-v2>
if ( element.isNull() )
return nullptr;
// load renderer
QString rendererType = element.attribute( "type" );
QgsRendererAbstractMetadata* m = QgsRendererRegistry::instance()->rendererMetadata( rendererType );
if ( !m )
return nullptr;
QgsFeatureRenderer* r = m->createRenderer( element );
if ( r )
{
r->setUsingSymbolLevels( element.attribute( "symbollevels", "0" ).toInt() );
r->setForceRasterRender( element.attribute( "forceraster", "0" ).toInt() );
//restore layer effect
QDomElement effectElem = element.firstChildElement( "effect" );
if ( !effectElem.isNull() )
{
r->setPaintEffect( QgsPaintEffectRegistry::instance()->createEffect( effectElem ) );
}
// restore order by
QDomElement orderByElem = element.firstChildElement( "orderby" );
r->mOrderBy.load( orderByElem );
r->setOrderByEnabled( element.attribute( "enableorderby", "0" ).toInt() );
}
return r;
}
QgsFeatureRenderer *QgsGrassEditRenderer::create( QDomElement &element, const QgsReadWriteContext &context )
{
QgsGrassEditRenderer *renderer = new QgsGrassEditRenderer();
QDomElement childElem = element.firstChildElement();
while ( !childElem.isNull() )
{
QDomElement elem = childElem.firstChildElement();
if ( !elem.isNull() )
{
QString rendererType = elem.attribute( QStringLiteral( "type" ) );
QgsDebugMsg( "childElem.tagName() = " + childElem.tagName() + " rendererType = " + rendererType );
QgsRendererAbstractMetadata *meta = QgsApplication::rendererRegistry()->rendererMetadata( rendererType );
if ( meta )
{
QgsFeatureRenderer *subRenderer = meta->createRenderer( elem, context );
if ( subRenderer )
{
QgsDebugMsg( "renderer created : " + renderer->type() );
if ( childElem.tagName() == QLatin1String( "line" ) )
{
renderer->setLineRenderer( subRenderer );
}
else if ( childElem.tagName() == QLatin1String( "marker" ) )
{
renderer->setMarkerRenderer( subRenderer );
}
}
}
}
childElem = childElem.nextSiblingElement();
}
return renderer;
}
void QgsLayerStylingWidget::apply()
{
if ( !mCurrentLayer )
return;
disconnect( mCurrentLayer, SIGNAL( styleChanged() ), this, SLOT( updateCurrentWidgetLayer() ) );
QString undoName = "Style Change";
QWidget* current = mWidgetStack->mainWidget();
bool styleWasChanged = false;
if ( QgsLabelingWidget* widget = qobject_cast<QgsLabelingWidget*>( current ) )
{
widget->apply();
styleWasChanged = true;
undoName = "Label Change";
}
if ( QgsPanelWidgetWrapper* wrapper = qobject_cast<QgsPanelWidgetWrapper*>( current ) )
{
if ( QgsRendererPropertiesDialog* widget = qobject_cast<QgsRendererPropertiesDialog*>( wrapper->widget() ) )
{
widget->apply();
QgsVectorLayer* layer = qobject_cast<QgsVectorLayer*>( mCurrentLayer );
QgsRendererAbstractMetadata* m = QgsRendererRegistry::instance()->rendererMetadata( layer->renderer()->type() );
undoName = QString( "Style Change - %1" ).arg( m->visibleName() );
styleWasChanged = true;
}
}
else if ( QgsRasterTransparencyWidget* widget = qobject_cast<QgsRasterTransparencyWidget*>( current ) )
{
widget->apply();
styleWasChanged = true;
}
else if ( qobject_cast<QgsRasterHistogramWidget*>( current ) )
{
mRasterStyleWidget->apply();
styleWasChanged = true;
}
else if ( QgsMapLayerConfigWidget* widget = qobject_cast<QgsMapLayerConfigWidget*>( current ) )
{
widget->apply();
styleWasChanged = true;
}
pushUndoItem( undoName );
if ( styleWasChanged )
{
emit styleChanged( mCurrentLayer );
QgsProject::instance()->setDirty( true );
mMapCanvas->clearCache();
mMapCanvas->refresh();
}
connect( mCurrentLayer, SIGNAL( styleChanged() ), this, SLOT( updateCurrentWidgetLayer() ) );
}
QStringList QgsRendererRegistry::renderersList( QgsRendererAbstractMetadata::LayerTypes layerTypes ) const
{
QStringList renderers;
const auto constMRenderersOrder = mRenderersOrder;
for ( const QString &renderer : constMRenderersOrder )
{
QgsRendererAbstractMetadata *r = mRenderers.value( renderer );
if ( r && r->compatibleLayerTypes() & layerTypes )
renderers << renderer;
}
return renderers;
}
void QgsPointDisplacementRendererWidget::on_mRendererComboBox_currentIndexChanged( int index )
{
QString rendererId = mRendererComboBox->itemData( index ).toString();
QgsRendererAbstractMetadata* m = QgsRendererRegistry::instance()->rendererMetadata( rendererId );
if ( m )
{
// unfortunately renderer conversion is only available through the creation of a widget...
QgsRendererWidget* tempRenderWidget = m->createRendererWidget( mLayer, mStyle, mRenderer->embeddedRenderer()->clone() );
mRenderer->setEmbeddedRenderer( tempRenderWidget->renderer()->clone() );
delete tempRenderWidget;
emit widgetChanged();
}
}
void QgsInvertedPolygonRendererWidget::on_mRendererComboBox_currentIndexChanged( int index )
{
QString rendererId = mRendererComboBox->itemData( index ).toString();
QgsRendererAbstractMetadata* m = QgsApplication::rendererRegistry()->rendererMetadata( rendererId );
if ( m )
{
mEmbeddedRendererWidget.reset( m->createRendererWidget( mLayer, mStyle, const_cast<QgsFeatureRenderer*>( mRenderer->embeddedRenderer() )->clone() ) );
connect( mEmbeddedRendererWidget.data(), SIGNAL( widgetChanged() ), this, SIGNAL( widgetChanged() ) );
mEmbeddedRendererWidget->setContext( mContext );
if ( layout()->count() > 2 )
{
// remove the current renderer widget
layout()->takeAt( 2 );
}
layout()->addWidget( mEmbeddedRendererWidget.data() );
}
}
void QgsPointClusterRendererWidget::mRendererSettingsButton_clicked()
{
if ( !mRenderer )
return;
QgsRendererAbstractMetadata *m = QgsApplication::rendererRegistry()->rendererMetadata( mRenderer->embeddedRenderer()->type() );
if ( m )
{
QgsRendererWidget *w = m->createRendererWidget( mLayer, mStyle, mRenderer->embeddedRenderer()->clone() );
w->setPanelTitle( tr( "Renderer Settings" ) );
QgsExpressionContextScope scope;
scope.addVariable( QgsExpressionContextScope::StaticVariable( QgsExpressionContext::EXPR_CLUSTER_COLOR, "", true ) );
scope.addVariable( QgsExpressionContextScope::StaticVariable( QgsExpressionContext::EXPR_CLUSTER_SIZE, 0, true ) );
QList< QgsExpressionContextScope > scopes = mContext.additionalExpressionContextScopes();
scopes << scope;
QgsSymbolWidgetContext context = mContext;
context.setAdditionalExpressionContextScopes( scopes );
w->setContext( context );
connect( w, &QgsPanelWidget::widgetChanged, this, &QgsPointClusterRendererWidget::updateRendererFromWidget );
w->setDockMode( this->dockMode() );
openPanel( w );
}
}
QgsInvertedPolygonRendererWidget::QgsInvertedPolygonRendererWidget( QgsVectorLayer* layer, QgsStyle* style, QgsFeatureRenderer* renderer )
: QgsRendererWidget( layer, style )
{
if ( !layer )
{
return;
}
QgsWkbTypes::Type type = QgsWkbTypes::singleType( QgsWkbTypes::flatType( layer->wkbType() ) );
// the renderer only applies to polygon vector layers
if ( type != QgsWkbTypes::Polygon && type != QgsWkbTypes::CurvePolygon )
{
//setup blank dialog
mRenderer.reset( nullptr );
QGridLayout* layout = new QGridLayout( this );
QLabel* label = new QLabel( tr( "The inverted polygon renderer only applies to polygon and multipolygon layers. \n"
"'%1' is not a polygon layer and then cannot be displayed" )
.arg( layer->name() ), this );
this->setLayout( layout );
layout->addWidget( label );
return;
}
setupUi( this );
// try to recognize the previous renderer
// (null renderer means "no previous renderer")
if ( renderer )
{
mRenderer.reset( QgsInvertedPolygonRenderer::convertFromRenderer( renderer ) );
}
if ( ! mRenderer )
{
mRenderer.reset( new QgsInvertedPolygonRenderer() );
}
mMergePolygonsCheckBox->blockSignals( true );
mMergePolygonsCheckBox->setCheckState( mRenderer->preprocessingEnabled() ? Qt::Checked : Qt::Unchecked );
mMergePolygonsCheckBox->blockSignals( false );
int currentEmbeddedIdx = 0;
//insert possible renderer types
QStringList rendererList = QgsApplication::rendererRegistry()->renderersList( QgsRendererAbstractMetadata::PolygonLayer );
QStringList::const_iterator it = rendererList.constBegin();
int idx = 0;
mRendererComboBox->blockSignals( true );
for ( ; it != rendererList.constEnd(); ++it, ++idx )
{
if ( *it != QLatin1String( "invertedPolygonRenderer" ) ) //< an inverted renderer cannot contain another inverted renderer
{
QgsRendererAbstractMetadata* m = QgsApplication::rendererRegistry()->rendererMetadata( *it );
mRendererComboBox->addItem( m->icon(), m->visibleName(), /* data */ *it );
const QgsFeatureRenderer* embeddedRenderer = mRenderer->embeddedRenderer();
if ( embeddedRenderer && embeddedRenderer->type() == m->name() )
{
// store the combo box index of the current renderer
currentEmbeddedIdx = idx;
}
}
}
mRendererComboBox->blockSignals( false );
int oldIdx = mRendererComboBox->currentIndex();
mRendererComboBox->setCurrentIndex( currentEmbeddedIdx );
if ( oldIdx == currentEmbeddedIdx )
{
// force update
on_mRendererComboBox_currentIndexChanged( currentEmbeddedIdx );
}
}
QgsPointDisplacementRendererWidget::QgsPointDisplacementRendererWidget( QgsVectorLayer* layer, QgsStyle* style, QgsFeatureRenderer* renderer )
: QgsRendererWidget( layer, style )
, mRenderer( nullptr )
{
if ( !layer )
{
return;
}
//the renderer only applies to point vector layers
if ( layer->wkbType() != QgsWkbTypes::Point && layer->wkbType() != QgsWkbTypes::Point25D )
{
//setup blank dialog
mRenderer = nullptr;
setupBlankUi( layer->name() );
return;
}
setupUi( this );
mDistanceUnitWidget->setUnits( QgsUnitTypes::RenderUnitList() << QgsUnitTypes::RenderMillimeters << QgsUnitTypes::RenderMapUnits << QgsUnitTypes::RenderPixels );
if ( renderer )
{
mRenderer = QgsPointDisplacementRenderer::convertFromRenderer( renderer );
}
if ( !mRenderer )
{
mRenderer = new QgsPointDisplacementRenderer();
}
blockAllSignals( true );
mPlacementComboBox->addItem( tr( "Ring" ), QgsPointDisplacementRenderer::Ring );
mPlacementComboBox->addItem( tr( "Concentric rings" ), QgsPointDisplacementRenderer::ConcentricRings );
//insert attributes into combo box
if ( layer )
{
Q_FOREACH ( const QgsField& f, layer->fields() )
{
mLabelFieldComboBox->addItem( f.name() );
}
mLabelFieldComboBox->addItem( tr( "None" ) );
QString currentLabelAttribute = mRenderer->labelAttributeName();
if ( !currentLabelAttribute.isEmpty() )
{
mLabelFieldComboBox->setCurrentIndex( mLabelFieldComboBox->findText( currentLabelAttribute ) );
}
else
{
mLabelFieldComboBox->setCurrentIndex( mLabelFieldComboBox->findText( tr( "None" ) ) );
}
}
//insert possible renderer types
QStringList rendererList = QgsRendererRegistry::instance()->renderersList( QgsRendererAbstractMetadata::PointLayer );
QStringList::const_iterator it = rendererList.constBegin();
for ( ; it != rendererList.constEnd(); ++it )
{
if ( *it != QLatin1String( "pointDisplacement" ) && *it != QLatin1String( "pointCluster" ) && *it != QLatin1String( "heatmapRenderer" ) )
{
QgsRendererAbstractMetadata* m = QgsRendererRegistry::instance()->rendererMetadata( *it );
mRendererComboBox->addItem( m->icon(), m->visibleName(), *it );
}
}
mCircleColorButton->setColorDialogTitle( tr( "Select color" ) );
mCircleColorButton->setContext( QStringLiteral( "symbology" ) );
mCircleColorButton->setAllowAlpha( true );
mCircleColorButton->setShowNoColor( true );
mCircleColorButton->setNoColorString( tr( "No outline" ) );
mLabelColorButton->setContext( QStringLiteral( "symbology" ) );
mLabelColorButton->setColorDialogTitle( tr( "Select color" ) );
mLabelColorButton->setAllowAlpha( true );
mCircleWidthSpinBox->setValue( mRenderer->circleWidth() );
mCircleColorButton->setColor( mRenderer->circleColor() );
mLabelColorButton->setColor( mRenderer->labelColor() );
mCircleModificationSpinBox->setClearValue( 0.0 );
mCircleModificationSpinBox->setValue( mRenderer->circleRadiusAddition() );
mDistanceSpinBox->setValue( mRenderer->tolerance() );
mDistanceUnitWidget->setUnit( mRenderer->toleranceUnit() );
mDistanceUnitWidget->setMapUnitScale( mRenderer->toleranceMapUnitScale() );
mPlacementComboBox->setCurrentIndex( mPlacementComboBox->findData( mRenderer->placement() ) );
//scale dependent labeling
mMaxScaleDenominatorEdit->setText( QString::number( mRenderer->maxLabelScaleDenominator() ) );
mMaxScaleDenominatorEdit->setValidator( new QDoubleValidator( mMaxScaleDenominatorEdit ) );
if ( mRenderer->maxLabelScaleDenominator() > 0 )
{
mScaleDependentLabelsCheckBox->setCheckState( Qt::Checked );
}
else
{
mScaleDependentLabelsCheckBox->setCheckState( Qt::Unchecked );
mMaxScaleDenominatorEdit->setEnabled( false );
}
blockAllSignals( false );
//set the appropriate renderer dialog
if ( mRenderer->embeddedRenderer() )
{
QString rendererName = mRenderer->embeddedRenderer()->type();
int rendererIndex = mRendererComboBox->findData( rendererName );
if ( rendererIndex != -1 )
{
mRendererComboBox->setCurrentIndex( rendererIndex );
on_mRendererComboBox_currentIndexChanged( rendererIndex );
}
}
updateCenterIcon();
}
QgsPointClusterRendererWidget::QgsPointClusterRendererWidget( QgsVectorLayer *layer, QgsStyle *style, QgsFeatureRenderer *renderer )
: QgsRendererWidget( layer, style )
{
if ( !layer )
{
return;
}
//the renderer only applies to point vector layers
if ( QgsWkbTypes::flatType( layer->wkbType() ) != QgsWkbTypes::Point )
{
//setup blank dialog
mRenderer = nullptr;
setupBlankUi( layer->name() );
return;
}
setupUi( this );
connect( mRendererComboBox, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, &QgsPointClusterRendererWidget::mRendererComboBox_currentIndexChanged );
connect( mDistanceSpinBox, static_cast < void ( QDoubleSpinBox::* )( double ) > ( &QDoubleSpinBox::valueChanged ), this, &QgsPointClusterRendererWidget::mDistanceSpinBox_valueChanged );
connect( mDistanceUnitWidget, &QgsUnitSelectionWidget::changed, this, &QgsPointClusterRendererWidget::mDistanceUnitWidget_changed );
connect( mRendererSettingsButton, &QPushButton::clicked, this, &QgsPointClusterRendererWidget::mRendererSettingsButton_clicked );
this->layout()->setContentsMargins( 0, 0, 0, 0 );
mDistanceUnitWidget->setUnits( QgsUnitTypes::RenderUnitList() << QgsUnitTypes::RenderMillimeters << QgsUnitTypes::RenderMapUnits << QgsUnitTypes::RenderPixels
<< QgsUnitTypes::RenderPoints << QgsUnitTypes::RenderInches );
mCenterSymbolToolButton->setSymbolType( QgsSymbol::Marker );
if ( renderer )
{
mRenderer = QgsPointClusterRenderer::convertFromRenderer( renderer );
}
if ( !mRenderer )
{
mRenderer = new QgsPointClusterRenderer();
}
blockAllSignals( true );
//insert possible renderer types
QStringList rendererList = QgsApplication::rendererRegistry()->renderersList( QgsRendererAbstractMetadata::PointLayer );
QStringList::const_iterator it = rendererList.constBegin();
for ( ; it != rendererList.constEnd(); ++it )
{
if ( *it != QLatin1String( "pointDisplacement" ) && *it != QLatin1String( "pointCluster" ) && *it != QLatin1String( "heatmapRenderer" ) )
{
QgsRendererAbstractMetadata *m = QgsApplication::rendererRegistry()->rendererMetadata( *it );
mRendererComboBox->addItem( m->icon(), m->visibleName(), *it );
}
}
mDistanceSpinBox->setValue( mRenderer->tolerance() );
mDistanceUnitWidget->setUnit( mRenderer->toleranceUnit() );
mDistanceUnitWidget->setMapUnitScale( mRenderer->toleranceMapUnitScale() );
mCenterSymbolToolButton->setSymbol( mRenderer->clusterSymbol()->clone() );
blockAllSignals( false );
//set the appropriate renderer dialog
if ( mRenderer->embeddedRenderer() )
{
QString rendererName = mRenderer->embeddedRenderer()->type();
int rendererIndex = mRendererComboBox->findData( rendererName );
if ( rendererIndex != -1 )
{
mRendererComboBox->setCurrentIndex( rendererIndex );
mRendererComboBox_currentIndexChanged( rendererIndex );
}
}
connect( mCenterSymbolToolButton, &QgsSymbolButton::changed, this, &QgsPointClusterRendererWidget::centerSymbolChanged );
mCenterSymbolToolButton->setDialogTitle( tr( "Cluster symbol" ) );
mCenterSymbolToolButton->setLayer( mLayer );
mCenterSymbolToolButton->registerExpressionContextGenerator( this );
}
QgsPointDisplacementRendererWidget::QgsPointDisplacementRendererWidget( QgsVectorLayer *layer, QgsStyle *style, QgsFeatureRenderer *renderer )
: QgsRendererWidget( layer, style )
{
if ( !layer )
{
return;
}
//the renderer only applies to point vector layers
if ( layer->wkbType() != QgsWkbTypes::Point && layer->wkbType() != QgsWkbTypes::Point25D )
{
//setup blank dialog
mRenderer = nullptr;
setupBlankUi( layer->name() );
return;
}
setupUi( this );
connect( mLabelFieldComboBox, static_cast<void ( QComboBox::* )( const QString & )>( &QComboBox::currentIndexChanged ), this, &QgsPointDisplacementRendererWidget::mLabelFieldComboBox_currentIndexChanged );
connect( mRendererComboBox, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, &QgsPointDisplacementRendererWidget::mRendererComboBox_currentIndexChanged );
connect( mPlacementComboBox, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, &QgsPointDisplacementRendererWidget::mPlacementComboBox_currentIndexChanged );
connect( mCircleWidthSpinBox, static_cast < void ( QDoubleSpinBox::* )( double ) > ( &QDoubleSpinBox::valueChanged ), this, &QgsPointDisplacementRendererWidget::mCircleWidthSpinBox_valueChanged );
connect( mCircleColorButton, &QgsColorButton::colorChanged, this, &QgsPointDisplacementRendererWidget::mCircleColorButton_colorChanged );
connect( mDistanceSpinBox, static_cast < void ( QDoubleSpinBox::* )( double ) > ( &QDoubleSpinBox::valueChanged ), this, &QgsPointDisplacementRendererWidget::mDistanceSpinBox_valueChanged );
connect( mDistanceUnitWidget, &QgsUnitSelectionWidget::changed, this, &QgsPointDisplacementRendererWidget::mDistanceUnitWidget_changed );
connect( mLabelColorButton, &QgsColorButton::colorChanged, this, &QgsPointDisplacementRendererWidget::mLabelColorButton_colorChanged );
connect( mCircleModificationSpinBox, static_cast < void ( QDoubleSpinBox::* )( double ) > ( &QDoubleSpinBox::valueChanged ), this, &QgsPointDisplacementRendererWidget::mCircleModificationSpinBox_valueChanged );
connect( mScaleDependentLabelsCheckBox, &QCheckBox::stateChanged, this, &QgsPointDisplacementRendererWidget::mScaleDependentLabelsCheckBox_stateChanged );
connect( mRendererSettingsButton, &QPushButton::clicked, this, &QgsPointDisplacementRendererWidget::mRendererSettingsButton_clicked );
this->layout()->setContentsMargins( 0, 0, 0, 0 );
mLabelFontButton->setMode( QgsFontButton::ModeQFont );
mDistanceUnitWidget->setUnits( QgsUnitTypes::RenderUnitList() << QgsUnitTypes::RenderMillimeters << QgsUnitTypes::RenderMetersInMapUnits << QgsUnitTypes::RenderMapUnits << QgsUnitTypes::RenderPixels
<< QgsUnitTypes::RenderPoints << QgsUnitTypes::RenderInches );
mCenterSymbolToolButton->setSymbolType( QgsSymbol::Marker );
if ( renderer )
{
mRenderer = QgsPointDisplacementRenderer::convertFromRenderer( renderer );
}
if ( !mRenderer )
{
mRenderer = new QgsPointDisplacementRenderer();
}
blockAllSignals( true );
mPlacementComboBox->addItem( tr( "Ring" ), QgsPointDisplacementRenderer::Ring );
mPlacementComboBox->addItem( tr( "Concentric rings" ), QgsPointDisplacementRenderer::ConcentricRings );
mPlacementComboBox->addItem( tr( "Grid" ), QgsPointDisplacementRenderer::Grid );
//insert attributes into combo box
if ( layer )
{
const QgsFields layerFields = layer->fields();
for ( const QgsField &f : layerFields )
{
mLabelFieldComboBox->addItem( f.name() );
}
mLabelFieldComboBox->addItem( tr( "None" ) );
QString currentLabelAttribute = mRenderer->labelAttributeName();
if ( !currentLabelAttribute.isEmpty() )
{
mLabelFieldComboBox->setCurrentIndex( mLabelFieldComboBox->findText( currentLabelAttribute ) );
}
else
{
mLabelFieldComboBox->setCurrentIndex( mLabelFieldComboBox->findText( tr( "None" ) ) );
}
}
//insert possible renderer types
QStringList rendererList = QgsApplication::rendererRegistry()->renderersList( QgsRendererAbstractMetadata::PointLayer );
QStringList::const_iterator it = rendererList.constBegin();
for ( ; it != rendererList.constEnd(); ++it )
{
if ( *it != QLatin1String( "pointDisplacement" ) && *it != QLatin1String( "pointCluster" ) && *it != QLatin1String( "heatmapRenderer" ) )
{
QgsRendererAbstractMetadata *m = QgsApplication::rendererRegistry()->rendererMetadata( *it );
mRendererComboBox->addItem( m->icon(), m->visibleName(), *it );
}
}
mCircleColorButton->setColorDialogTitle( tr( "Select Color" ) );
mCircleColorButton->setContext( QStringLiteral( "symbology" ) );
mCircleColorButton->setAllowOpacity( true );
mCircleColorButton->setShowNoColor( true );
mCircleColorButton->setNoColorString( tr( "No stroke" ) );
mLabelColorButton->setContext( QStringLiteral( "symbology" ) );
mLabelColorButton->setColorDialogTitle( tr( "Select Color" ) );
mLabelColorButton->setAllowOpacity( true );
mCircleWidthSpinBox->setValue( mRenderer->circleWidth() );
mCircleColorButton->setColor( mRenderer->circleColor() );
mLabelColorButton->setColor( mRenderer->labelColor() );
mLabelFontButton->setCurrentFont( mRenderer->labelFont() );
mCircleModificationSpinBox->setClearValue( 0.0 );
mCircleModificationSpinBox->setValue( mRenderer->circleRadiusAddition() );
mDistanceSpinBox->setValue( mRenderer->tolerance() );
mDistanceUnitWidget->setUnit( mRenderer->toleranceUnit() );
mDistanceUnitWidget->setMapUnitScale( mRenderer->toleranceMapUnitScale() );
mCenterSymbolToolButton->setSymbol( mRenderer->centerSymbol()->clone() );
mPlacementComboBox->setCurrentIndex( mPlacementComboBox->findData( mRenderer->placement() ) );
//scale dependent labeling
mMinLabelScaleWidget->setScale( std::max( mRenderer->minimumLabelScale(), 0.0 ) );
if ( mRenderer->minimumLabelScale() > 0 )
{
mScaleDependentLabelsCheckBox->setCheckState( Qt::Checked );
}
else
{
mScaleDependentLabelsCheckBox->setCheckState( Qt::Unchecked );
mMinLabelScaleWidget->setEnabled( false );
}
blockAllSignals( false );
//set the appropriate renderer dialog
if ( mRenderer->embeddedRenderer() )
{
QString rendererName = mRenderer->embeddedRenderer()->type();
int rendererIndex = mRendererComboBox->findData( rendererName );
if ( rendererIndex != -1 )
{
mRendererComboBox->setCurrentIndex( rendererIndex );
mRendererComboBox_currentIndexChanged( rendererIndex );
}
}
connect( mMinLabelScaleWidget, &QgsScaleWidget::scaleChanged, this, &QgsPointDisplacementRendererWidget::minLabelScaleChanged );
connect( mLabelFontButton, &QgsFontButton::changed, this, &QgsPointDisplacementRendererWidget::labelFontChanged );
connect( mCenterSymbolToolButton, &QgsSymbolButton::changed, this, &QgsPointDisplacementRendererWidget::centerSymbolChanged );
mCenterSymbolToolButton->setDialogTitle( tr( "Center symbol" ) );
mCenterSymbolToolButton->setLayer( mLayer );
mCenterSymbolToolButton->registerExpressionContextGenerator( this );
}
