Branch data Line data Source code
1 : : /***************************************************************************
2 : : qgscolorramp.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 : : #ifndef QGSCOLORRAMP_H
17 : : #define QGSCOLORRAMP_H
18 : :
19 : : #include "qgis_core.h"
20 : : #include <QColor>
21 : : #include <QGradient>
22 : : #include "qgis.h"
23 : : #include "qgscolorscheme.h"
24 : :
25 : : /**
26 : : * \ingroup core
27 : : * \class QgsColorRamp
28 : : * \brief Abstract base class for color ramps
29 : : * \since QGIS 3.0
30 : : */
31 : 345 : class CORE_EXPORT QgsColorRamp
32 : : {
33 : :
34 : : #ifdef SIP_RUN
35 : : SIP_CONVERT_TO_SUBCLASS_CODE
36 : : if ( sipCpp->type() == QgsGradientColorRamp::typeString() )
37 : : sipType = sipType_QgsGradientColorRamp;
38 : : else if ( sipCpp->type() == QgsLimitedRandomColorRamp::typeString() )
39 : : sipType = sipType_QgsLimitedRandomColorRamp;
40 : : else if ( sipCpp->type() == QgsRandomColorRamp::typeString() )
41 : : sipType = sipType_QgsRandomColorRamp;
42 : : else if ( sipCpp->type() == QgsPresetSchemeColorRamp::typeString() )
43 : : sipType = sipType_QgsPresetSchemeColorRamp;
44 : : else if ( sipCpp->type() == QgsColorBrewerColorRamp::typeString() )
45 : : sipType = sipType_QgsColorBrewerColorRamp;
46 : : else if ( sipCpp->type() == QgsCptCityColorRamp::typeString() )
47 : : sipType = sipType_QgsCptCityColorRamp;
48 : : else
49 : : sipType = 0;
50 : : SIP_END
51 : : #endif
52 : : public:
53 : :
54 : 235 : virtual ~QgsColorRamp() = default;
55 : :
56 : : /**
57 : : * Returns number of defined colors, or -1 if undefined
58 : : */
59 : : virtual int count() const = 0;
60 : :
61 : : /**
62 : : * Returns relative value between [0,1] of color at specified index
63 : : */
64 : : virtual double value( int index ) const = 0;
65 : :
66 : : /**
67 : : * Returns the color corresponding to a specified value.
68 : : * \param value value between [0, 1] inclusive
69 : : * \returns color for value
70 : : */
71 : : virtual QColor color( double value ) const = 0;
72 : :
73 : : /**
74 : : * Returns a string representing the color ramp type.
75 : : */
76 : : virtual QString type() const = 0;
77 : :
78 : :
79 : : /**
80 : : * Inverts the ordering of the color ramp.
81 : : */
82 : 0 : virtual void invert() {}
83 : :
84 : : /**
85 : : * Creates a clone of the color ramp.
86 : : */
87 : : virtual QgsColorRamp *clone() const = 0 SIP_FACTORY;
88 : :
89 : : /**
90 : : * Returns a string map containing all the color ramp's properties.
91 : : */
92 : : virtual QVariantMap properties() const = 0;
93 : :
94 : : /**
95 : : * Returns a list of available ramp types, where the first value in each item is the QgsColorRamp::type() string
96 : : * and the second is a user friendly, translated name for the color ramp type.
97 : : *
98 : : * The ramp types are returned in a order of precedence for exposing in UI, with more commonly used types
99 : : * listed first.
100 : : *
101 : : * \since QGIS 3.16
102 : : */
103 : : static QList< QPair< QString, QString > > rampTypes();
104 : : };
105 : :
106 : : /**
107 : : * \ingroup core
108 : : * \class QgsGradientStop
109 : : * \brief Represents a color stop within a QgsGradientColorRamp color ramp.
110 : : * \since QGIS 3.0
111 : : */
112 : 1740 : class CORE_EXPORT QgsGradientStop
113 : : {
114 : : public:
115 : :
116 : : /**
117 : : * Constructor for QgsGradientStop
118 : : * \param offset positional offset for stop, between 0 and 1.0
119 : : * \param color color for stop
120 : : */
121 : 1740 : QgsGradientStop( double offset, const QColor &color )
122 : 1740 : : offset( offset )
123 : 1740 : , color( color )
124 : 1740 : { }
125 : :
126 : : //! Relative positional offset, between 0 and 1
127 : : double offset;
128 : : //! Gradient color at stop
129 : : QColor color;
130 : :
131 : : bool operator==( const QgsGradientStop &other ) const
132 : : {
133 : : return other.color == color && qgsDoubleNear( other.offset, offset );
134 : : }
135 : : };
136 : :
137 : : //! List of gradient stops
138 : : typedef QList<QgsGradientStop> QgsGradientStopsList;
139 : :
140 : : #define DEFAULT_GRADIENT_COLOR1 QColor(0,0,255)
141 : : #define DEFAULT_GRADIENT_COLOR2 QColor(0,255,0)
142 : :
143 : : /**
144 : : * \ingroup core
145 : : * \class QgsGradientColorRamp
146 : : * \brief Gradient color ramp, which smoothly interpolates between two colors and also
147 : : * supports optional extra color stops.
148 : : * \since QGIS 3.0
149 : : */
150 : 470 : class CORE_EXPORT QgsGradientColorRamp : public QgsColorRamp
151 : : {
152 : : public:
153 : :
154 : : /**
155 : : * Constructor for QgsGradientColorRamp
156 : : * \param color1 start color, corresponding to a position of 0.0
157 : : * \param color2 end color, corresponding to a position of 1.0
158 : : * \param discrete set to TRUE for discrete interpolation instead of smoothly
159 : : * interpolating between colors
160 : : * \param stops optional list of additional color stops
161 : : */
162 : : QgsGradientColorRamp( const QColor &color1 = DEFAULT_GRADIENT_COLOR1,
163 : : const QColor &color2 = DEFAULT_GRADIENT_COLOR2,
164 : : bool discrete = false,
165 : : const QgsGradientStopsList &stops = QgsGradientStopsList() );
166 : :
167 : : //! Creates a new QgsColorRamp from a map of properties
168 : : static QgsColorRamp *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
169 : :
170 : 0 : int count() const override { return mStops.count() + 2; }
171 : : double value( int index ) const override;
172 : : QColor color( double value ) const override;
173 : :
174 : : /**
175 : : * Returns the string identifier for QgsGradientColorRamp.
176 : : *
177 : : * \since QGIS 3.16
178 : : */
179 : 310 : static QString typeString() { return QStringLiteral( "gradient" ); }
180 : :
181 : : QString type() const override;
182 : : void invert() override;
183 : : QgsGradientColorRamp *clone() const override SIP_FACTORY;
184 : : QVariantMap properties() const override;
185 : :
186 : : /**
187 : : * Returns the gradient start color.
188 : : * \see setColor1()
189 : : * \see color2()
190 : : */
191 : 0 : QColor color1() const { return mColor1; }
192 : :
193 : : /**
194 : : * Returns the gradient end color.
195 : : * \see setColor2()
196 : : * \see color1()
197 : : */
198 : 0 : QColor color2() const { return mColor2; }
199 : :
200 : : /**
201 : : * Sets the gradient start color.
202 : : * \param color start color
203 : : * \see color1()
204 : : * \see setColor2()
205 : : */
206 : 0 : void setColor1( const QColor &color ) { mColor1 = color; }
207 : :
208 : : /**
209 : : * Sets the gradient end color.
210 : : * \param color end color
211 : : * \see color2()
212 : : * \see setColor1()
213 : : */
214 : 0 : void setColor2( const QColor &color ) { mColor2 = color; }
215 : :
216 : : /**
217 : : * Returns TRUE if the gradient is using discrete interpolation, rather than
218 : : * smoothly interpolating between colors.
219 : : * \see setDiscrete()
220 : : */
221 : 0 : bool isDiscrete() const { return mDiscrete; }
222 : :
223 : : /**
224 : : * Sets whether the gradient should use discrete interpolation, rather than
225 : : * smoothly interpolating between colors.
226 : : * \param discrete set to TRUE to use discrete interpolation
227 : : * \see convertToDiscrete()
228 : : * \see isDiscrete()
229 : : */
230 : : void setDiscrete( bool discrete ) { mDiscrete = discrete; }
231 : :
232 : : /**
233 : : * Converts a gradient with existing color stops to or from discrete
234 : : * interpolation.
235 : : * \param discrete set to TRUE to convert the gradient stops to discrete,
236 : : * or FALSE to convert them to smooth interpolation
237 : : * \see isDiscrete()
238 : : */
239 : : void convertToDiscrete( bool discrete );
240 : :
241 : : /**
242 : : * Sets the list of intermediate gradient stops for the ramp.
243 : : * \param stops list of stops. Any existing color stops will be replaced. The stop
244 : : * list will be automatically reordered so that stops are listed in ascending offset
245 : : * order.
246 : : * \see stops()
247 : : */
248 : : void setStops( const QgsGradientStopsList &stops );
249 : :
250 : : /**
251 : : * Returns the list of intermediate gradient stops for the ramp.
252 : : * \see setStops()
253 : : */
254 : 0 : QgsGradientStopsList stops() const { return mStops; }
255 : :
256 : : /**
257 : : * Returns any additional info attached to the gradient ramp (e.g., authorship notes)
258 : : * \see setInfo()
259 : : */
260 : : QgsStringMap info() const { return mInfo; }
261 : :
262 : : /**
263 : : * Sets additional info to attach to the gradient ramp (e.g., authorship notes)
264 : : * \param info map of string info to attach
265 : : * \see info()
266 : : */
267 : 345 : void setInfo( const QgsStringMap &info ) { mInfo = info; }
268 : :
269 : : /**
270 : : * Copy color ramp stops to a QGradient
271 : : * \param gradient gradient to copy stops into
272 : : * \param opacity opacity multiplier. Opacity of colors will be multiplied
273 : : * by this factor before adding to the gradient.
274 : : * \since QGIS 2.1
275 : : */
276 : : void addStopsToGradient( QGradient *gradient, double opacity = 1 );
277 : :
278 : : protected:
279 : : QColor mColor1;
280 : : QColor mColor2;
281 : : bool mDiscrete;
282 : : QgsGradientStopsList mStops;
283 : : QgsStringMap mInfo;
284 : : };
285 : :
286 : 0 : Q_DECLARE_METATYPE( QgsGradientColorRamp )
287 : :
288 : : #define DEFAULT_RANDOM_COUNT 10
289 : : #define DEFAULT_RANDOM_HUE_MIN 0
290 : : #define DEFAULT_RANDOM_HUE_MAX 359
291 : : #define DEFAULT_RANDOM_VAL_MIN 200
292 : : #define DEFAULT_RANDOM_VAL_MAX 240
293 : : #define DEFAULT_RANDOM_SAT_MIN 100
294 : : #define DEFAULT_RANDOM_SAT_MAX 240
295 : :
296 : : /**
297 : : * \ingroup core
298 : : * \class QgsLimitedRandomColorRamp
299 : : * \brief Constrained random color ramp, which returns random colors based on preset parameters.
300 : : * \since QGIS 3.0
301 : : */
302 : 0 : class CORE_EXPORT QgsLimitedRandomColorRamp : public QgsColorRamp
303 : : {
304 : : public:
305 : :
306 : : /**
307 : : * Constructor for QgsLimitedRandomColorRamp
308 : : * \param count number of colors in ramp
309 : : * \param hueMin minimum hue
310 : : * \param hueMax maximum hue
311 : : * \param satMin minimum saturation
312 : : * \param satMax maximum saturation
313 : : * \param valMin minimum color value
314 : : * \param valMax maximum color value
315 : : */
316 : : QgsLimitedRandomColorRamp( int count = DEFAULT_RANDOM_COUNT,
317 : : int hueMin = DEFAULT_RANDOM_HUE_MIN, int hueMax = DEFAULT_RANDOM_HUE_MAX,
318 : : int satMin = DEFAULT_RANDOM_SAT_MIN, int satMax = DEFAULT_RANDOM_SAT_MAX,
319 : : int valMin = DEFAULT_RANDOM_VAL_MIN, int valMax = DEFAULT_RANDOM_VAL_MAX );
320 : :
321 : : /**
322 : : * Returns a new QgsLimitedRandomColorRamp color ramp created using the properties encoded in a string
323 : : * map.
324 : : * \param properties color ramp properties
325 : : * \see properties()
326 : : */
327 : : static QgsColorRamp *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
328 : :
329 : : double value( int index ) const override;
330 : : QColor color( double value ) const override;
331 : :
332 : : /**
333 : : * Returns the string identifier for QgsLimitedRandomColorRamp.
334 : : *
335 : : * \since QGIS 3.16
336 : : */
337 : 0 : static QString typeString() { return QStringLiteral( "random" ); }
338 : :
339 : : QString type() const override;
340 : : QgsLimitedRandomColorRamp *clone() const override SIP_FACTORY;
341 : : QVariantMap properties() const override;
342 : 0 : int count() const override { return mCount; }
343 : :
344 : : /**
345 : : * Gets a list of random colors
346 : : * \since QGIS 2.4
347 : : */
348 : : static QList<QColor> randomColors( int count,
349 : : int hueMax = DEFAULT_RANDOM_HUE_MAX, int hueMin = DEFAULT_RANDOM_HUE_MIN,
350 : : int satMax = DEFAULT_RANDOM_SAT_MAX, int satMin = DEFAULT_RANDOM_SAT_MIN,
351 : : int valMax = DEFAULT_RANDOM_VAL_MAX, int valMin = DEFAULT_RANDOM_VAL_MIN );
352 : :
353 : : /**
354 : : * Must be called after changing the properties of the color ramp
355 : : * to regenerate the list of random colors.
356 : : */
357 : : void updateColors();
358 : :
359 : : /**
360 : : * Returns the minimum hue for generated colors
361 : : * \see setHueMin()
362 : : */
363 : : int hueMin() const { return mHueMin; }
364 : :
365 : : /**
366 : : * Returns the maximum hue for generated colors
367 : : * \see setHueMax()
368 : : */
369 : : int hueMax() const { return mHueMax; }
370 : :
371 : : /**
372 : : * Returns the minimum saturation for generated colors
373 : : * \see setSatMin()
374 : : */
375 : : int satMin() const { return mSatMin; }
376 : :
377 : : /**
378 : : * Returns the maximum saturation for generated colors
379 : : * \see setSatMax()
380 : : */
381 : : int satMax() const { return mSatMax; }
382 : :
383 : : /**
384 : : * Returns the minimum value for generated colors
385 : : * \see setValMin()
386 : : */
387 : : int valMin() const { return mValMin; }
388 : :
389 : : /**
390 : : * Returns the maximum value for generated colors
391 : : * \see setValMax()
392 : : */
393 : : int valMax() const { return mValMax; }
394 : :
395 : : /**
396 : : * Sets the number of colors contained in the ramp.
397 : : */
398 : : void setCount( int val ) { mCount = val; }
399 : :
400 : : /**
401 : : * Sets the minimum hue for generated colors
402 : : * \see hueMin()
403 : : */
404 : : void setHueMin( int val ) { mHueMin = val; }
405 : :
406 : : /**
407 : : * Sets the maximum hue for generated colors
408 : : * \see hueMax()
409 : : */
410 : : void setHueMax( int val ) { mHueMax = val; }
411 : :
412 : : /**
413 : : * Sets the minimum saturation for generated colors
414 : : * \see satMin()
415 : : */
416 : : void setSatMin( int val ) { mSatMin = val; }
417 : :
418 : : /**
419 : : * Sets the maximum saturation for generated colors
420 : : * \see satMax()
421 : : */
422 : : void setSatMax( int val ) { mSatMax = val; }
423 : :
424 : : /**
425 : : * Sets the minimum value for generated colors
426 : : * \see valMin()
427 : : */
428 : : void setValMin( int val ) { mValMin = val; }
429 : :
430 : : /**
431 : : * Sets the maximum value for generated colors
432 : : * \see valMax()
433 : : */
434 : : void setValMax( int val ) { mValMax = val; }
435 : :
436 : : protected:
437 : : int mCount;
438 : : int mHueMin;
439 : : int mHueMax;
440 : : int mSatMin;
441 : : int mSatMax;
442 : : int mValMin;
443 : : int mValMax;
444 : : QList<QColor> mColors;
445 : : };
446 : :
447 : : /**
448 : : * \ingroup core
449 : : * \class QgsRandomColorRamp
450 : : * \brief Totally random color ramp. Returns colors generated at random, but constrained
451 : : * to some hardcoded saturation and value ranges to prevent ugly color generation.
452 : : * \since QGIS 3.0
453 : : */
454 : 0 : class CORE_EXPORT QgsRandomColorRamp: public QgsColorRamp
455 : : {
456 : : public:
457 : :
458 : : /**
459 : : * Constructor for QgsRandomColorRamp.
460 : : */
461 : 0 : QgsRandomColorRamp() = default;
462 : :
463 : : int count() const override;
464 : :
465 : : double value( int index ) const override;
466 : :
467 : : QColor color( double value ) const override;
468 : :
469 : : /**
470 : : * Sets the desired total number of unique colors for the resultant ramp. Calling
471 : : * this method pregenerates a set of visually distinct colors which are returned
472 : : * by subsequent calls to color().
473 : : * \param colorCount number of unique colors
474 : : * \since QGIS 2.5
475 : : */
476 : : virtual void setTotalColorCount( int colorCount );
477 : :
478 : : /**
479 : : * Returns the string identifier for QgsRandomColorRamp.
480 : : *
481 : : * \since QGIS 3.16
482 : : */
483 : 0 : static QString typeString() { return QStringLiteral( "randomcolors" ); }
484 : :
485 : : QString type() const override;
486 : :
487 : : QgsRandomColorRamp *clone() const override SIP_FACTORY;
488 : :
489 : : QVariantMap properties() const override;
490 : :
491 : : protected:
492 : :
493 : 0 : int mTotalColorCount = 0;
494 : : QList<QColor> mPrecalculatedColors;
495 : :
496 : : };
497 : :
498 : :
499 : : /**
500 : : * \ingroup core
501 : : * \class QgsPresetSchemeColorRamp
502 : : * \brief A scheme based color ramp consisting of a list of predefined colors.
503 : : * \since QGIS 3.0
504 : : */
505 : 0 : class CORE_EXPORT QgsPresetSchemeColorRamp : public QgsColorRamp, public QgsColorScheme
506 : : {
507 : : public:
508 : :
509 : : /**
510 : : * Constructor for QgsPresetSchemeColorRamp.
511 : : * \param colors list of colors in ramp
512 : : */
513 : : QgsPresetSchemeColorRamp( const QList< QColor > &colors = QList< QColor >() );
514 : :
515 : : /**
516 : : * Constructor for QgsPresetColorRamp.
517 : : * \param colors list of named colors in ramp
518 : : */
519 : : QgsPresetSchemeColorRamp( const QgsNamedColorList &colors );
520 : :
521 : : /**
522 : : * Returns a new QgsPresetSchemeColorRamp color ramp created using the properties encoded in a string
523 : : * map.
524 : : * \param properties color ramp properties
525 : : * \see properties()
526 : : */
527 : : static QgsColorRamp *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
528 : :
529 : : /**
530 : : * Sets the list of colors used by the ramp.
531 : : * \param colors list of colors
532 : : * \see colors()
533 : : */
534 : 0 : bool setColors( const QgsNamedColorList &colors, const QString & = QString(), const QColor & = QColor() ) override { mColors = colors; return true; }
535 : :
536 : : /**
537 : : * Returns the list of colors used by the ramp.
538 : : * \see setColors()
539 : : */
540 : : QList< QColor > colors() const;
541 : :
542 : : double value( int index ) const override;
543 : : QColor color( double value ) const override;
544 : :
545 : : /**
546 : : * Returns the string identifier for QgsPresetSchemeColorRamp.
547 : : *
548 : : * \since QGIS 3.16
549 : : */
550 : 0 : static QString typeString() { return QStringLiteral( "preset" ); }
551 : :
552 : : QString type() const override;
553 : : void invert() override;
554 : : QgsPresetSchemeColorRamp *clone() const override SIP_FACTORY;
555 : : QVariantMap properties() const override;
556 : : int count() const override;
557 : :
558 : 0 : QString schemeName() const override { return QStringLiteral( "preset" ); }
559 : : QgsNamedColorList fetchColors( const QString &context = QString(), const QColor &baseColor = QColor() ) override;
560 : 0 : bool isEditable() const override { return true; }
561 : :
562 : : private:
563 : :
564 : : QgsNamedColorList mColors;
565 : : };
566 : :
567 : :
568 : : #define DEFAULT_COLORBREWER_SCHEMENAME "Spectral"
569 : : #define DEFAULT_COLORBREWER_COLORS 5
570 : :
571 : : /**
572 : : * \ingroup core
573 : : * \class QgsColorBrewerColorRamp
574 : : * \brief Color ramp utilising "Color Brewer" preset color schemes.
575 : : * \since QGIS 3.0
576 : : */
577 : 0 : class CORE_EXPORT QgsColorBrewerColorRamp : public QgsColorRamp
578 : : {
579 : : public:
580 : :
581 : : /**
582 : : * Constructor for QgsColorBrewerColorRamp
583 : : * \param schemeName color brewer scheme name
584 : : * \param colors number of colors in ramp
585 : : * \param inverted invert ramp ordering
586 : : */
587 : : QgsColorBrewerColorRamp( const QString &schemeName = DEFAULT_COLORBREWER_SCHEMENAME,
588 : : int colors = DEFAULT_COLORBREWER_COLORS,
589 : : bool inverted = false );
590 : :
591 : : /**
592 : : * Returns a new QgsColorBrewerColorRamp color ramp created using the properties encoded in a string
593 : : * map.
594 : : * \param properties color ramp properties
595 : : * \see properties()
596 : : */
597 : : static QgsColorRamp *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
598 : :
599 : : double value( int index ) const override;
600 : : QColor color( double value ) const override;
601 : :
602 : : /**
603 : : * Returns the string identifier for QgsColorBrewerColorRamp.
604 : : *
605 : : * \since QGIS 3.16
606 : : */
607 : 0 : static QString typeString() { return QStringLiteral( "colorbrewer" ); }
608 : :
609 : 0 : QString type() const override { return QgsColorBrewerColorRamp::typeString(); }
610 : : void invert() override;
611 : : QgsColorBrewerColorRamp *clone() const override SIP_FACTORY;
612 : : QVariantMap properties() const override;
613 : 0 : int count() const override { return mColors; }
614 : :
615 : : /**
616 : : * Returns the name of the color brewer color scheme.
617 : : * \see setSchemeName()
618 : : */
619 : : QString schemeName() const { return mSchemeName; }
620 : :
621 : : /**
622 : : * Returns the number of colors in the ramp.
623 : : * \see setColors()
624 : : */
625 : : int colors() const { return mColors; }
626 : :
627 : : /**
628 : : * Sets the name of the color brewer color scheme.
629 : : * \param schemeName scheme name, must match a valid color brewer scheme name
630 : : * \see schemeName()
631 : : * \see listSchemeNames()
632 : : */
633 : : void setSchemeName( const QString &schemeName ) { mSchemeName = schemeName; loadPalette(); }
634 : :
635 : : /**
636 : : * Sets the number of colors in the ramp.
637 : : * \param colors number of colors. Must match a valid value for the scheme,
638 : : * which can be retrieved using listSchemeVariants()
639 : : * \see colors()
640 : : */
641 : : void setColors( int colors ) { mColors = colors; loadPalette(); }
642 : :
643 : : /**
644 : : * Returns a list of all valid color brewer scheme names.
645 : : * \see listSchemeVariants()
646 : : */
647 : : static QStringList listSchemeNames();
648 : :
649 : : /**
650 : : * Returns a list of the valid variants (numbers of colors) for a specified
651 : : * color brewer scheme name
652 : : * \param schemeName color brewer scheme name
653 : : * \see listSchemeNames()
654 : : */
655 : : static QList<int> listSchemeVariants( const QString &schemeName );
656 : :
657 : : protected:
658 : :
659 : : //! Generates the scheme using the current name and number of colors
660 : : void loadPalette();
661 : :
662 : : QString mSchemeName;
663 : : int mColors;
664 : : QList<QColor> mPalette;
665 : : bool mInverted;
666 : : };
667 : :
668 : :
669 : : #define DEFAULT_CPTCITY_SCHEMENAME "cb/div/BrBG_" //change this
670 : : #define DEFAULT_CPTCITY_VARIANTNAME "05"
671 : :
672 : : /**
673 : : * \ingroup core
674 : : * \class QgsCptCityColorRamp
675 : : */
676 : 0 : class CORE_EXPORT QgsCptCityColorRamp : public QgsGradientColorRamp
677 : : {
678 : : public:
679 : :
680 : : /**
681 : : * Constructor for QgsCptCityColorRamp
682 : : * \param schemeName cpt-city scheme name
683 : : * \param variantName cpt-city variant name
684 : : * \param inverted invert ramp ordering
685 : : * \param doLoadFile load cpt-city ramp from file
686 : : */
687 : : QgsCptCityColorRamp( const QString &schemeName = DEFAULT_CPTCITY_SCHEMENAME,
688 : : const QString &variantName = DEFAULT_CPTCITY_VARIANTNAME,
689 : : bool inverted = false,
690 : : bool doLoadFile = true );
691 : :
692 : : /**
693 : : * Constructor for QgsCptCityColorRamp
694 : : * \param schemeName cpt-city scheme name
695 : : * \param variantList cpt-city variant list
696 : : * \param variantName cpt-city variant name
697 : : * \param inverted invert ramp ordering
698 : : * \param doLoadFile load cpt-city ramp from file
699 : : */
700 : : QgsCptCityColorRamp( const QString &schemeName, const QStringList &variantList,
701 : : const QString &variantName = QString(), bool inverted = false,
702 : : bool doLoadFile = true );
703 : :
704 : : //! Creates the symbol layer
705 : : static QgsColorRamp *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
706 : :
707 : : /**
708 : : * Returns the string identifier for QgsCptCityColorRamp.
709 : : *
710 : : * \since QGIS 3.16
711 : : */
712 : 240 : static QString typeString() { return QStringLiteral( "cpt-city" ); }
713 : :
714 : : QString type() const override;
715 : :
716 : : void invert() override;
717 : :
718 : : QgsCptCityColorRamp *clone() const override SIP_FACTORY;
719 : : void copy( const QgsCptCityColorRamp *other );
720 : : QgsGradientColorRamp *cloneGradientRamp() const SIP_FACTORY;
721 : :
722 : : QVariantMap properties() const override;
723 : :
724 : : QString schemeName() const { return mSchemeName; }
725 : 0 : QString variantName() const { return mVariantName; }
726 : 0 : QStringList variantList() const { return mVariantList; }
727 : :
728 : : // lazy loading - have to call loadPalette() explicitly
729 : : void setSchemeName( const QString &schemeName ) { mSchemeName = schemeName; mFileLoaded = false; }
730 : 0 : void setVariantName( const QString &variantName ) { mVariantName = variantName; mFileLoaded = false; }
731 : : void setVariantList( const QStringList &variantList ) { mVariantList = variantList; }
732 : : void setName( const QString &schemeName, const QString &variantName = QString(), const QStringList &variantList = QStringList() )
733 : : { mSchemeName = schemeName; mVariantName = variantName; mVariantList = variantList; mFileLoaded = false; }
734 : :
735 : : void loadPalette() { loadFile(); }
736 : 0 : bool hasMultiStops() const { return mMultiStops; }
737 : :
738 : : QString fileName() const;
739 : : bool loadFile();
740 : : bool fileLoaded() const { return mFileLoaded; }
741 : :
742 : : QString copyingFileName() const;
743 : : QString descFileName() const;
744 : : QgsStringMap copyingInfo() const;
745 : :
746 : : protected:
747 : : QString mSchemeName;
748 : : QString mVariantName;
749 : : QStringList mVariantList;
750 : : bool mFileLoaded = false;
751 : : bool mMultiStops = false;
752 : : bool mInverted;
753 : :
754 : : };
755 : :
756 : : // clazy:excludeall=qstring-allocations
757 : :
758 : : #endif
|
