Branch data Line data Source code
1 : : /***************************************************************************
2 : : qgssymbollayerutils.h
3 : : ---------------------
4 : : begin : November 2009
5 : : copyright : (C) 2009 by Martin Dobias
6 : : email : wonder dot sk at gmail dot 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 : :
16 : :
17 : : #ifndef QGSSYMBOLLAYERUTILS_H
18 : : #define QGSSYMBOLLAYERUTILS_H
19 : :
20 : : #include "qgis_core.h"
21 : : #include "qgis_sip.h"
22 : : #include <QMap>
23 : : #include <QFont>
24 : : #include <QColor>
25 : : #include <QPainter>
26 : : #include "qgssymbol.h"
27 : : #include "qgis.h"
28 : : #include "qgsmapunitscale.h"
29 : : #include "qgscolorramp.h"
30 : : #include "qgsarrowsymbollayer.h"
31 : :
32 : : #include <QFile>
33 : :
34 : : class QgsExpression;
35 : : class QgsPathResolver;
36 : : class QgsReadWriteContext;
37 : : class QgsSymbolLayer;
38 : :
39 : : typedef QMap<QString, QString> QgsStringMap;
40 : : typedef QMap<QString, QgsSymbol * > QgsSymbolMap;
41 : : typedef QList< QPair< QColor, QString > > QgsNamedColorList SIP_SKIP;
42 : :
43 : : class QDomDocument;
44 : : class QDomElement;
45 : : class QIcon;
46 : : class QPixmap;
47 : : class QPointF;
48 : : class QSize;
49 : : class QMimeData;
50 : :
51 : : /**
52 : : * \ingroup core
53 : : * \class QgsSymbolLayerUtils
54 : : */
55 : : class CORE_EXPORT QgsSymbolLayerUtils
56 : : {
57 : : public:
58 : :
59 : : //! Editing vertex markers
60 : : enum VertexMarkerType
61 : : {
62 : : SemiTransparentCircle,
63 : : Cross,
64 : : NoMarker
65 : : };
66 : :
67 : : static QString encodeColor( const QColor &color );
68 : : static QColor decodeColor( const QString &str );
69 : :
70 : : static QString encodeSldAlpha( int alpha );
71 : : static int decodeSldAlpha( const QString &str );
72 : :
73 : : static QString encodeSldFontStyle( QFont::Style style );
74 : : static QFont::Style decodeSldFontStyle( const QString &str );
75 : :
76 : : static QString encodeSldFontWeight( int weight );
77 : : static int decodeSldFontWeight( const QString &str );
78 : :
79 : : static QString encodePenStyle( Qt::PenStyle style );
80 : : static Qt::PenStyle decodePenStyle( const QString &str );
81 : :
82 : : static QString encodePenJoinStyle( Qt::PenJoinStyle style );
83 : : static Qt::PenJoinStyle decodePenJoinStyle( const QString &str );
84 : :
85 : : static QString encodePenCapStyle( Qt::PenCapStyle style );
86 : : static Qt::PenCapStyle decodePenCapStyle( const QString &str );
87 : :
88 : : static QString encodeSldLineJoinStyle( Qt::PenJoinStyle style );
89 : : static Qt::PenJoinStyle decodeSldLineJoinStyle( const QString &str );
90 : :
91 : : static QString encodeSldLineCapStyle( Qt::PenCapStyle style );
92 : : static Qt::PenCapStyle decodeSldLineCapStyle( const QString &str );
93 : :
94 : : static QString encodeBrushStyle( Qt::BrushStyle style );
95 : : static Qt::BrushStyle decodeBrushStyle( const QString &str );
96 : :
97 : : static QString encodeSldBrushStyle( Qt::BrushStyle style );
98 : : static Qt::BrushStyle decodeSldBrushStyle( const QString &str );
99 : :
100 : : /**
101 : : * Decodes a \a value representing an arrow head type.
102 : : * \since QGIS 3.2
103 : : */
104 : : static QgsArrowSymbolLayer::HeadType decodeArrowHeadType( const QVariant &value, bool *ok SIP_OUT = nullptr );
105 : :
106 : : /**
107 : : * Decodes a \a value representing an arrow type.
108 : : * \since QGIS 3.2
109 : : */
110 : : static QgsArrowSymbolLayer::ArrowType decodeArrowType( const QVariant &value, bool *ok SIP_OUT = nullptr );
111 : :
112 : : /**
113 : : * Encodes a QPointF to a string.
114 : : * \see decodePoint()
115 : : * \see encodeSize()
116 : : */
117 : : static QString encodePoint( QPointF point );
118 : :
119 : : /**
120 : : * Decodes a QSizeF from a string.
121 : : * \see encodePoint()
122 : : * \see decodeSize()
123 : : */
124 : : static QPointF decodePoint( const QString &string );
125 : :
126 : : /**
127 : : * Converts a \a value to a point.
128 : : *
129 : : * \param value value to convert
130 : : * \param ok if specified, will be set to TRUE if value was successfully converted
131 : : *
132 : : * \returns converted point
133 : : *
134 : : * \see decodePoint()
135 : : * \see toSize()
136 : : * \since QGIS 3.10
137 : : */
138 : : static QPointF toPoint( const QVariant &value, bool *ok SIP_OUT = nullptr );
139 : :
140 : : /**
141 : : * Encodes a QSizeF to a string.
142 : : * \see decodeSize()
143 : : * \see encodePoint()
144 : : * \since QGIS 3.0
145 : : */
146 : : static QString encodeSize( QSizeF size );
147 : :
148 : : /**
149 : : * Decodes a QSizeF from a string.
150 : : * \see encodeSize()
151 : : * \see decodePoint()
152 : : * \since QGIS 3.0
153 : : */
154 : : static QSizeF decodeSize( const QString &string );
155 : :
156 : : /**
157 : : * Converts a \a value to a size.
158 : : *
159 : : * \param value value to convert
160 : : * \param ok if specified, will be set to TRUE if value was successfully converted
161 : : *
162 : : * \returns converted size
163 : : *
164 : : * \see decodeSize()
165 : : * \see toPoint()
166 : : * \since QGIS 3.10
167 : : */
168 : : static QSizeF toSize( const QVariant &value, bool *ok SIP_OUT = nullptr );
169 : :
170 : : static QString encodeMapUnitScale( const QgsMapUnitScale &mapUnitScale );
171 : : static QgsMapUnitScale decodeMapUnitScale( const QString &str );
172 : :
173 : : static QString encodeRealVector( const QVector<qreal> &v );
174 : : static QVector<qreal> decodeRealVector( const QString &s );
175 : :
176 : : static QString encodeSldRealVector( const QVector<qreal> &v );
177 : : static QVector<qreal> decodeSldRealVector( const QString &s );
178 : :
179 : : /**
180 : : * Encodes a render unit into an SLD unit of measure string.
181 : : * \param unit unit to encode
182 : : * \param scaleFactor if specified, will be set to scale factor for unit of measure
183 : : * \returns encoded string
184 : : * \see decodeSldUom()
185 : : */
186 : : static QString encodeSldUom( QgsUnitTypes::RenderUnit unit, double *scaleFactor );
187 : :
188 : : /**
189 : : * Decodes a SLD unit of measure string to a render unit.
190 : : * \param str string to decode
191 : : * \param scaleFactor if specified, will be set to scale factor for unit of measure
192 : : * \returns matching render unit
193 : : * \see encodeSldUom()
194 : : */
195 : : static QgsUnitTypes::RenderUnit decodeSldUom( const QString &str, double *scaleFactor = nullptr );
196 : :
197 : : /**
198 : : * Returns the size scaled in pixels according to the uom attribute.
199 : : * \param uom The uom attribute from SLD 1.1 version
200 : : * \param size The original size
201 : : * \returns the size in pixels
202 : : * \since QGIS 3.0
203 : : */
204 : : static double sizeInPixelsFromSldUom( const QString &uom, double size );
205 : :
206 : : static QString encodeScaleMethod( QgsSymbol::ScaleMethod scaleMethod );
207 : : static QgsSymbol::ScaleMethod decodeScaleMethod( const QString &str );
208 : :
209 : : static QPainter::CompositionMode decodeBlendMode( const QString &s );
210 : :
211 : : /**
212 : : * Returns an icon preview for a color ramp.
213 : : * \param symbol symbol
214 : : * \param size target pixmap size
215 : : * \param padding space between icon edge and symbol
216 : : * \param shape optional legend patch shape to use for rendering the preview icon
217 : : * \see symbolPreviewPixmap()
218 : : */
219 : : static QIcon symbolPreviewIcon( const QgsSymbol *symbol, QSize size, int padding = 0, QgsLegendPatchShape *shape = nullptr );
220 : :
221 : : /**
222 : : * Returns a pixmap preview for a color ramp.
223 : : * \param symbol symbol
224 : : * \param size target pixmap size
225 : : * \param padding space between icon edge and symbol
226 : : * \param customContext render context to use when rendering symbol
227 : : * \param selected set to TRUE to render the symbol in a selected state
228 : : * \param expressionContext optional custom expression context
229 : : * \param shape optional legend patch shape to use for rendering the preview icon
230 : : * \note Parameter customContext added in QGIS 2.6
231 : : * \note Parameter selected added in QGIS 3.10
232 : : * \note Parameter expressionContext added in QGIS 3.10
233 : : * \note Parameter shape added in QGIS 3.14
234 : : * \see symbolPreviewIcon()
235 : : */
236 : : static QPixmap symbolPreviewPixmap( const QgsSymbol *symbol, QSize size, int padding = 0, QgsRenderContext *customContext = nullptr, bool selected = false,
237 : : const QgsExpressionContext *expressionContext = nullptr,
238 : : const QgsLegendPatchShape *shape = nullptr );
239 : :
240 : : /**
241 : : * Draws a symbol layer preview to a QPicture
242 : : * \param layer symbol layer to draw
243 : : * \param units size units
244 : : * \param size target size of preview picture
245 : : * \param scale map unit scale for preview
246 : : * \returns QPicture containing symbol layer preview
247 : : * \see symbolLayerPreviewIcon()
248 : : * \since QGIS 2.9
249 : : */
250 : : static QPicture symbolLayerPreviewPicture( const QgsSymbolLayer *layer, QgsUnitTypes::RenderUnit units, QSize size, const QgsMapUnitScale &scale = QgsMapUnitScale() );
251 : :
252 : : /**
253 : : * Draws a symbol layer preview to an icon.
254 : : * \param layer symbol layer to draw
255 : : * \param u size units
256 : : * \param size target size of preview icon
257 : : * \param scale map unit scale for preview
258 : : * \returns icon containing symbol layer preview
259 : : * \see symbolLayerPreviewPicture()
260 : : */
261 : : static QIcon symbolLayerPreviewIcon( const QgsSymbolLayer *layer, QgsUnitTypes::RenderUnit u, QSize size, const QgsMapUnitScale &scale = QgsMapUnitScale() );
262 : :
263 : : /**
264 : : * Returns an icon preview for a color ramp.
265 : : * \param ramp color ramp
266 : : * \param size target icon size
267 : : * \param padding space between icon edge and color ramp
268 : : * \see colorRampPreviewPixmap()
269 : : */
270 : : static QIcon colorRampPreviewIcon( QgsColorRamp *ramp, QSize size, int padding = 0 );
271 : :
272 : : /**
273 : : * Returns a pixmap preview for a color ramp.
274 : : * \param ramp color ramp
275 : : * \param size target pixmap size
276 : : * \param padding space between icon edge and color ramp
277 : : * \param direction direction to render pixmap (since QGIS 3.18)
278 : : * \param flipDirection set to TRUE to flip the direction of the ramp. For horizontal \a directions, ramps will be
279 : : * rendered left to right by default. For vertical \a directions, ramps will be rendered top to bottom by default. Setting
280 : : * this flag to TRUE will reverse these default directions.
281 : : * \param drawTransparentBackground set to FALSE to disable the checkerboard effect drawn below transparent colors in the ramp
282 : : * \see colorRampPreviewIcon()
283 : : */
284 : : static QPixmap colorRampPreviewPixmap( QgsColorRamp *ramp, QSize size, int padding = 0, Qt::Orientation direction = Qt::Horizontal,
285 : : bool flipDirection = false, bool drawTransparentBackground = true );
286 : :
287 : : static void drawStippledBackground( QPainter *painter, QRect rect );
288 : :
289 : : /**
290 : : * Draws a vertex symbol at (painter) coordinates x, y. (Useful to assist vertex editing.)
291 : : * \since QGIS 3.4.5
292 : : */
293 : : static void drawVertexMarker( double x, double y, QPainter &p, QgsSymbolLayerUtils::VertexMarkerType type, int markerSize );
294 : :
295 : : //! Returns the maximum estimated bleed for the symbol
296 : : static double estimateMaxSymbolBleed( QgsSymbol *symbol, const QgsRenderContext &context );
297 : :
298 : : /**
299 : : * Attempts to load a symbol from a DOM element
300 : : * \param element DOM element representing symbol
301 : : * \param context object to transform relative to absolute paths
302 : : * \returns decoded symbol, if possible
303 : : */
304 : : static QgsSymbol *loadSymbol( const QDomElement &element, const QgsReadWriteContext &context ) SIP_FACTORY;
305 : :
306 : : /**
307 : : * Attempts to load a symbol from a DOM element and cast it to a particular symbol
308 : : * type.
309 : : * \param element DOM element representing symbol
310 : : * \param context object to transform relative to absolute paths
311 : : * \returns decoded symbol cast to specified type, if possible
312 : : * \note not available in Python bindings
313 : : */
314 : 0 : template <class SymbolType> static SymbolType *loadSymbol( const QDomElement &element, const QgsReadWriteContext &context ) SIP_SKIP
315 : : {
316 : 0 : QgsSymbol *tmpSymbol = QgsSymbolLayerUtils::loadSymbol( element, context );
317 : 0 : SymbolType *symbolCastToType = dynamic_cast<SymbolType *>( tmpSymbol );
318 : :
319 : 0 : if ( symbolCastToType )
320 : : {
321 : 0 : return symbolCastToType;
322 : : }
323 : : else
324 : : {
325 : : //could not cast
326 : 0 : delete tmpSymbol;
327 : 0 : return nullptr;
328 : : }
329 : 0 : }
330 : :
331 : : //! Reads and returns symbol layer from XML. Caller is responsible for deleting the returned object
332 : : static QgsSymbolLayer *loadSymbolLayer( QDomElement &element, const QgsReadWriteContext &context ) SIP_FACTORY;
333 : : //! Writes a symbol definition to XML
334 : : static QDomElement saveSymbol( const QString &symbolName, const QgsSymbol *symbol, QDomDocument &doc, const QgsReadWriteContext &context );
335 : :
336 : : /**
337 : : * Returns a string representing the symbol. Can be used to test for equality
338 : : * between symbols.
339 : : * \since QGIS 2.12
340 : : */
341 : : static QString symbolProperties( QgsSymbol *symbol );
342 : :
343 : : static bool createSymbolLayerListFromSld( QDomElement &element, QgsWkbTypes::GeometryType geomType, QgsSymbolLayerList &layers );
344 : :
345 : : static QgsSymbolLayer *createFillLayerFromSld( QDomElement &element ) SIP_FACTORY;
346 : : static QgsSymbolLayer *createLineLayerFromSld( QDomElement &element ) SIP_FACTORY;
347 : : static QgsSymbolLayer *createMarkerLayerFromSld( QDomElement &element ) SIP_FACTORY;
348 : :
349 : : static bool convertPolygonSymbolizerToPointMarker( QDomElement &element, QgsSymbolLayerList &layerList );
350 : : static bool hasExternalGraphic( QDomElement &element );
351 : : static bool hasWellKnownMark( QDomElement &element );
352 : :
353 : : static bool needFontMarker( QDomElement &element );
354 : : static bool needSvgMarker( QDomElement &element );
355 : : static bool needEllipseMarker( QDomElement &element );
356 : : static bool needMarkerLine( QDomElement &element );
357 : : static bool needLinePatternFill( QDomElement &element );
358 : : static bool needPointPatternFill( QDomElement &element );
359 : : static bool needSvgFill( QDomElement &element );
360 : :
361 : : static void fillToSld( QDomDocument &doc, QDomElement &element,
362 : : Qt::BrushStyle brushStyle, const QColor &color = QColor() );
363 : : static bool fillFromSld( QDomElement &element,
364 : : Qt::BrushStyle &brushStyle, QColor &color );
365 : :
366 : : //! \note not available in Python bindings
367 : : static void lineToSld( QDomDocument &doc, QDomElement &element,
368 : : Qt::PenStyle penStyle, const QColor &color, double width = -1,
369 : : const Qt::PenJoinStyle *penJoinStyle = nullptr, const Qt::PenCapStyle *penCapStyle = nullptr,
370 : : const QVector<qreal> *customDashPattern = nullptr, double dashOffset = 0.0 ) SIP_SKIP;
371 : : static bool lineFromSld( QDomElement &element,
372 : : Qt::PenStyle &penStyle, QColor &color, double &width,
373 : : Qt::PenJoinStyle *penJoinStyle = nullptr, Qt::PenCapStyle *penCapStyle = nullptr,
374 : : QVector<qreal> *customDashPattern = nullptr, double *dashOffset = nullptr );
375 : :
376 : : static void externalGraphicToSld( QDomDocument &doc, QDomElement &element,
377 : : const QString &path, const QString &mime,
378 : : const QColor &color, double size = -1 );
379 : : static bool externalGraphicFromSld( QDomElement &element,
380 : : QString &path, QString &mime,
381 : : QColor &color, double &size );
382 : :
383 : : static void wellKnownMarkerToSld( QDomDocument &doc, QDomElement &element,
384 : : const QString &name, const QColor &color, const QColor &strokeColor, Qt::PenStyle strokeStyle,
385 : : double strokeWidth = -1, double size = -1 );
386 : :
387 : : //! \note available in Python as wellKnownMarkerFromSld2
388 : : static bool wellKnownMarkerFromSld( QDomElement &element,
389 : : QString &name, QColor &color, QColor &strokeColor, Qt::PenStyle &strokeStyle,
390 : : double &strokeWidth, double &size ) SIP_PYNAME( wellKnownMarkerFromSld2 );
391 : :
392 : : static void externalMarkerToSld( QDomDocument &doc, QDomElement &element,
393 : : const QString &path, const QString &format, int *markIndex = nullptr,
394 : : const QColor &color = QColor(), double size = -1 );
395 : : static bool externalMarkerFromSld( QDomElement &element,
396 : : QString &path, QString &format, int &markIndex,
397 : : QColor &color, double &size );
398 : :
399 : :
400 : : static void labelTextToSld( QDomDocument &doc, QDomElement &element, const QString &label,
401 : : const QFont &font, const QColor &color = QColor(), double size = -1 );
402 : :
403 : : //! Create ogr feature style string for pen
404 : : static QString ogrFeatureStylePen( double width, double mmScaleFactor, double mapUnitsScaleFactor, const QColor &c,
405 : : Qt::PenJoinStyle joinStyle = Qt::MiterJoin,
406 : : Qt::PenCapStyle capStyle = Qt::FlatCap,
407 : : double offset = 0.0,
408 : : const QVector<qreal> *dashPattern = nullptr );
409 : :
410 : : /**
411 : : * Create ogr feature style string for brush
412 : : * \param fillColr fill color
413 : : */
414 : : static QString ogrFeatureStyleBrush( const QColor &fillColr );
415 : :
416 : : static void createRotationElement( QDomDocument &doc, QDomElement &element, const QString &rotationFunc );
417 : : static bool rotationFromSldElement( QDomElement &element, QString &rotationFunc );
418 : :
419 : : static void createOpacityElement( QDomDocument &doc, QDomElement &element, const QString &alphaFunc );
420 : : static bool opacityFromSldElement( QDomElement &element, QString &alphaFunc );
421 : :
422 : : static void createDisplacementElement( QDomDocument &doc, QDomElement &element, QPointF offset );
423 : : static bool displacementFromSldElement( QDomElement &element, QPointF &offset );
424 : :
425 : : /**
426 : : * \brief Creates a SE 1.1 anchor point element as a child of the specified element
427 : : * \param doc The document
428 : : * \param element The parent element
429 : : * \param anchor An anchor specification, with values between 0 and 1
430 : : */
431 : : static void createAnchorPointElement( QDomDocument &doc, QDomElement &element, QPointF anchor );
432 : :
433 : : static void createOnlineResourceElement( QDomDocument &doc, QDomElement &element, const QString &path, const QString &format );
434 : : static bool onlineResourceFromSldElement( QDomElement &element, QString &path, QString &format );
435 : :
436 : : static void createGeometryElement( QDomDocument &doc, QDomElement &element, const QString &geomFunc );
437 : : static bool geometryFromSldElement( QDomElement &element, QString &geomFunc );
438 : :
439 : : /**
440 : : * Creates a OGC Expression element based on the provided function expression
441 : : * \param doc The document owning the element
442 : : * \param element The element parent
443 : : * \param function The expression to be encoded
444 : : */
445 : : static bool createExpressionElement( QDomDocument &doc, QDomElement &element, const QString &function );
446 : : static bool createFunctionElement( QDomDocument &doc, QDomElement &element, const QString &function );
447 : : static bool functionFromSldElement( QDomElement &element, QString &function );
448 : :
449 : : static QDomElement createSvgParameterElement( QDomDocument &doc, const QString &name, const QString &value );
450 : : static QgsStringMap getSvgParameterList( QDomElement &element );
451 : :
452 : : static QDomElement createVendorOptionElement( QDomDocument &doc, const QString &name, const QString &value );
453 : : static QgsStringMap getVendorOptionList( QDomElement &element );
454 : :
455 : : //! Parses the properties from XML and returns a map
456 : : static QVariantMap parseProperties( const QDomElement &element );
457 : : //! Saves the map of properties to XML
458 : : static void saveProperties( QVariantMap props, QDomDocument &doc, QDomElement &element );
459 : :
460 : : //! Reads a collection of symbols from XML and returns them in a map. Caller is responsible for deleting returned symbols.
461 : : static QgsSymbolMap loadSymbols( QDomElement &element, const QgsReadWriteContext &context ) SIP_FACTORY;
462 : : //! Writes a collection of symbols to XML with specified tagName for the top-level element
463 : : static QDomElement saveSymbols( QgsSymbolMap &symbols, const QString &tagName, QDomDocument &doc, const QgsReadWriteContext &context );
464 : :
465 : : static void clearSymbolMap( QgsSymbolMap &symbols );
466 : :
467 : : /**
468 : : * Creates new mime data from a \a symbol.
469 : : * This also sets the mime color data to match the symbol's color, so that copied symbols
470 : : * can be paste in places where a color is expected.
471 : : * \see symbolFromMimeData()
472 : : * \since QGIS 3.0
473 : : */
474 : : static QMimeData *symbolToMimeData( const QgsSymbol *symbol ) SIP_FACTORY;
475 : :
476 : : /**
477 : : * Attempts to parse \a mime data as a symbol. A new symbol instance will be returned
478 : : * if the data was successfully converted to a symbol.
479 : : * \see symbolToMimeData()
480 : : * \since QGIS 3.0
481 : : */
482 : : static QgsSymbol *symbolFromMimeData( const QMimeData *data ) SIP_FACTORY;
483 : :
484 : : /**
485 : : * Creates a color ramp from the settings encoded in an XML element
486 : : * \param element DOM element
487 : : * \returns new color ramp. Caller takes responsibility for deleting the returned value.
488 : : * \see saveColorRamp()
489 : : */
490 : : static QgsColorRamp *loadColorRamp( QDomElement &element ) SIP_FACTORY;
491 : :
492 : : /**
493 : : * Encodes a color ramp's settings to an XML element
494 : : * \param name name of ramp
495 : : * \param ramp color ramp to save
496 : : * \param doc XML document
497 : : * \returns DOM element representing state of color ramp
498 : : * \see loadColorRamp()
499 : : */
500 : : static QDomElement saveColorRamp( const QString &name, QgsColorRamp *ramp, QDomDocument &doc );
501 : :
502 : : /**
503 : : * Saves a color ramp to a QVariantMap, wrapped in a QVariant.
504 : : * You can use QgsXmlUtils::writeVariant to save it to an XML document.
505 : : *
506 : : * \see loadColorRamp( const QVariant &value )
507 : : */
508 : : static QVariant colorRampToVariant( const QString &name, QgsColorRamp *ramp );
509 : :
510 : : /**
511 : : * Load a color ramp from a QVariantMap, wrapped in a QVariant.
512 : : * You can use QgsXmlUtils::readVariant to load it from an XML document.
513 : : *
514 : : * \see colorRampToVariant()
515 : : */
516 : : static QgsColorRamp *loadColorRamp( const QVariant &value ) SIP_FACTORY;
517 : :
518 : : /**
519 : : * Returns a friendly display name for a color
520 : : * \param color source color
521 : : * \returns display name for color
522 : : * \since QGIS 2.5
523 : : */
524 : : static QString colorToName( const QColor &color );
525 : :
526 : : /**
527 : : * Attempts to parse a string as a list of colors using a variety of common formats, including hex
528 : : * codes, rgb and rgba strings.
529 : : * \param colorStr string representing the color list
530 : : * \returns list of parsed colors
531 : : * \since QGIS 2.5
532 : : */
533 : : static QList< QColor > parseColorList( const QString &colorStr );
534 : :
535 : : /**
536 : : * Creates mime data from a color. Sets both the mime data's color data, and the
537 : : * mime data's text with the color's hex code.
538 : : * \param color color to encode as mime data
539 : : * \see colorFromMimeData
540 : : * \since QGIS 2.5
541 : : */
542 : : static QMimeData *colorToMimeData( const QColor &color ) SIP_FACTORY;
543 : :
544 : : /**
545 : : * Attempts to parse mime data as a color
546 : : * \param data mime data to parse
547 : : * \param hasAlpha will be set to TRUE if mime data was interpreted as a color containing
548 : : * an explicit alpha value
549 : : * \returns valid color if mimedata could be interpreted as a color, otherwise an invalid color
550 : : * \since QGIS 2.5
551 : : */
552 : : static QColor colorFromMimeData( const QMimeData *data, bool &hasAlpha SIP_OUT );
553 : :
554 : : /**
555 : : * Attempts to parse mime data as a list of named colors
556 : : * \param data mime data to parse
557 : : * \returns list of parsed colors
558 : : * \since QGIS 2.5
559 : : */
560 : : static QgsNamedColorList colorListFromMimeData( const QMimeData *data );
561 : :
562 : : /**
563 : : * Creates mime data from a list of named colors
564 : : * \param colorList list of named colors
565 : : * \param allFormats set to TRUE to include additional mime formats, include text/plain and application/x-color
566 : : * \returns mime data containing encoded colors
567 : : * \since QGIS 2.5
568 : : */
569 : : static QMimeData *colorListToMimeData( const QgsNamedColorList &colorList, bool allFormats = true ) SIP_FACTORY;
570 : :
571 : : /**
572 : : * Exports colors to a gpl GIMP palette file
573 : : * \param file destination file
574 : : * \param paletteName name of palette, which is stored in gpl file
575 : : * \param colors colors to export
576 : : * \returns TRUE if export was successful
577 : : * \see importColorsFromGpl
578 : : */
579 : : static bool saveColorsToGpl( QFile &file, const QString &paletteName, const QgsNamedColorList &colors );
580 : :
581 : : /**
582 : : * Imports colors from a gpl GIMP palette file
583 : : * \param file source gpl file
584 : : * \param ok will be TRUE if file was successfully read
585 : : * \param name will be set to palette name from gpl file, if present
586 : : * \returns list of imported colors
587 : : * \see saveColorsToGpl
588 : : */
589 : : static QgsNamedColorList importColorsFromGpl( QFile &file, bool &ok, QString &name );
590 : :
591 : : /**
592 : : * Attempts to parse a string as a color using a variety of common formats, including hex
593 : : * codes, rgb and rgba strings.
594 : : * \param colorStr string representing the color
595 : : * \param strictEval set to TRUE for stricter color parsing rules
596 : : * \returns parsed color
597 : : * \since QGIS 2.3
598 : : */
599 : : static QColor parseColor( const QString &colorStr, bool strictEval = false );
600 : :
601 : : /**
602 : : * Attempts to parse a string as a color using a variety of common formats, including hex
603 : : * codes, rgb and rgba, hsl and hsla strings.
604 : : * \param colorStr string representing the color
605 : : * \param containsAlpha if colorStr contains an explicit alpha value then containsAlpha will be set to TRUE
606 : : * \param strictEval set to TRUE for stricter color parsing rules
607 : : * \returns parsed color
608 : : * \since QGIS 2.3
609 : : */
610 : : static QColor parseColorWithAlpha( const QString &colorStr, bool &containsAlpha, bool strictEval = false );
611 : :
612 : : /**
613 : : * Multiplies opacity of image pixel values with a (global) transparency value.
614 : : */
615 : : static void multiplyImageOpacity( QImage *image, qreal opacity );
616 : :
617 : : //! Blurs an image in place, e.g. creating Qt-independent drop shadows
618 : : static void blurImageInPlace( QImage &image, QRect rect, int radius, bool alphaOnly );
619 : :
620 : : /**
621 : : * Converts a QColor into a premultiplied ARGB QColor value using a specified alpha value
622 : : * \since QGIS 2.3
623 : : */
624 : : static void premultiplyColor( QColor &rgb, int alpha );
625 : :
626 : : //! Sorts the passed list in requested order
627 : : static void sortVariantList( QList<QVariant> &list, Qt::SortOrder order );
628 : : //! Returns a point on the line from startPoint to directionPoint that is a certain distance away from the starting point
629 : : static QPointF pointOnLineWithDistance( QPointF startPoint, QPointF directionPoint, double distance );
630 : :
631 : : //! Returns a list of all available svg files
632 : : static QStringList listSvgFiles();
633 : :
634 : : //! Returns a list of svg files at the specified directory
635 : : static QStringList listSvgFilesAt( const QString &directory );
636 : :
637 : : /**
638 : : * Determines an SVG symbol's path from its \a name.
639 : : * If \a name is not an absolute path the file is scanned for in the SVG paths specified
640 : : * in settings svg/searchPathsForSVG.
641 : : * \see svgSymbolPathToName()
642 : : */
643 : : static QString svgSymbolNameToPath( const QString &name, const QgsPathResolver &pathResolver );
644 : :
645 : : /**
646 : : * Determines an SVG symbol's name from its \a path.
647 : : * \see svgSymbolNameToPath()
648 : : */
649 : : static QString svgSymbolPathToName( const QString &path, const QgsPathResolver &pathResolver );
650 : :
651 : : //! Calculate the centroid point of a QPolygonF
652 : : static QPointF polygonCentroid( const QPolygonF &points );
653 : :
654 : : //! Calculate a point on the surface of a QPolygonF
655 : : static QPointF polygonPointOnSurface( const QPolygonF &points, const QVector<QPolygonF> *rings = nullptr );
656 : :
657 : : //! Calculate whether a point is within of a QPolygonF
658 : : static bool pointInPolygon( const QPolygonF &points, QPointF point );
659 : :
660 : : /**
661 : : * Returns the total length of a \a polyline.
662 : : *
663 : : * \since QGIS 3.20
664 : : */
665 : : static double polylineLength( const QPolygonF &polyline );
666 : :
667 : : /**
668 : : * Returns the substring of a \a polyline which starts at \a startOffset from the beginning of the line
669 : : * and ends at \a endOffset from the start of the line.
670 : : *
671 : : * If \a startOffset is less than 0, then the start point will be calculated by subtracting that distance
672 : : * from the end of the line. Similarly, if \a endOffset is less than zero then the end point will be subtracted
673 : : * from the end of the line.
674 : : *
675 : : * May return an empty linestring if the substring is zero length.
676 : : *
677 : : * \since QGIS 3.16
678 : : */
679 : : static QPolygonF polylineSubstring( const QPolygonF &polyline, double startOffset, double endOffset );
680 : :
681 : : /**
682 : : * Returns TRUE if the angle formed by the line \a p1 - \a p2 - \a p3 forms a "sharp" corner.
683 : : *
684 : : * Sharp corners form an angle which exceeds a 45 degree threshold.
685 : : *
686 : : * \since QGIS 3.16
687 : : */
688 : : static bool isSharpCorner( QPointF p1, QPointF p2, QPointF p3 );
689 : :
690 : : /**
691 : : * Appends a polyline \a line to an existing \a target polyline.
692 : : *
693 : : * Any duplicate points at the start \a line which match the end point from \a target will be skipped.
694 : : *
695 : : * \since QGIS 3.16
696 : : */
697 : : static void appendPolyline( QPolygonF &target, const QPolygonF &line );
698 : :
699 : : /**
700 : : * Returns a new valid expression instance for given field or expression string.
701 : : * If the input is not a valid expression, it is assumed that it is a field name and gets properly quoted.
702 : : * If the string is empty, returns NULLPTR.
703 : : * This is useful when accepting input which could be either a non-quoted field name or expression.
704 : : * \since QGIS 2.2
705 : : */
706 : : static QgsExpression *fieldOrExpressionToExpression( const QString &fieldOrExpression ) SIP_FACTORY;
707 : :
708 : : /**
709 : : * Returns a field name if the whole expression is just a name of the field .
710 : : * Returns full expression string if the expression is more complex than just one field.
711 : : * Using just expression->expression() method may return quoted field name, but that is not
712 : : * wanted for saving (due to backward compatibility) or display in GUI.
713 : : * \since QGIS 2.2
714 : : */
715 : : static QString fieldOrExpressionFromExpression( QgsExpression *expression );
716 : :
717 : : /**
718 : : * Computes a sequence of about 'classes' equally spaced round values
719 : : * which cover the range of values from 'minimum' to 'maximum'.
720 : : * The values are chosen so that they are 1, 2 or 5 times a power of 10.
721 : : * \since QGIS 2.10
722 : : */
723 : : static QList<double> prettyBreaks( double minimum, double maximum, int classes );
724 : :
725 : : /**
726 : : * Rescales the given size based on the uomScale found in the props, if any is found, otherwise
727 : : * returns the value un-modified
728 : : * \since QGIS 3.0
729 : : */
730 : : static double rescaleUom( double size, QgsUnitTypes::RenderUnit unit, const QVariantMap &props );
731 : :
732 : : /**
733 : : * Rescales the given point based on the uomScale found in the props, if any is found, otherwise
734 : : * returns a copy of the original point
735 : : * \since QGIS 3.0
736 : : */
737 : : static QPointF rescaleUom( QPointF point, QgsUnitTypes::RenderUnit unit, const QVariantMap &props ) SIP_PYNAME( rescalePointUom );
738 : :
739 : : /**
740 : : * Rescales the given array based on the uomScale found in the props, if any is found, otherwise
741 : : * returns a copy of the original point
742 : : * \since QGIS 3.0
743 : : */
744 : : static QVector<qreal> rescaleUom( const QVector<qreal> &array, QgsUnitTypes::RenderUnit unit, const QVariantMap &props ) SIP_PYNAME( rescaleArrayUom );
745 : :
746 : : /**
747 : : * Checks if the properties contain scaleMinDenom and scaleMaxDenom, if available, they are added into the SE Rule element
748 : : * \since QGIS 3.0
749 : : */
750 : : static void applyScaleDependency( QDomDocument &doc, QDomElement &ruleElem, QVariantMap &props );
751 : :
752 : : /**
753 : : * Merges the local scale limits, if any, with the ones already in the map, if any
754 : : * \since QGIS 3.0
755 : : */
756 : : static void mergeScaleDependencies( double mScaleMinDenom, double mScaleMaxDenom, QVariantMap &props );
757 : :
758 : : /**
759 : : * Encodes a reference to a parametric SVG into SLD, as a succession of parametric SVG using URL parameters,
760 : : * a fallback SVG without parameters, and a final fallback as a mark with the right colors and stroke for systems
761 : : * that cannot do SVG at all
762 : : * \since QGIS 3.0
763 : : */
764 : : static void parametricSvgToSld( QDomDocument &doc, QDomElement &graphicElem,
765 : : const QString &path,
766 : : const QColor &fillColor, double size, const QColor &strokeColor, double strokeWidth );
767 : :
768 : : /**
769 : : * Encodes a reference to a parametric SVG into a path with parameters according to the SVG Parameters spec
770 : : * \since QGIS 3.0
771 : : */
772 : : static QString getSvgParametricPath( const QString &basePath, const QColor &fillColor, const QColor &strokeColor, double strokeWidth );
773 : :
774 : : /**
775 : : * Converts a set of symbol layer id to a set of pointers to actual symbol layers carried by the feature renderer.
776 : : * \since QGIS 3.12
777 : : */
778 : : static QSet<const QgsSymbolLayer *> toSymbolLayerPointers( QgsFeatureRenderer *renderer, const QSet<QgsSymbolLayerId> &symbolLayerIds );
779 : :
780 : : /**
781 : : * \brief Creates a new symbol with size restricted to min/max size if original size is out of min/max range
782 : : * \param s the original symbol
783 : : * \param minSize the minimum size in mm
784 : : * \param maxSize the maximum size in mm
785 : : * \param context the render context
786 : : * \param width expected width, can be changed by the function
787 : : * \param height expected height, can be changed by this function
788 : : * \return 0 if size is within minSize/maxSize range. New symbol if size was out of min/max range. Caller takes ownership
789 : : */
790 : : static QgsSymbol *restrictedSizeSymbol( const QgsSymbol *s, double minSize, double maxSize, QgsRenderContext *context, double &width, double &height );
791 : :
792 : : /**
793 : : * Evaluates a map of properties using the given \a context and returns a variant map with evaluated expressions from the properties.
794 : : * \since QGIS 3.18
795 : : */
796 : : static QgsStringMap evaluatePropertiesMap( const QMap<QString, QgsProperty> &propertiesMap, const QgsExpressionContext &context );
797 : : };
798 : :
799 : : class QPolygonF;
800 : :
801 : : //! calculate geometry shifted by a specified distance
802 : : QList<QPolygonF> offsetLine( QPolygonF polyline, double dist, QgsWkbTypes::GeometryType geometryType ) SIP_SKIP;
803 : :
804 : : #endif
805 : :
806 : :
|
