QGIS API Documentation  3.23.0-Master (dd0cd13a00)
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"
21 #include "qgstemporalcontroller.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( interpolatedLineWidth().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 
163 void 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 
190 void 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 
201 void QgsInterpolatedLineSymbolLayerWidget::onReloadMinMaxValueWidth()
202 {
203  reloadMinMaxWidthFromLayer();
204  setLineEditValue( mLineEditWidthMinValue, mMinimumForWidthFromLayer );
205  setLineEditValue( mLineEditWidthMaxValue, mMaximumForWidthFromLayer );
206  apply();
207 }
208 
209 void QgsInterpolatedLineSymbolLayerWidget::onReloadMinMaxValueColor()
210 {
211  reloadMinMaxColorFromLayer();
212  setLineEditValue( mLineEditColorMinValue, mMinimumForColorFromLayer );
213  setLineEditValue( mLineEditColorMaxValue, mMaximumForColorFromLayer );
214  onColorMinMaxLineTextEdited();
215 }
216 
217 void 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 
281 void 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 
345 void 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 
353 void 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 
361 QgsInterpolatedLineWidth 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 
376 QgsInterpolatedLineColor 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 
387 double 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 
397 void 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.
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.
const QgsVectorLayer * vectorLayer() const
Returns the vector layer associated with the widget.
QgsExpressionContext createExpressionContext() const override
This method needs to be reimplemented in all classes which implement this interface and return an exp...
@ 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:1443