QGIS API Documentation 3.27.0-Master (f261cc1f8b)
qgsinterpolatedlinesymbollayerwidget.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsinterpolatedlinesymbollayerwidget.cpp - QgsInterpolatedLineSymbolLayerWidget
3
4 ---------------------
5 begin : 23.3.2021
6 copyright : (C) 2021 by Vincent Cloarec
7 email : vcloarec at gmail dot com
8 ***************************************************************************
9 * *
10 * This program is free software; you can redistribute it and/or modify *
11 * it under the terms of the GNU General Public License as published by *
12 * the Free Software Foundation; either version 2 of the License, or *
13 * (at your option) any later version. *
14 * *
15 ***************************************************************************/
17
18#include "qgsvectorlayer.h"
20#include "qgsproject.h"
22#include "qgsmapcanvas.h"
23#include "qgsdoublevalidator.h"
24
25
27 : QgsSymbolLayerWidget( parent, layer )
28{
29 setupUi( this );
30
31 mWidthMethodComboBox->addItem( tr( "Fixed Width" ), false );
32 mWidthMethodComboBox->addItem( tr( "Varying Width" ), true );
33 mColorMethodComboBox->addItem( tr( "Single Color" ), QgsInterpolatedLineColor::SingleColor );
34 mColorMethodComboBox->addItem( tr( "Varying Color" ), QgsInterpolatedLineColor::ColorRamp );
35
36 mWidthStartFieldExpression->setFilters( QgsFieldProxyModel::Numeric );
37 mWidthEndFieldExpression->setFilters( QgsFieldProxyModel::Numeric );
38 mColorStartFieldExpression->setFilters( QgsFieldProxyModel::Numeric );
39 mColorEndFieldExpression->setFilters( QgsFieldProxyModel::Numeric );
40
41 mWidthStartFieldExpression->setLayer( layer );
42 mWidthEndFieldExpression->setLayer( layer );
43 mColorStartFieldExpression->setLayer( layer );
44 mColorEndFieldExpression->setLayer( layer );
45
46 mWidthUnitSelectionFixed->setUnits( QgsUnitTypes::RenderUnitList()
47 << QgsUnitTypes::RenderUnit::RenderInches
48 << QgsUnitTypes::RenderUnit::RenderMapUnits
49 << QgsUnitTypes::RenderUnit::RenderMetersInMapUnits
50 << QgsUnitTypes::RenderUnit::RenderMillimeters
51 << QgsUnitTypes::RenderUnit::RenderPixels
52 << QgsUnitTypes::RenderUnit::RenderPoints );
53
54 mWidthUnitSelectionVarying->setUnits( QgsUnitTypes::RenderUnitList()
55 << QgsUnitTypes::RenderUnit::RenderInches
56 << QgsUnitTypes::RenderUnit::RenderMapUnits
57 << QgsUnitTypes::RenderUnit::RenderMetersInMapUnits
58 << QgsUnitTypes::RenderUnit::RenderMillimeters
59 << QgsUnitTypes::RenderUnit::RenderPixels
60 << QgsUnitTypes::RenderUnit::RenderPoints );
61
62 connect( mWidthMethodComboBox, qOverload<int>( &QComboBox::currentIndexChanged ),
63 this, &QgsInterpolatedLineSymbolLayerWidget::updateVisibleWidget );
64 connect( mColorMethodComboBox, qOverload<int>( &QComboBox::currentIndexChanged ),
65 this, &QgsInterpolatedLineSymbolLayerWidget::updateVisibleWidget );
66
67 // Width parameter
68 connect( mWidthMethodComboBox, qOverload<int>( &QComboBox::currentIndexChanged ),
69 this, &QgsInterpolatedLineSymbolLayerWidget::apply );
70 connect( mDoubleSpinBoxWidth, qOverload<double>( &QDoubleSpinBox::valueChanged ),
71 this, &QgsInterpolatedLineSymbolLayerWidget::apply );
72 connect( mWidthStartFieldExpression, static_cast < void ( QgsFieldExpressionWidget::* )( const QString & ) >( &QgsFieldExpressionWidget::fieldChanged )
73 , this, &QgsInterpolatedLineSymbolLayerWidget::reloadMinMaxWidthFromLayer );
74 connect( mWidthEndFieldExpression, static_cast < void ( QgsFieldExpressionWidget::* )( const QString & ) >( &QgsFieldExpressionWidget::fieldChanged )
75 , this, &QgsInterpolatedLineSymbolLayerWidget::reloadMinMaxWidthFromLayer );
76 connect( mButtonLoadMinMaxValueWidth, &QPushButton::clicked, this, &QgsInterpolatedLineSymbolLayerWidget::onReloadMinMaxValueWidth );
77 connect( mLineEditWidthMinValue, &QLineEdit::textChanged, this, &QgsInterpolatedLineSymbolLayerWidget::apply );
78 connect( mLineEditWidthMaxValue, &QLineEdit::textChanged, this, &QgsInterpolatedLineSymbolLayerWidget::apply );
79 connect( mDoubleSpinBoxMinWidth, qOverload<double>( &QDoubleSpinBox::valueChanged ),
80 this, &QgsInterpolatedLineSymbolLayerWidget::apply );
81 connect( mDoubleSpinBoxMaxWidth, qOverload<double>( &QDoubleSpinBox::valueChanged ),
82 this, &QgsInterpolatedLineSymbolLayerWidget::apply );
83 connect( mWidthUnitSelectionFixed, &QgsUnitSelectionWidget::changed, this, &QgsInterpolatedLineSymbolLayerWidget::apply );
84 connect( mWidthUnitSelectionVarying, &QgsUnitSelectionWidget::changed, this, &QgsInterpolatedLineSymbolLayerWidget::apply );
85
86 connect( mWidthUnitSelectionVarying, &QgsUnitSelectionWidget::changed, this, [this]
87 {
88 whileBlocking( mWidthUnitSelectionFixed )->setUnit( mWidthUnitSelectionVarying->unit() );
89 } );
90
91 connect( mWidthUnitSelectionFixed, &QgsUnitSelectionWidget::changed, this, [this]
92 {
93 whileBlocking( mWidthUnitSelectionVarying )->setUnit( mWidthUnitSelectionFixed->unit() );
94 } );
95
96 connect( mCheckBoxAbsoluteValue, &QCheckBox::clicked, this, &QgsInterpolatedLineSymbolLayerWidget::apply );
97 connect( mCheckBoxOutOfrange, &QCheckBox::clicked, this, &QgsInterpolatedLineSymbolLayerWidget::apply );
98
99 // Color parameter
100 connect( mColorMethodComboBox, qOverload<int>( &QComboBox::currentIndexChanged ),
101 this, &QgsInterpolatedLineSymbolLayerWidget::apply );
102 connect( mColorRampShaderWidget, &QgsColorRampShaderWidget::widgetChanged, this, &QgsInterpolatedLineSymbolLayerWidget::apply );
103 connect( mColorButton, &QgsColorButton::colorChanged, this, &QgsInterpolatedLineSymbolLayerWidget::apply );
104
105 connect( mColorStartFieldExpression, static_cast < void ( QgsFieldExpressionWidget::* )( const QString & ) >( &QgsFieldExpressionWidget::fieldChanged )
106 , this, &QgsInterpolatedLineSymbolLayerWidget::reloadMinMaxColorFromLayer );
107 connect( mColorEndFieldExpression, static_cast < void ( QgsFieldExpressionWidget::* )( const QString & ) >( &QgsFieldExpressionWidget::fieldChanged )
108 , this, &QgsInterpolatedLineSymbolLayerWidget::reloadMinMaxColorFromLayer );
109
110 connect( mLineEditColorMinValue, &QLineEdit::textChanged, this, &QgsInterpolatedLineSymbolLayerWidget::onColorMinMaxLineTextChanged );
111 connect( mLineEditColorMinValue, &QLineEdit::textEdited, this, &QgsInterpolatedLineSymbolLayerWidget::onColorMinMaxLineTextEdited );
112 connect( mLineEditColorMaxValue, &QLineEdit::textChanged, this, &QgsInterpolatedLineSymbolLayerWidget::onColorMinMaxLineTextChanged );
113 connect( mLineEditColorMaxValue, &QLineEdit::textEdited, this, &QgsInterpolatedLineSymbolLayerWidget::onColorMinMaxLineTextEdited );
114 connect( mButtonLoadMinMaxValueColor, &QPushButton::clicked, this, &QgsInterpolatedLineSymbolLayerWidget::onReloadMinMaxValueColor );
115 connect( mColorRampShaderWidget, &QgsColorRampShaderWidget::widgetChanged, this, &QgsInterpolatedLineSymbolLayerWidget::apply );
116
117}
118
120{
121 if ( !layer || layer->layerType() != QLatin1String( "InterpolatedLine" ) )
122 return;
123
124 mLayer = static_cast<QgsInterpolatedLineSymbolLayer *>( layer );
125
126 const QgsInterpolatedLineWidth interpolatedWidth = mLayer->interpolatedWidth();
127 whileBlocking( mWidthMethodComboBox )->setCurrentIndex( mWidthMethodComboBox->findData( interpolatedWidth.isVariableWidth() ) );
128
129 whileBlocking( mDoubleSpinBoxWidth )->setValue( interpolatedWidth.fixedStrokeWidth() );
130 whileBlocking( mWidthStartFieldExpression )->setExpression( mLayer->dataDefinedProperties().property( QgsSymbolLayer::PropertyLineStartWidthValue ).asExpression() );
131 whileBlocking( mWidthEndFieldExpression )->setExpression( mLayer->dataDefinedProperties().property( QgsSymbolLayer::PropertyLineEndWidthValue ).asExpression() );
132 setLineEditValue( mLineEditWidthMinValue, interpolatedWidth.minimumValue() );
133 setLineEditValue( mLineEditWidthMaxValue, interpolatedWidth.maximumValue() );
134 whileBlocking( mDoubleSpinBoxMinWidth )->setValue( interpolatedWidth.minimumWidth() );
135 whileBlocking( mDoubleSpinBoxMaxWidth )->setValue( interpolatedWidth.maximumWidth() );
136 whileBlocking( mWidthUnitSelectionFixed )->setUnit( mLayer->widthUnit() );
137 whileBlocking( mWidthUnitSelectionVarying )->setUnit( mLayer->widthUnit() );
138 whileBlocking( mCheckBoxAbsoluteValue )->setChecked( interpolatedWidth.useAbsoluteValue() );
139 whileBlocking( mCheckBoxOutOfrange )->setChecked( interpolatedWidth.ignoreOutOfRange() );
140
141 const QgsInterpolatedLineColor interpolatedColor = mLayer->interpolatedColor();
142 whileBlocking( mColorMethodComboBox )->setCurrentIndex( mColorMethodComboBox->findData( interpolatedColor.coloringMethod() ) );
143
144 whileBlocking( mColorStartFieldExpression )->setExpression( mLayer->dataDefinedProperties().property( QgsSymbolLayer::PropertyLineStartColorValue ).asExpression() );
145 whileBlocking( mColorEndFieldExpression )->setExpression( mLayer->dataDefinedProperties().property( QgsSymbolLayer::PropertyLineEndColorValue ).asExpression() );
146 whileBlocking( mColorRampShaderWidget )->setFromShader( interpolatedColor.colorRampShader() );
147 setLineEditValue( mLineEditColorMinValue, interpolatedColor.colorRampShader().minimumValue() );
148 setLineEditValue( mLineEditColorMaxValue, interpolatedColor.colorRampShader().maximumValue() );
149 whileBlocking( mColorButton )->setColor( interpolatedColor.singleColor() );
150
151
152 updateVisibleWidget();
153}
154
156{
157 if ( !mLayer )
158 return nullptr;
159
160 return mLayer;
161}
162
163void QgsInterpolatedLineSymbolLayerWidget::apply()
164{
165 if ( !mLayer )
166 return;
167
168 bool isExpression = false;
169 QString fieldOrExpression = mWidthStartFieldExpression->currentField( &isExpression );
170 mLayer->setDataDefinedProperty( QgsSymbolLayer::PropertyLineStartWidthValue, isExpression ? QgsProperty::fromExpression( fieldOrExpression ) : QgsProperty::fromField( fieldOrExpression ) );
171 fieldOrExpression = mWidthEndFieldExpression->currentField( &isExpression );
172 mLayer->setDataDefinedProperty( QgsSymbolLayer::PropertyLineEndWidthValue, isExpression ? QgsProperty::fromExpression( fieldOrExpression ) : QgsProperty::fromField( fieldOrExpression ) );
173
174 mLayer->setInterpolatedWidth( interpolatedLineWidth() );
175 if ( mWidthMethodComboBox->currentData().toBool() )
176 mLayer->setWidthUnit( mWidthUnitSelectionVarying->unit() );
177 else
178 mLayer->setWidthUnit( mWidthUnitSelectionFixed->unit() );
179
180 fieldOrExpression = mColorStartFieldExpression->currentField( &isExpression );
181 mLayer->setDataDefinedProperty( QgsSymbolLayer::PropertyLineStartColorValue, isExpression ? QgsProperty::fromExpression( fieldOrExpression ) : QgsProperty::fromField( fieldOrExpression ) );
182 fieldOrExpression = mColorEndFieldExpression->currentField( &isExpression );
183 mLayer->setDataDefinedProperty( QgsSymbolLayer::PropertyLineEndColorValue, isExpression ? QgsProperty::fromExpression( fieldOrExpression ) : QgsProperty::fromField( fieldOrExpression ) );
184
185 mLayer->setInterpolatedColor( interpolatedLineColor() );
186
187 emit changed();
188}
189
190void QgsInterpolatedLineSymbolLayerWidget::updateVisibleWidget()
191{
192 mFixedWidthWidget->setVisible( !mWidthMethodComboBox->currentData().toBool() );
193 mVaryingWidthWidget->setVisible( mWidthMethodComboBox->currentData().toBool() );
194
195 mFixedColorWidget->setVisible(
196 static_cast<QgsInterpolatedLineColor::ColoringMethod>( mColorMethodComboBox->currentData().toInt() ) == QgsInterpolatedLineColor::SingleColor );
197 mVaryingColorWidget->setVisible(
198 static_cast<QgsInterpolatedLineColor::ColoringMethod>( mColorMethodComboBox->currentData().toInt() ) == QgsInterpolatedLineColor::ColorRamp );
199}
200
201void QgsInterpolatedLineSymbolLayerWidget::onReloadMinMaxValueWidth()
202{
203 reloadMinMaxWidthFromLayer();
204 setLineEditValue( mLineEditWidthMinValue, mMinimumForWidthFromLayer );
205 setLineEditValue( mLineEditWidthMaxValue, mMaximumForWidthFromLayer );
206 apply();
207}
208
209void QgsInterpolatedLineSymbolLayerWidget::onReloadMinMaxValueColor()
210{
211 reloadMinMaxColorFromLayer();
212 setLineEditValue( mLineEditColorMinValue, mMinimumForColorFromLayer );
213 setLineEditValue( mLineEditColorMaxValue, mMaximumForColorFromLayer );
214 onColorMinMaxLineTextEdited();
215}
216
217void QgsInterpolatedLineSymbolLayerWidget::reloadMinMaxWidthFromLayer()
218{
219 QgsExpressionContext expressionContext = createExpressionContext();
220
221 QgsExpression expressionStart( mWidthStartFieldExpression->expression() );
222 if ( !expressionStart.prepare( &expressionContext ) )
223 {
224 apply();
225 return;
226 }
227
228 QgsExpression expressionEnd( mWidthEndFieldExpression->expression() );
229 if ( !expressionEnd.prepare( &expressionContext ) )
230 {
231 apply();
232 return;
233 }
234
235 if ( !mLayer || !vectorLayer() )
236 {
237 apply();
238 return;
239 }
240
242 QgsFeature feat;
243 mMinimumForWidthFromLayer = std::numeric_limits<double>::max();
244 mMaximumForWidthFromLayer = -std::numeric_limits<double>::max();
245 while ( it.nextFeature( feat ) )
246 {
247 expressionContext.setFeature( feat );
248 double startValue = expressionStart.evaluate( &expressionContext ).toDouble();
249 double endValue = expressionEnd.evaluate( &expressionContext ).toDouble();
250
251 if ( mCheckBoxAbsoluteValue->isChecked() )
252 {
253 startValue = fabs( startValue );
254 endValue = fabs( endValue );
255 }
256
257 if ( startValue < mMinimumForWidthFromLayer )
258 mMinimumForWidthFromLayer = startValue;
259 if ( startValue > mMaximumForWidthFromLayer )
260 mMaximumForWidthFromLayer = startValue;
261
262 if ( endValue < mMinimumForWidthFromLayer )
263 mMinimumForWidthFromLayer = endValue;
264 if ( endValue > mMaximumForWidthFromLayer )
265 mMaximumForWidthFromLayer = endValue;
266 }
267
268 if ( mLineEditWidthMinValue->text().isEmpty() && !std::isnan( mMinimumForWidthFromLayer ) )
269 {
270 setLineEditValue( mLineEditWidthMinValue, mMinimumForWidthFromLayer );
271 }
272
273 if ( mLineEditWidthMaxValue->text().isEmpty() && !std::isnan( mMaximumForWidthFromLayer ) )
274 {
275 setLineEditValue( mLineEditWidthMaxValue, mMaximumForWidthFromLayer );
276 }
277
278 apply();
279}
280
281void QgsInterpolatedLineSymbolLayerWidget::reloadMinMaxColorFromLayer()
282{
283 QgsExpressionContext expressionContext = createExpressionContext();
284
285 QgsExpression expressionStart( mColorStartFieldExpression->expression() );
286 if ( !expressionStart.prepare( &expressionContext ) )
287 {
288 apply();
289 return;
290 }
291
292 QgsExpression expressionEnd( mColorEndFieldExpression->expression() );
293 if ( !expressionEnd.prepare( &expressionContext ) )
294 {
295 apply();
296 return;
297 }
298
299 if ( !mLayer || !vectorLayer() )
300 {
301 apply();
302 return;
303 }
304
306 QgsFeature feat;
307 mMinimumForColorFromLayer = std::numeric_limits<double>::max();
308 mMaximumForColorFromLayer = -std::numeric_limits<double>::max();
309 while ( it.nextFeature( feat ) )
310 {
311 expressionContext.setFeature( feat );
312 const double startValue = expressionStart.evaluate( &expressionContext ).toDouble();
313 const double endValue = expressionEnd.evaluate( &expressionContext ).toDouble();
314
315 if ( startValue < mMinimumForColorFromLayer )
316 mMinimumForColorFromLayer = startValue;
317 if ( startValue > mMaximumForColorFromLayer )
318 mMaximumForColorFromLayer = startValue;
319
320 if ( endValue < mMinimumForColorFromLayer )
321 mMinimumForColorFromLayer = endValue;
322 if ( endValue > mMaximumForColorFromLayer )
323 mMaximumForColorFromLayer = endValue;
324 }
325
326 bool minMaxColorChanged = false;
327 if ( mLineEditColorMinValue->text().isEmpty() && !std::isnan( mMinimumForColorFromLayer ) )
328 {
329 setLineEditValue( mLineEditColorMinValue, mMinimumForColorFromLayer );
330 minMaxColorChanged = true;
331 }
332
333 if ( mLineEditColorMaxValue->text().isEmpty() && !std::isnan( mMaximumForColorFromLayer ) )
334 {
335 setLineEditValue( mLineEditColorMaxValue, mMaximumForColorFromLayer );
336 minMaxColorChanged = true;
337 }
338
339 if ( minMaxColorChanged )
340 onColorMinMaxLineTextEdited();
341
342 apply();
343}
344
345void QgsInterpolatedLineSymbolLayerWidget::onColorMinMaxLineTextChanged()
346{
347 const double min = lineEditValue( mLineEditColorMinValue );
348 const double max = lineEditValue( mLineEditColorMaxValue );
349 whileBlocking( mColorRampShaderWidget )->setMinimumMaximum( min, max );
350 apply();
351}
352
353void QgsInterpolatedLineSymbolLayerWidget::onColorMinMaxLineTextEdited()
354{
355 const double min = lineEditValue( mLineEditColorMinValue );
356 const double max = lineEditValue( mLineEditColorMaxValue );
357 whileBlocking( mColorRampShaderWidget )->setMinimumMaximumAndClassify( min, max );
358 apply();
359}
360
361QgsInterpolatedLineWidth QgsInterpolatedLineSymbolLayerWidget::interpolatedLineWidth()
362{
363 QgsInterpolatedLineWidth interWidth;
364 interWidth.setIsVariableWidth( mWidthMethodComboBox->currentData().toBool() );
365 interWidth.setMinimumValue( lineEditValue( mLineEditWidthMinValue ) );
366 interWidth.setMaximumValue( lineEditValue( mLineEditWidthMaxValue ) );
367 interWidth.setMinimumWidth( mDoubleSpinBoxMinWidth->value() );
368 interWidth.setMaximumWidth( mDoubleSpinBoxMaxWidth->value() );
369 interWidth.setFixedStrokeWidth( mDoubleSpinBoxWidth->value() );
370 interWidth.setIgnoreOutOfRange( mCheckBoxOutOfrange->isChecked() );
371 interWidth.setUseAbsoluteValue( mCheckBoxAbsoluteValue->isChecked() );
372
373 return interWidth;
374}
375
376QgsInterpolatedLineColor QgsInterpolatedLineSymbolLayerWidget::interpolatedLineColor()
377{
378 QgsInterpolatedLineColor interColor;
379 interColor.setColor( mColorButton->color() );
380 const QgsColorRampShader colorRampShader = mColorRampShaderWidget->shader();
381 interColor.setColor( colorRampShader );
382 interColor.setColoringMethod( static_cast<QgsInterpolatedLineColor::ColoringMethod>( mColorMethodComboBox->currentData().toInt() ) );
383
384 return interColor;
385}
386
387double QgsInterpolatedLineSymbolLayerWidget::lineEditValue( QLineEdit *lineEdit )
388{
389 if ( lineEdit->text().isEmpty() )
390 {
391 return std::numeric_limits<double>::quiet_NaN();
392 }
393
394 return QgsDoubleValidator::toDouble( lineEdit->text() );
395}
396
397void QgsInterpolatedLineSymbolLayerWidget::setLineEditValue( QLineEdit *lineEdit, double value )
398{
399 QString strValue;
400 if ( !std::isnan( value ) )
401 strValue = QLocale().toString( value );
402 whileBlocking( lineEdit )->setText( strValue );
403}
void colorChanged(const QColor &color)
Emitted whenever a new color is set for the button.
void widgetChanged()
Widget changed.
A ramp shader will color a raster pixel based on a list of values ranges in a ramp.
static double toDouble(const QString &input, bool *ok)
Converts input string to double value.
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
void setFeature(const QgsFeature &feature)
Convenience function for setting a feature for the context.
Class for parsing and evaluation of expressions (formerly called "search strings").
Wrapper for iterator of features from vector data provider or vector layer.
bool nextFeature(QgsFeature &f)
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
Definition: qgsfeature.h:56
The QgsFieldExpressionWidget class reates a widget to choose fields and edit expressions It contains ...
void fieldChanged(const QString &fieldName)
Emitted when the currently selected field changes.
@ Numeric
All numeric fields.
Class defining color to render mesh datasets.
QgsInterpolatedLineColor::ColoringMethod coloringMethod() const
Returns the coloring method used.
QgsColorRampShader colorRampShader() const
Returns the color ramp shader.
void setColor(const QgsColorRampShader &colorRampShader)
Sets the color ramp to define the coloring.
QColor singleColor() const
Returns the single color that is used if SingleColor coloring mode is set.
void setColoringMethod(ColoringMethod coloringMethod)
Sets the coloring method used.
ColoringMethod
Defines how the color is defined.
@ ColorRamp
Render with a color ramp.
@ SingleColor
Render with a single color.
QgsInterpolatedLineSymbolLayerWidget(QgsVectorLayer *layer, QWidget *parent=nullptr)
Constructor.
A symbol layer that represents vector layer line feature as interpolated line The interpolation is do...
QgsInterpolatedLineColor interpolatedColor() const
Returns the interpolated color used to render the colors of lines, see QgsInterpolatedLineColor.
void setWidthUnit(QgsUnitTypes::RenderUnit strokeWidthUnit)
Sets the width unit.
void setInterpolatedWidth(const QgsInterpolatedLineWidth &interpolatedLineWidth)
Sets the interpolated width used to render the width of lines, see QgsInterpolatedLineWidth.
void setInterpolatedColor(const QgsInterpolatedLineColor &interpolatedLineColor)
Sets the interpolated color used to render the colors of lines, see QgsInterpolatedLineColor.
QgsUnitTypes::RenderUnit widthUnit() const
Returns the width unit.
QgsInterpolatedLineWidth interpolatedWidth() const
Returns the interpolated width used to render the width of lines, see QgsInterpolatedLineWidth.
Represents a width than can vary depending on values.
void setFixedStrokeWidth(double fixedWidth)
Sets the fixed width.
void setUseAbsoluteValue(bool useAbsoluteValue)
Sets whether absolute value are used as input.
double minimumValue() const
Returns the minimum value used to defined the variable width.
void setIgnoreOutOfRange(bool ignoreOutOfRange)
Sets whether the variable width ignores out of range value.
void setMaximumValue(double maximumValue)
Sets the maximum value used to defined the variable width.
bool useAbsoluteValue() const
Returns whether absolute value are used as input.
void setIsVariableWidth(bool isVariableWidth)
Returns whether the width is variable.
void setMinimumValue(double minimumValue)
Sets the minimum value used to defined the variable width.
double maximumWidth() const
Returns the maximum width used to defined the variable width.
void setMaximumWidth(double maximumWidth)
Sets the maximum width used to defined the variable width.
double maximumValue() const
Returns the maximum value used to defined the variable width.
void setMinimumWidth(double minimumWidth)
Sets the minimum width used to defined the variable width.
bool ignoreOutOfRange() const
Returns whether the variable width ignores out of range value.
double minimumWidth() const
Returns the minimum width used to defined the variable width.
double fixedStrokeWidth() const
Returns the fixed width.
bool isVariableWidth() const
Returns whether the width is variable.
QgsProperty property(int key) const override
Returns a matching property from the collection, if one exists.
QString asExpression() const
Returns an expression string representing the state of the property, or an empty string if the proper...
static QgsProperty fromExpression(const QString &expression, bool isActive=true)
Returns a new ExpressionBasedProperty created from the specified expression.
static QgsProperty fromField(const QString &fieldName, bool isActive=true)
Returns a new FieldBasedProperty created from the specified field name.
double maximumValue() const
Returns the minimum value for the raster shader.
double minimumValue() const
Returns the maximum value for the raster shader.
void changed()
Should be emitted whenever configuration changes happened on this symbol layer configuration.
QgsExpressionContext createExpressionContext() const override
This method needs to be reimplemented in all classes which implement this interface and return an exp...
const QgsVectorLayer * vectorLayer() const
Returns the vector layer associated with the widget.
@ PropertyLineEndWidthValue
End line width for interpolated line renderer (since QGIS 3.22)
@ PropertyLineEndColorValue
End line color for interpolated line renderer (since QGIS 3.22)
@ PropertyLineStartColorValue
Start line color for interpolated line renderer (since QGIS 3.22)
@ PropertyLineStartWidthValue
Start line width for interpolated line renderer (since QGIS 3.22)
virtual QString layerType() const =0
Returns a string that represents this layer type.
virtual void setDataDefinedProperty(Property key, const QgsProperty &property)
Sets a data defined property for the layer.
QgsPropertyCollection & dataDefinedProperties()
Returns a reference to the symbol layer's property collection, used for data defined overrides.
QList< QgsUnitTypes::RenderUnit > RenderUnitList
List of render units.
Definition: qgsunittypes.h:240
Represents a vector layer which manages a vector based data sets.
QgsFeatureIterator getFeatures(const QgsFeatureRequest &request=QgsFeatureRequest()) const FINAL
Queries the layer for features specified in request.
QgsSignalBlocker< Object > whileBlocking(Object *object)
Temporarily blocks signals from a QObject while calling a single method from the object.
Definition: qgis.h:2322