QGIS API Documentation 3.40.0-Bratislava (b56115d8743)
Loading...
Searching...
No Matches
qgslayerpropertieswidget.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgslayerpropertieswidget.cpp
3 ----------------------------
4 begin : June 2012
5 copyright : (C) 2012 by Arunmozhi
6 email : aruntheguy at gmail.com
7 ***************************************************************************
8 * *
9 * This program is free software; you can redistribute it and/or modify *
10 * it under the terms of the GNU General Public License as published by *
11 * the Free Software Foundation; either version 2 of the License, or *
12 * (at your option) any later version. *
13 * *
14 ***************************************************************************/
15
17
18#include <QFile>
19#include <QStandardItem>
20#include <QKeyEvent>
21#include <QMessageBox>
22#include <QPicture>
23
24#include "qgssymbollayer.h"
27
28#include "qgsapplication.h"
29#include "qgslogger.h"
30
36#include "qgssymbol.h" //for the unit
37#include "qgspanelwidget.h"
38#include "qgsmapcanvas.h"
39#include "qgspainteffect.h"
40#include "qgsproject.h"
41#include "qgsvectorlayer.h"
45#include "qgssymbollayerutils.h"
47#include "qgsmarkersymbol.h"
48#include "qgslinesymbol.h"
49#include "qgsfillsymbol.h"
51
52static bool _initWidgetFunction( const QString &name, QgsSymbolLayerWidgetFunc f )
53{
55
56 QgsSymbolLayerAbstractMetadata *abstractMetadata = reg->symbolLayerMetadata( name );
57 if ( !abstractMetadata )
58 {
59 QgsDebugError( "Failed to find symbol layer's entry in registry: " + name );
60 return false;
61 }
62 QgsSymbolLayerMetadata *metadata = dynamic_cast<QgsSymbolLayerMetadata *>( abstractMetadata );
63 if ( !metadata )
64 {
65 QgsDebugError( "Failed to cast symbol layer's metadata: " + name );
66 return false;
67 }
68 metadata->setWidgetFunction( f );
69 return true;
70}
71
72static void _initWidgetFunctions()
73{
74 static bool sInitialized = false;
75 if ( sInitialized )
76 return;
77
78 _initWidgetFunction( QStringLiteral( "SimpleLine" ), QgsSimpleLineSymbolLayerWidget::create );
79 _initWidgetFunction( QStringLiteral( "MarkerLine" ), QgsMarkerLineSymbolLayerWidget::create );
80 _initWidgetFunction( QStringLiteral( "HashLine" ), QgsHashedLineSymbolLayerWidget::create );
81 _initWidgetFunction( QStringLiteral( "ArrowLine" ), QgsArrowSymbolLayerWidget::create );
82 _initWidgetFunction( QStringLiteral( "InterpolatedLine" ), QgsInterpolatedLineSymbolLayerWidget::create );
83 _initWidgetFunction( QStringLiteral( "RasterLine" ), QgsRasterLineSymbolLayerWidget::create );
84 _initWidgetFunction( QStringLiteral( "Lineburst" ), QgsLineburstSymbolLayerWidget::create );
85 _initWidgetFunction( QStringLiteral( "FilledLine" ), QgsFilledLineSymbolLayerWidget::create );
86 _initWidgetFunction( QStringLiteral( "LinearReferencing" ), QgsLinearReferencingSymbolLayerWidget::create );
87
88 _initWidgetFunction( QStringLiteral( "SimpleMarker" ), QgsSimpleMarkerSymbolLayerWidget::create );
89 _initWidgetFunction( QStringLiteral( "FilledMarker" ), QgsFilledMarkerSymbolLayerWidget::create );
90 _initWidgetFunction( QStringLiteral( "SvgMarker" ), QgsSvgMarkerSymbolLayerWidget::create );
91 _initWidgetFunction( QStringLiteral( "RasterMarker" ), QgsRasterMarkerSymbolLayerWidget::create );
92 _initWidgetFunction( QStringLiteral( "AnimatedMarker" ), QgsAnimatedMarkerSymbolLayerWidget::create );
93 _initWidgetFunction( QStringLiteral( "FontMarker" ), QgsFontMarkerSymbolLayerWidget::create );
94 _initWidgetFunction( QStringLiteral( "EllipseMarker" ), QgsEllipseSymbolLayerWidget::create );
95 _initWidgetFunction( QStringLiteral( "VectorField" ), QgsVectorFieldSymbolLayerWidget::create );
96 _initWidgetFunction( QStringLiteral( "MaskMarker" ), QgsMaskMarkerSymbolLayerWidget::create );
97
98 _initWidgetFunction( QStringLiteral( "SimpleFill" ), QgsSimpleFillSymbolLayerWidget::create );
99 _initWidgetFunction( QStringLiteral( "GradientFill" ), QgsGradientFillSymbolLayerWidget::create );
100 _initWidgetFunction( QStringLiteral( "ShapeburstFill" ), QgsShapeburstFillSymbolLayerWidget::create );
101 _initWidgetFunction( QStringLiteral( "RasterFill" ), QgsRasterFillSymbolLayerWidget::create );
102 _initWidgetFunction( QStringLiteral( "SVGFill" ), QgsSVGFillSymbolLayerWidget::create );
103 _initWidgetFunction( QStringLiteral( "CentroidFill" ), QgsCentroidFillSymbolLayerWidget::create );
104 _initWidgetFunction( QStringLiteral( "LinePatternFill" ), QgsLinePatternFillSymbolLayerWidget::create );
105 _initWidgetFunction( QStringLiteral( "PointPatternFill" ), QgsPointPatternFillSymbolLayerWidget::create );
106 _initWidgetFunction( QStringLiteral( "RandomMarkerFill" ), QgsRandomMarkerFillSymbolLayerWidget::create );
107
108 _initWidgetFunction( QStringLiteral( "GeometryGenerator" ), QgsGeometryGeneratorSymbolLayerWidget::create );
109
110 sInitialized = true;
111}
112
113
115 : QgsPanelWidget( parent )
116 , mLayer( layer )
117 , mSymbol( symbol )
118 , mVectorLayer( vl )
119{
120
121 setupUi( this );
122 connect( mEnabledCheckBox, &QCheckBox::toggled, this, &QgsLayerPropertiesWidget::mEnabledCheckBox_toggled );
123 // initialize the sub-widgets
124 // XXX Should this thing be here this way? Initialize all the widgets just for the sake of one layer?
125 // TODO Make this on demand creation
126 _initWidgetFunctions();
127
128 // TODO Algorithm
129 //
130 // 3. populate the combo box with the supported layer type
131 // 4. set the present layer type
132 // 5. create the widget for the present layer type and set in stacked widget
133 // 6. connect comboBox type changed to two things
134 // 1. emit signal that type has beed changed
135 // 2. remove the widget and place the new widget corresponding to the changed layer type
136 //
138 // update layer type combo box
139 const int idx = cboLayerType->findData( mLayer->layerType() );
140 cboLayerType->setCurrentIndex( idx );
141
142 connect( mEnabledCheckBox, &QAbstractButton::toggled, mEnabledDDBtn, &QWidget::setEnabled );
143 mEnabledCheckBox->setChecked( mLayer->enabled() );
144
145 // set the corresponding widget
147 connect( cboLayerType, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, &QgsLayerPropertiesWidget::layerTypeChanged );
148
150
151 this->connectChildPanel( mEffectWidget );
152
153 if ( !mLayer->paintEffect() )
154 {
156 mLayer->paintEffect()->setEnabled( false );
157 }
158 mEffectWidget->setPaintEffect( mLayer->paintEffect() );
159
161}
162
164{
165 mContext = context;
166 if ( mSymbol )
167 mContext.setSymbolType( mSymbol->type() );
168
169 QgsSymbolLayerWidget *w = dynamic_cast< QgsSymbolLayerWidget * >( stackedWidget->currentWidget() );
170 if ( w )
171 w->setContext( mContext );
172}
173
175{
176 return mContext;
177}
178
180{
182 mEffectWidget->setDockMode( this->dockMode() );
183}
184
186{
187 const QStringList symbolLayerIds = QgsApplication::symbolLayerRegistry()->symbolLayersForType( mSymbol->type() );
188
189 const auto constSymbolLayerIds = symbolLayerIds;
190 for ( const QString &symbolLayerId : constSymbolLayerIds )
191 cboLayerType->addItem( QgsApplication::symbolLayerRegistry()->symbolLayerMetadata( symbolLayerId )->visibleName(), symbolLayerId );
192
194 {
196 const auto constLineLayerIds = lineLayerIds;
197 for ( const QString &lineLayerId : constLineLayerIds )
198 {
200 if ( layerInfo->type() != Qgis::SymbolType::Hybrid )
201 {
202 const QString visibleName = layerInfo->visibleName();
203 const QString name = tr( "Outline: %1" ).arg( visibleName );
204 cboLayerType->addItem( name, lineLayerId );
205 }
206 }
207 }
208}
209
211{
212 if ( stackedWidget->currentWidget() != pageDummy )
213 {
214 // stop updating from the original widget
215 if ( QgsSymbolLayerWidget *w = qobject_cast< QgsSymbolLayerWidget * >( stackedWidget->currentWidget() ) )
217 stackedWidget->removeWidget( stackedWidget->currentWidget() );
218 }
219
221
222 const QString layerType = layer->layerType();
224 if ( am )
225 {
227 if ( w )
228 {
229 w->setContext( mContext );
230 w->setSymbolLayer( layer );
231 stackedWidget->addWidget( w );
232 stackedWidget->setCurrentWidget( w );
233 // start receiving updates from widget
235 connect( w, &QgsSymbolLayerWidget::symbolChanged, this, &QgsLayerPropertiesWidget::reloadLayer );
236 return;
237 }
238 }
239 // When anything is not right
240 stackedWidget->setCurrentWidget( pageDummy );
241}
242
244{
245 if ( auto *lExpressionContext = mContext.expressionContext() )
246 return *lExpressionContext;
247
248 QgsExpressionContext expContext;
249 if ( auto *lMapCanvas = mContext.mapCanvas() )
250 {
251 expContext = lMapCanvas->createExpressionContext();
252 }
253 else
254 {
259 }
260
262
264 if ( mLayer )
265 {
266 //cheat a bit - set the symbol color variable to match the symbol layer's color (when we should really be using the *symbols*
267 //color, but that's not accessible here). 99% of the time these will be the same anyway
269 }
270 expContext << symbolScope;
276 expContext.lastScope()->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "symbol_layer_count" ), 1, true ) );
277 expContext.lastScope()->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "symbol_layer_index" ), 1, true ) );
278 expContext.lastScope()->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "symbol_marker_row" ), 1, true ) );
279 expContext.lastScope()->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "symbol_marker_column" ), 1, true ) );
280 expContext.lastScope()->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "symbol_frame" ), 1, true ) );
281
282 // additional scopes
283 const auto constAdditionalExpressionContextScopes = mContext.additionalExpressionContextScopes();
284 for ( const QgsExpressionContextScope &scope : constAdditionalExpressionContextScopes )
285 {
286 expContext.appendScope( new QgsExpressionContextScope( scope ) );
287 }
288
289 //TODO - show actual value
290 expContext.setOriginalValueVariable( QVariant() );
291
297 << QStringLiteral( "symbol_layer_count" ) << QStringLiteral( "symbol_layer_index" )
298 << QStringLiteral( "symbol_frame" ) );
299
300 return expContext;
301}
302
304{
305 button->init( static_cast< int >( key ), mLayer->dataDefinedProperties(), QgsSymbolLayer::propertyDefinitions(), mVectorLayer );
306 connect( button, &QgsPropertyOverrideButton::changed, this, &QgsLayerPropertiesWidget::updateProperty );
308}
309
310void QgsLayerPropertiesWidget::updateProperty()
311{
312 QgsPropertyOverrideButton *button = qobject_cast<QgsPropertyOverrideButton *>( sender() );
313 const QgsSymbolLayer::Property key = static_cast< QgsSymbolLayer::Property >( button->propertyKey() );
314 mLayer->setDataDefinedProperty( key, button->toProperty() );
315 emit changed();
316}
317
319{
320 QgsSymbolLayer *layer = mLayer;
321 if ( !layer )
322 return;
323 const QString newLayerType = cboLayerType->currentData().toString();
324 if ( layer->layerType() == newLayerType )
325 return;
326
327 // get creation function for new layer from registry
329 QgsSymbolLayerAbstractMetadata *am = pReg->symbolLayerMetadata( newLayerType );
330 if ( !am ) // check whether the metadata is assigned
331 return;
332
333 // change layer to a new (with different type)
334 // base new layer on existing layer's properties
335 QVariantMap properties = layer->properties();
336
337 // if the old symbol layer was a "geometry generator" layer then
338 // we instead get the properties from the generator
339 if ( QgsGeometryGeneratorSymbolLayer *generator = dynamic_cast< QgsGeometryGeneratorSymbolLayer * >( layer ) )
340 {
341 if ( generator->subSymbol() && generator->subSymbol()->symbolLayerCount() > 0 )
342 properties = generator->subSymbol()->symbolLayer( 0 )->properties();
343 }
344
345 QgsSymbolLayer *newLayer = am->createSymbolLayer( properties );
346 if ( !newLayer )
347 return;
348
349 // if a symbol layer is changed to a "geometry generator" layer, then we move the old symbol layer into the
350 // geometry generator's subsymbol.
351 if ( QgsGeometryGeneratorSymbolLayer *generator = dynamic_cast< QgsGeometryGeneratorSymbolLayer * >( newLayer ) )
352 {
353 if ( mSymbol )
354 {
355 switch ( mSymbol->type() )
356 {
358 {
359 std::unique_ptr< QgsMarkerSymbol > markerSymbol = std::make_unique< QgsMarkerSymbol >( QgsSymbolLayerList( {layer->clone() } ) );
360 generator->setSymbolType( Qgis::SymbolType::Marker );
361 generator->setSubSymbol( markerSymbol.release() );
362 break;
363 }
365 {
366 std::unique_ptr< QgsLineSymbol > lineSymbol = std::make_unique< QgsLineSymbol >( QgsSymbolLayerList( {layer->clone() } ) );
367 generator->setSymbolType( Qgis::SymbolType::Line );
368 generator->setSubSymbol( lineSymbol.release() );
369 break;
370 }
372 {
373 std::unique_ptr< QgsFillSymbol > fillSymbol = std::make_unique< QgsFillSymbol >( QgsSymbolLayerList( {layer->clone() } ) );
374 generator->setSymbolType( Qgis::SymbolType::Fill );
375 generator->setSubSymbol( fillSymbol.release() );
376 break;
377 }
379 break;
380 }
381 }
382 }
383 else
384 {
385 // try to copy the subsymbol, if its the same type as the new symbol layer's subsymbol
386 if ( newLayer->subSymbol() && layer->subSymbol() && newLayer->subSymbol()->type() == layer->subSymbol()->type() )
387 {
388 newLayer->setSubSymbol( layer->subSymbol()->clone() );
389 }
390 }
391
392 // special logic for when NEW symbol layers are created from GUI only...
393 // TODO: find a nicer generic way to handle this!
394 if ( QgsFontMarkerSymbolLayer *fontMarker = dynamic_cast< QgsFontMarkerSymbolLayer * >( newLayer ) )
395 {
396 const QString defaultFont = fontMarker->fontFamily();
397 const QFontDatabase fontDb;
398 if ( !fontDb.hasFamily( defaultFont ) )
399 {
400 // default font marker font choice doesn't exist on system, so just use first available symbol font
401 const QStringList candidates = fontDb.families( QFontDatabase::WritingSystem::Symbol );
402 bool foundGoodCandidate = false;
403 for ( const QString &candidate : candidates )
404 {
405 if ( fontDb.writingSystems( candidate ).size() == 1 )
406 {
407 // family ONLY offers symbol writing systems, so it's a good candidate!
408 fontMarker->setFontFamily( candidate );
409 foundGoodCandidate = true;
410 break;
411 }
412 }
413 if ( !foundGoodCandidate && !candidates.empty() )
414 {
415 // fallback to first available family which advertises symbol writing system
416 QString candidate = candidates.at( 0 );
417 fontMarker->setFontFamily( candidate );
418 }
419 }
420
421 // search (briefly!!) for a unicode character which actually exists in the font
422 const QFontMetrics fontMetrics( fontMarker->fontFamily() );
423 ushort character = fontMarker->character().at( 0 ).unicode();
424 for ( ; character < 1000; ++character )
425 {
426 if ( fontMetrics.inFont( QChar( character ) ) )
427 {
428 fontMarker->setCharacter( QChar( character ) );
429 break;
430 }
431 }
432 }
433
434 updateSymbolLayerWidget( newLayer );
435 emit changeLayer( newLayer );
436}
437
439{
440 emit changed();
441
442 // also update paint effect preview
443 bool paintEffectToggled = false;
444 if ( mLayer->paintEffect() && mLayer->paintEffect()->enabled() )
445 {
446 mLayer->paintEffect()->setEnabled( false );
447 paintEffectToggled = true;
448 }
450 if ( paintEffectToggled )
451 {
452 mLayer->paintEffect()->setEnabled( true );
453 }
454 emit widgetChanged();
455}
456
457void QgsLayerPropertiesWidget::reloadLayer()
458{
459 emit changeLayer( mLayer );
460}
461
462void QgsLayerPropertiesWidget::mEnabledCheckBox_toggled( bool enabled )
463{
464 mLayer->setEnabled( enabled );
466}
@ Millimeters
Millimeters.
@ Marker
Marker symbol.
@ Line
Line symbol.
@ Fill
Fill symbol.
@ Hybrid
Hybrid symbol.
static QgsSymbolLayerWidget * create(QgsVectorLayer *vl)
Creates a new QgsAnimatedMarkerSymbolLayerWidget.
static QgsSymbolLayerRegistry * symbolLayerRegistry()
Returns the application's symbol layer registry, used for managing symbol layers.
static QgsSymbolLayerWidget * create(QgsVectorLayer *layer)
Static creation method.
static QgsSymbolLayerWidget * create(QgsVectorLayer *vl)
Creates a new QgsCentroidFillSymbolLayerWidget.
void changed()
Emitted when the paint effect properties change.
static QgsSymbolLayerWidget * create(QgsVectorLayer *vl)
Creates a new QgsSymbolLayerWidget.
Single scope for storing variables and functions for use within a QgsExpressionContext.
void addVariable(const QgsExpressionContextScope::StaticVariable &variable)
Adds a variable into the context scope.
static QgsExpressionContextScope * updateSymbolScope(const QgsSymbol *symbol, QgsExpressionContextScope *symbolScope=nullptr)
Updates a symbol scope related to a QgsSymbol to an expression context.
static QgsExpressionContextScope * projectScope(const QgsProject *project)
Creates a new scope which contains variables and functions relating to a QGIS project.
static QgsExpressionContextScope * atlasScope(const QgsLayoutAtlas *atlas)
Creates a new scope which contains variables and functions relating to a QgsLayoutAtlas.
static QgsExpressionContextScope * mapSettingsScope(const QgsMapSettings &mapSettings)
Creates a new scope which contains variables and functions relating to a QgsMapSettings object.
static QgsExpressionContextScope * layerScope(const QgsMapLayer *layer)
Creates a new scope which contains variables and functions relating to a QgsMapLayer.
static QgsExpressionContextScope * globalScope()
Creates a new scope which contains variables and functions relating to the global QGIS context.
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
static const QString EXPR_GEOMETRY_PART_COUNT
Inbuilt variable name for geometry part count variable.
static const QString EXPR_GEOMETRY_POINT_COUNT
Inbuilt variable name for point count variable.
static const QString EXPR_CLUSTER_SIZE
Inbuilt variable name for cluster size variable.
static const QString EXPR_GEOMETRY_POINT_NUM
Inbuilt variable name for point number variable.
void setOriginalValueVariable(const QVariant &value)
Sets the original value variable value for the context.
static const QString EXPR_GEOMETRY_RING_NUM
Inbuilt variable name for geometry ring number variable.
static const QString EXPR_GEOMETRY_PART_NUM
Inbuilt variable name for geometry part number variable.
static const QString EXPR_SYMBOL_COLOR
Inbuilt variable name for symbol color variable.
QgsExpressionContextScope * lastScope()
Returns the last scope added to the context.
void appendScope(QgsExpressionContextScope *scope)
Appends a scope to the end of the context.
void setHighlightedVariables(const QStringList &variableNames)
Sets the list of variable names within the context intended to be highlighted to the user.
static const QString EXPR_ORIGINAL_VALUE
Inbuilt variable name for value original value variable.
static const QString EXPR_CLUSTER_COLOR
Inbuilt variable name for cluster color variable.
static QgsSymbolLayerWidget * create(QgsVectorLayer *vl)
Creates a new QgsFilledLineSymbolLayerWidget.
static QgsSymbolLayerWidget * create(QgsVectorLayer *vl)
Creates a new QgsFilledMarkerSymbolLayerWidget.
static QgsSymbolLayerWidget * create(QgsVectorLayer *vl)
Creates a new QgsFontMarkerSymbolLayerWidget.
static QgsSymbolLayerWidget * create(QgsVectorLayer *vl)
Will be registered as factory.
A symbol layer subclass which alters rendered feature shapes through the use of QGIS expressions.
static QgsSymbolLayerWidget * create(QgsVectorLayer *vl)
Creates a new QgsGradientFillSymbolLayerWidget.
static QgsSymbolLayerWidget * create(QgsVectorLayer *vl)
Creates a new QgsHashedLineSymbolLayerWidget.
static QgsSymbolLayerWidget * create(QgsVectorLayer *layer)
Static creation method.
QgsLayerPropertiesWidget(QgsSymbolLayer *layer, const QgsSymbol *symbol, QgsVectorLayer *vl, QWidget *parent=nullptr)
Constructor for QgsLayerPropertiesWidget.
void setDockMode(bool dockMode) override
Set the widget in dock mode which tells the widget to emit panel widgets and not open dialogs.
void changeLayer(QgsSymbolLayer *layer)
Emitted when the symbol layer is changed in the widget.
QgsSymbolWidgetContext context() const
Returns the context in which the symbol widget is shown, e.g., the associated map canvas and expressi...
QgsExpressionContext createExpressionContext() const override
This method needs to be reimplemented in all classes which implement this interface and return an exp...
void setContext(const QgsSymbolWidgetContext &context)
Sets the context in which the symbol widget is shown, e.g., the associated map canvas and expression ...
void changed()
Emitted when the symbol layer configuration is changed in the widget.
void updateSymbolLayerWidget(QgsSymbolLayer *layer)
void registerDataDefinedButton(QgsPropertyOverrideButton *button, QgsSymbolLayer::Property key)
Registers a data defined override button.
static QgsSymbolLayerWidget * create(QgsVectorLayer *vl)
Creates a new QgsLinePatternFillSymbolLayerWidget.
static QgsSymbolLayerWidget * create(QgsVectorLayer *vl)
Creates a new QgsLinearReferencingSymbolLayerWidget.
static QgsSymbolLayerWidget * create(QgsVectorLayer *vl)
Creates a new QgsLineburstSymbolLayerWidget.
The QgsMapSettings class contains configuration for rendering of the map.
Struct for storing maximum and minimum scales for measurements in map units.
static QgsSymbolLayerWidget * create(QgsVectorLayer *vl)
Creates a new QgsMarkerLineSymbolLayerWidget.
static QgsSymbolLayerWidget * create(QgsVectorLayer *layer)
Static creation method.
static QgsPaintEffect * defaultStack()
Returns a new effect stack consisting of a sensible selection of default effects.
void setEnabled(bool enabled)
Sets whether the effect is enabled.
bool enabled() const
Returns whether the effect is enabled.
Base class for any widget that can be shown as a inline panel.
void connectChildPanel(QgsPanelWidget *panel)
Connect the given sub panel widgets showPanel signals to this current panels main showPanel event to ...
void widgetChanged()
Emitted when the widget state changes.
virtual void setDockMode(bool dockMode)
Set the widget in dock mode which tells the widget to emit panel widgets and not open dialogs.
bool dockMode()
Returns the dock mode state.
static QgsSymbolLayerWidget * create(QgsVectorLayer *vl)
Creates a new QgsPointPatternFillSymbolLayerWidget.
static QgsProject * instance()
Returns the QgsProject singleton instance.
A button for controlling property overrides which may apply to a widget.
QgsProperty toProperty() const
Returns a QgsProperty object encapsulating the current state of the widget.
void changed()
Emitted when property definition changes.
void init(int propertyKey, const QgsProperty &property, const QgsPropertiesDefinition &definitions, const QgsVectorLayer *layer=nullptr, bool auxiliaryStorageEnabled=false)
Initialize a newly constructed property button (useful if button was included in a UI layout).
void registerExpressionContextGenerator(QgsExpressionContextGenerator *generator)
Register an expression context generator class that will be used to retrieve an expression context fo...
int propertyKey() const
Returns the property key linked to the button.
static QgsSymbolLayerWidget * create(QgsVectorLayer *vl)
Creates a new QgsRandomMarkerFillSymbolLayerWidget.
static QgsSymbolLayerWidget * create(QgsVectorLayer *vl)
Creates a new QgsRasterFillSymbolLayerWidget.
static QgsSymbolLayerWidget * create(QgsVectorLayer *vl)
Creates a new QgsRasterLineSymbolLayerWidget.
static QgsSymbolLayerWidget * create(QgsVectorLayer *vl)
Creates a new QgsRasterMarkerSymbolLayerWidget.
static QgsSymbolLayerWidget * create(QgsVectorLayer *vl)
Creates a new QgsSVGFillSymbolLayerWidget.
static QgsSymbolLayerWidget * create(QgsVectorLayer *vl)
Creates a new QgsShapeburstFillSymbolLayerWidget.
static QgsSymbolLayerWidget * create(QgsVectorLayer *vl)
Creates a new QgsSimpleFillSymbolLayerWidget.
static QgsSymbolLayerWidget * create(QgsVectorLayer *vl)
Creates a new QgsSimpleLineSymbolLayerWidget.
static QgsSymbolLayerWidget * create(QgsVectorLayer *vl)
Creates a new QgsSimpleMarkerSymbolLayerWidget.
static QgsSymbolLayerWidget * create(QgsVectorLayer *vl)
Creates a new QgsSvgMarkerSymbolLayerWidget.
Stores metadata about one symbol layer class.
virtual QgsSymbolLayer * createSymbolLayer(const QVariantMap &map)=0
Create a symbol layer of this type given the map of properties.
virtual QgsSymbolLayerWidget * createSymbolLayerWidget(QgsVectorLayer *)
Create widget for symbol layer of this type. Can return nullptr if there's no GUI.
Convenience metadata class that uses static functions to create symbol layer and its widget.
void setWidgetFunction(QgsSymbolLayerWidgetFunc f)
Registry of available symbol layer classes.
QStringList symbolLayersForType(Qgis::SymbolType type)
Returns a list of available symbol layers for a specified symbol type.
QgsSymbolLayerAbstractMetadata * symbolLayerMetadata(const QString &name) const
Returns metadata for specified symbol layer. Returns nullptr if not found.
static QPicture symbolLayerPreviewPicture(const QgsSymbolLayer *layer, Qgis::RenderUnit units, QSize size, const QgsMapUnitScale &scale=QgsMapUnitScale(), Qgis::SymbolType parentSymbolType=Qgis::SymbolType::Hybrid)
Draws a symbol layer preview to a QPicture.
virtual void setSymbolLayer(QgsSymbolLayer *layer)=0
void changed()
Should be emitted whenever configuration changes happened on this symbol layer configuration.
void symbolChanged()
Should be emitted whenever the sub symbol changed on this symbol layer configuration.
virtual void setContext(const QgsSymbolWidgetContext &context)
Sets the context in which the symbol widget is shown, e.g., the associated map canvas and expression ...
virtual QgsSymbolLayer * clone() const =0
Shall be reimplemented by subclasses to create a deep copy of the instance.
virtual bool setSubSymbol(QgsSymbol *symbol)
Sets layer's subsymbol. takes ownership of the passed symbol.
Property
Data definable properties.
@ LayerEnabled
Whether symbol layer is enabled.
void setPaintEffect(QgsPaintEffect *effect)
Sets the current paint effect for the layer.
QgsPaintEffect * paintEffect() const
Returns the current paint effect for the layer.
void setEnabled(bool enabled)
Sets whether symbol layer is enabled and should be drawn.
virtual QVariantMap properties() const =0
Should be reimplemented by subclasses to return a string map that contains the configuration informat...
bool enabled() const
Returns true if symbol layer is enabled and will be drawn.
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.
virtual QgsSymbol * subSymbol()
Returns the symbol's sub symbol, if present.
virtual QColor color() const
Returns the "representative" color of the symbol layer.
static const QgsPropertiesDefinition & propertyDefinitions()
Returns the symbol layer property definitions.
QgsPropertyCollection & dataDefinedProperties()
Returns a reference to the symbol layer's property collection, used for data defined overrides.
Contains settings which reflect the context in which a symbol (or renderer) widget is shown,...
QList< QgsExpressionContextScope > additionalExpressionContextScopes() const
Returns the list of additional expression context scopes to show as available within the layer.
void setSymbolType(Qgis::SymbolType type)
Sets the associated symbol type, if the widget is being shown as a subcomponent of a parent symbol co...
QgsExpressionContext * expressionContext() const
Returns the expression context used for the widget, if set.
QgsMapCanvas * mapCanvas() const
Returns the map canvas associated with the widget.
Abstract base class for all rendered symbols.
Definition qgssymbol.h:231
virtual QgsSymbol * clone() const =0
Returns a deep copy of this symbol.
Qgis::SymbolType type() const
Returns the symbol's type.
Definition qgssymbol.h:293
static QgsSymbolLayerWidget * create(QgsVectorLayer *vl)
Creates a new QgsVectorFieldSymbolLayerWidget.
Represents a vector layer which manages a vector based data sets.
#define QgsDebugError(str)
Definition qgslogger.h:38
QList< QgsSymbolLayer * > QgsSymbolLayerList
Definition qgssymbol.h:30
QgsSymbolLayerWidget *(* QgsSymbolLayerWidgetFunc)(QgsVectorLayer *)
Single variable definition for use within a QgsExpressionContextScope.