Branch data Line data Source code
1 : : /***************************************************************************
2 : : qgis.h - QGIS namespace
3 : : -------------------
4 : : begin : Sat Jun 30 2002
5 : : copyright : (C) 2002 by Gary E.Sherman
6 : : email : sherman at mrcc.com
7 : : ***************************************************************************/
8 : :
9 : : /***************************************************************************
10 : : * *
11 : : * This program is free software; you can redistribute it and/or modify *
12 : : * it under the terms of the GNU General Public License as published by *
13 : : * the Free Software Foundation; either version 2 of the License, or *
14 : : * (at your option) any later version. *
15 : : * *
16 : : ***************************************************************************/
17 : :
18 : : #ifndef QGIS_H
19 : : #define QGIS_H
20 : :
21 : : #include <QMetaEnum>
22 : : #include <cfloat>
23 : : #include <memory>
24 : : #include <cmath>
25 : :
26 : : #include "qgstolerance.h"
27 : : #include "qgis_core.h"
28 : : #include "qgis_sip.h"
29 : :
30 : : #ifdef SIP_RUN
31 : : % ModuleHeaderCode
32 : : #include <qgis.h>
33 : : % End
34 : :
35 : : % ModuleCode
36 : : int QgisEvent = QEvent::User + 1;
37 : : % End
38 : : #endif
39 : :
40 : :
41 : : /**
42 : : * \ingroup core
43 : : * \brief The Qgis class provides global constants for use throughout the application.
44 : : */
45 : : class CORE_EXPORT Qgis
46 : : {
47 : : Q_GADGET
48 : : public:
49 : :
50 : : /**
51 : : * Version string.
52 : : *
53 : : * \since QGIS 3.12
54 : : */
55 : : static QString version();
56 : :
57 : : /**
58 : : * Version number used for comparing versions using the "Check QGIS Version" function
59 : : *
60 : : * \since QGIS 3.12
61 : : */
62 : : static int versionInt();
63 : :
64 : : /**
65 : : * Release name
66 : : *
67 : : * \since QGIS 3.12
68 : : */
69 : : static QString releaseName();
70 : :
71 : : //! The development version
72 : : static const char *QGIS_DEV_VERSION;
73 : :
74 : : /**
75 : : * The development version
76 : : *
77 : : * \since QGIS 3.12
78 : : */
79 : : static QString devVersion();
80 : :
81 : : // Enumerations
82 : : //
83 : :
84 : : /**
85 : : * \brief Level for messages
86 : : * This will be used both for message log and message bar in application.
87 : : */
88 : : enum MessageLevel
89 : : {
90 : : Info = 0,
91 : : Warning = 1,
92 : : Critical = 2,
93 : : Success = 3,
94 : : None = 4
95 : : };
96 : :
97 : : /**
98 : : * Raster data types.
99 : : * This is modified and extended copy of GDALDataType.
100 : : */
101 : : enum DataType
102 : : {
103 : : UnknownDataType = 0, //!< Unknown or unspecified type
104 : : Byte = 1, //!< Eight bit unsigned integer (quint8)
105 : : UInt16 = 2, //!< Sixteen bit unsigned integer (quint16)
106 : : Int16 = 3, //!< Sixteen bit signed integer (qint16)
107 : : UInt32 = 4, //!< Thirty two bit unsigned integer (quint32)
108 : : Int32 = 5, //!< Thirty two bit signed integer (qint32)
109 : : Float32 = 6, //!< Thirty two bit floating point (float)
110 : : Float64 = 7, //!< Sixty four bit floating point (double)
111 : : CInt16 = 8, //!< Complex Int16
112 : : CInt32 = 9, //!< Complex Int32
113 : : CFloat32 = 10, //!< Complex Float32
114 : : CFloat64 = 11, //!< Complex Float64
115 : : ARGB32 = 12, //!< Color, alpha, red, green, blue, 4 bytes the same as QImage::Format_ARGB32
116 : : ARGB32_Premultiplied = 13 //!< Color, alpha, red, green, blue, 4 bytes the same as QImage::Format_ARGB32_Premultiplied
117 : : };
118 : : Q_ENUM( DataType )
119 : :
120 : : /**
121 : : * Authorisation to run Python Macros
122 : : * \since QGIS 3.10
123 : : */
124 : : enum PythonMacroMode
125 : : {
126 : : Never = 0, //!< Macros are never run
127 : : Ask = 1, //!< User is prompt before running
128 : : SessionOnly = 2, //!< Only during this session
129 : : Always = 3, //!< Macros are always run
130 : : NotForThisSession, //!< Macros will not be run for this session
131 : : };
132 : : Q_ENUM( PythonMacroMode )
133 : :
134 : : /**
135 : : * Identify search radius in mm
136 : : * \since QGIS 2.3
137 : : */
138 : : static const double DEFAULT_SEARCH_RADIUS_MM;
139 : :
140 : : //! Default threshold between map coordinates and device coordinates for map2pixel simplification
141 : : static const float DEFAULT_MAPTOPIXEL_THRESHOLD;
142 : :
143 : : /**
144 : : * Default highlight color. The transparency is expected to only be applied to polygon
145 : : * fill. Lines and outlines are rendered opaque.
146 : : *
147 : : * \since QGIS 2.3
148 : : */
149 : : static const QColor DEFAULT_HIGHLIGHT_COLOR;
150 : :
151 : : /**
152 : : * Default highlight buffer in mm.
153 : : * \since QGIS 2.3
154 : : */
155 : : static const double DEFAULT_HIGHLIGHT_BUFFER_MM;
156 : :
157 : : /**
158 : : * Default highlight line/stroke minimum width in mm.
159 : : * \since QGIS 2.3
160 : : */
161 : : static const double DEFAULT_HIGHLIGHT_MIN_WIDTH_MM;
162 : :
163 : : /**
164 : : * Fudge factor used to compare two scales. The code is often going from scale to scale
165 : : * denominator. So it looses precision and, when a limit is inclusive, can lead to errors.
166 : : * To avoid that, use this factor instead of using <= or >=.
167 : : * \since QGIS 2.15
168 : : */
169 : : static const double SCALE_PRECISION;
170 : :
171 : : /**
172 : : * Default Z coordinate value for 2.5d geometry
173 : : * This value have to be assigned to the Z coordinate for the new 2.5d geometry vertex.
174 : : * \since QGIS 3.0
175 : : */
176 : : static const double DEFAULT_Z_COORDINATE;
177 : :
178 : : /**
179 : : * UI scaling factor. This should be applied to all widget sizes obtained from font metrics,
180 : : * to account for differences in the default font sizes across different platforms.
181 : : * \since QGIS 3.0
182 : : */
183 : : static const double UI_SCALE_FACTOR;
184 : :
185 : : /**
186 : : * Default snapping distance tolerance.
187 : : * \since QGIS 3.0
188 : : */
189 : : static const double DEFAULT_SNAP_TOLERANCE;
190 : :
191 : : /**
192 : : * Default snapping distance units.
193 : : * \since QGIS 3.0
194 : : */
195 : : static const QgsTolerance::UnitType DEFAULT_SNAP_UNITS;
196 : :
197 : : /**
198 : : * A string with default project scales.
199 : : *
200 : : * \since QGIS 3.12
201 : : */
202 : : static QString defaultProjectScales();
203 : :
204 : : /**
205 : : * GEOS version number linked
206 : : *
207 : : * \since QGIS 3.20
208 : : */
209 : : static int geosVersionInt();
210 : :
211 : : /**
212 : : * GEOS Major version number linked
213 : : *
214 : : * \since QGIS 3.20
215 : : */
216 : : static int geosVersionMajor();
217 : :
218 : : /**
219 : : * GEOS Minor version number linked
220 : : *
221 : : * \since QGIS 3.20
222 : : */
223 : : static int geosVersionMinor();
224 : :
225 : : /**
226 : : * GEOS Patch version number linked
227 : : *
228 : : * \since QGIS 3.20
229 : : */
230 : : static int geosVersionPatch();
231 : :
232 : : /**
233 : : * GEOS string version linked
234 : : *
235 : : * \since QGIS 3.20
236 : : */
237 : : static QString geosVersion();
238 : : };
239 : :
240 : : // hack to workaround warnings when casting void pointers
241 : : // retrieved from QLibrary::resolve to function pointers.
242 : : // It's assumed that this works on all systems supporting
243 : : // QLibrary
244 : : #define cast_to_fptr(f) f
245 : :
246 : :
247 : : /**
248 : : * \ingroup core
249 : : * \brief RAII signal blocking class. Used for temporarily blocking signals from a QObject
250 : : * for the lifetime of QgsSignalBlocker object.
251 : : * \see whileBlocking()
252 : : * \note not available in Python bindings
253 : : * \since QGIS 2.16
254 : : */
255 : : // based on Boojum's code from http://stackoverflow.com/questions/3556687/prevent-firing-signals-in-qt
256 : : template<class Object> class QgsSignalBlocker SIP_SKIP SIP_SKIP // clazy:exclude=rule-of-three
257 : : {
258 : : public:
259 : :
260 : : /**
261 : : * Constructor for QgsSignalBlocker
262 : : * \param object QObject to block signals from
263 : : */
264 : 0 : explicit QgsSignalBlocker( Object *object )
265 : 0 : : mObject( object )
266 : 0 : , mPreviousState( object->blockSignals( true ) )
267 : 0 : {}
268 : :
269 : 0 : ~QgsSignalBlocker()
270 : : {
271 : 0 : mObject->blockSignals( mPreviousState );
272 : 0 : }
273 : :
274 : : //! Returns pointer to blocked QObject
275 : 0 : Object *operator->() { return mObject; }
276 : :
277 : : private:
278 : :
279 : : Object *mObject = nullptr;
280 : : bool mPreviousState;
281 : :
282 : : };
283 : :
284 : : /**
285 : : * Temporarily blocks signals from a QObject while calling a single method from the object.
286 : : *
287 : : * Usage:
288 : : * whileBlocking( checkBox )->setChecked( true );
289 : : * whileBlocking( spinBox )->setValue( 50 );
290 : : *
291 : : * No signals will be emitted when calling these methods.
292 : : *
293 : : * \see QgsSignalBlocker
294 : : * \note not available in Python bindings
295 : : * \since QGIS 2.16
296 : : */
297 : : // based on Boojum's code from http://stackoverflow.com/questions/3556687/prevent-firing-signals-in-qt
298 : 0 : template<class Object> inline QgsSignalBlocker<Object> whileBlocking( Object *object ) SIP_SKIP SIP_SKIP
299 : : {
300 : 0 : return QgsSignalBlocker<Object>( object );
301 : : }
302 : :
303 : : //! Hash for QVariant
304 : : CORE_EXPORT uint qHash( const QVariant &variant );
305 : :
306 : : /**
307 : : * Returns a string representation of a double
308 : : * \param a double value
309 : : * \param precision number of decimal places to retain
310 : : */
311 : 12388 : inline QString qgsDoubleToString( double a, int precision = 17 )
312 : : {
313 : 12388 : QString str = QString::number( a, 'f', precision );
314 : 12388 : if ( precision )
315 : : {
316 : 12249 : if ( str.contains( QLatin1Char( '.' ) ) )
317 : : {
318 : : // remove ending 0s
319 : 12249 : int idx = str.length() - 1;
320 : 66327 : while ( str.at( idx ) == '0' && idx > 1 )
321 : : {
322 : 54078 : idx--;
323 : : }
324 : 12249 : if ( idx < str.length() - 1 )
325 : 5391 : str.truncate( str.at( idx ) == '.' ? idx : idx + 1 );
326 : 12249 : }
327 : 12249 : }
328 : : // avoid printing -0
329 : : // see https://bugreports.qt.io/browse/QTBUG-71439
330 : 12388 : if ( str == QLatin1String( "-0" ) )
331 : : {
332 : 6 : return QLatin1String( "0" );
333 : : }
334 : 12382 : return str;
335 : 12388 : }
336 : :
337 : : /**
338 : : * Compare two doubles (but allow some difference)
339 : : * \param a first double
340 : : * \param b second double
341 : : * \param epsilon maximum difference allowable between doubles
342 : : */
343 : 762044 : inline bool qgsDoubleNear( double a, double b, double epsilon = 4 * std::numeric_limits<double>::epsilon() )
344 : : {
345 : 762044 : if ( std::isnan( a ) || std::isnan( b ) )
346 : 14 : return std::isnan( a ) && std::isnan( b ) ;
347 : :
348 : 762030 : const double diff = a - b;
349 : 762030 : return diff > -epsilon && diff <= epsilon;
350 : 762044 : }
351 : :
352 : : /**
353 : : * Compare two floats (but allow some difference)
354 : : * \param a first float
355 : : * \param b second float
356 : : * \param epsilon maximum difference allowable between floats
357 : : */
358 : 0 : inline bool qgsFloatNear( float a, float b, float epsilon = 4 * FLT_EPSILON )
359 : : {
360 : 0 : if ( std::isnan( a ) || std::isnan( b ) )
361 : 0 : return std::isnan( a ) && std::isnan( b ) ;
362 : :
363 : 0 : const float diff = a - b;
364 : 0 : return diff > -epsilon && diff <= epsilon;
365 : 0 : }
366 : :
367 : : //! Compare two doubles using specified number of significant digits
368 : : inline bool qgsDoubleNearSig( double a, double b, int significantDigits = 10 )
369 : : {
370 : : if ( std::isnan( a ) || std::isnan( b ) )
371 : : return std::isnan( a ) && std::isnan( b ) ;
372 : :
373 : : // The most simple would be to print numbers as %.xe and compare as strings
374 : : // but that is probably too costly
375 : : // Then the fastest would be to set some bits directly, but little/big endian
376 : : // has to be considered (maybe TODO)
377 : : // Is there a better way?
378 : : int aexp, bexp;
379 : : double ar = std::frexp( a, &aexp );
380 : : double br = std::frexp( b, &bexp );
381 : :
382 : : return aexp == bexp &&
383 : : std::round( ar * std::pow( 10.0, significantDigits ) ) == std::round( br * std::pow( 10.0, significantDigits ) );
384 : : }
385 : :
386 : : /**
387 : : * Returns a double \a number, rounded (as close as possible) to the specified number of \a places.
388 : : *
389 : : * \since QGIS 3.0
390 : : */
391 : 5510 : inline double qgsRound( double number, int places )
392 : : {
393 : 5510 : double m = ( number < 0.0 ) ? -1.0 : 1.0;
394 : 5510 : double scaleFactor = std::pow( 10.0, places );
395 : 5510 : return ( std::round( number * m * scaleFactor ) / scaleFactor ) * m;
396 : : }
397 : :
398 : :
399 : : #ifndef SIP_RUN
400 : :
401 : : ///@cond PRIVATE
402 : :
403 : : /**
404 : : * Contains "polyfills" for backporting c++ features from standards > c++11 and Qt global methods
405 : : * added later than our minimum version.
406 : : *
407 : : * To be removed when minimum c++ or Qt build requirement includes the std implementation
408 : : * for these features.
409 : : *
410 : : * \note not available in Python bindings.
411 : : */
412 : : namespace qgis
413 : : {
414 : :
415 : : /**
416 : : * Use qgis::down_cast<Derived*>(pointer_to_base) as equivalent of
417 : : * static_cast<Derived*>(pointer_to_base) with safe checking in debug
418 : : * mode.
419 : : *
420 : : * Only works if no virtual inheritance is involved.
421 : : *
422 : : * Ported from GDAL's cpl::down_cast method.
423 : : *
424 : : * \param f pointer to a base class
425 : : * \return pointer to a derived class
426 : : */
427 : 106 : template<typename To, typename From> inline To down_cast( From *f )
428 : : {
429 : : static_assert(
430 : : ( std::is_base_of<From,
431 : : typename std::remove_pointer<To>::type>::value ),
432 : : "target type not derived from source type" );
433 : : Q_ASSERT( f == nullptr || dynamic_cast<To>( f ) != nullptr );
434 : 106 : return static_cast<To>( f );
435 : : }
436 : :
437 : : template<class T>
438 : 343 : QSet<T> listToSet( const QList<T> &list )
439 : : {
440 : : #if QT_VERSION < QT_VERSION_CHECK(5, 14, 0)
441 : : return list.toSet();
442 : : #else
443 : 343 : return QSet<T>( list.begin(), list.end() );
444 : : #endif
445 : : }
446 : :
447 : : template<class T>
448 : 121 : QList<T> setToList( const QSet<T> &set )
449 : : {
450 : : #if QT_VERSION < QT_VERSION_CHECK(5, 14, 0)
451 : : return set.toList();
452 : : #else
453 : 121 : return QList<T>( set.begin(), set.end() );
454 : : #endif
455 : : }
456 : : }
457 : : ///@endcond
458 : : #endif
459 : :
460 : : /**
461 : : * Returns a map of all enum entries.
462 : : * The map has the enum values (int) as keys and the enum keys (QString) as values.
463 : : * The enum must have been declared using Q_ENUM or Q_FLAG.
464 : : */
465 : 0 : template<class T> const QMap<T, QString> qgsEnumMap() SIP_SKIP
466 : : {
467 : 0 : QMetaEnum metaEnum = QMetaEnum::fromType<T>();
468 : : Q_ASSERT( metaEnum.isValid() );
469 : 0 : QMap<T, QString> enumMap;
470 : 0 : for ( int idx = 0; idx < metaEnum.keyCount(); ++idx )
471 : : {
472 : 0 : const char *enumKey = metaEnum.key( idx );
473 : 0 : enumMap.insert( static_cast<T>( metaEnum.keyToValue( enumKey ) ), QString( enumKey ) );
474 : 0 : }
475 : 0 : return enumMap;
476 : 0 : }
477 : :
478 : : /**
479 : : * Returns the value for the given key of an enum.
480 : : * \since QGIS 3.6
481 : : */
482 : 0 : template<class T> QString qgsEnumValueToKey( const T &value ) SIP_SKIP
483 : : {
484 : 0 : QMetaEnum metaEnum = QMetaEnum::fromType<T>();
485 : : Q_ASSERT( metaEnum.isValid() );
486 : 0 : return QString::fromUtf8( metaEnum.valueToKey( static_cast<int>( value ) ) );
487 : : }
488 : :
489 : : /**
490 : : * Returns the value corresponding to the given \a key of an enum.
491 : : * If the key is invalid, it will return the \a defaultValue.
492 : : * If \a tryValueAsKey is TRUE, it will try to convert the string key to an enum value
493 : : * \since QGIS 3.6
494 : : */
495 : 0 : template<class T> T qgsEnumKeyToValue( const QString &key, const T &defaultValue, bool tryValueAsKey = true ) SIP_SKIP
496 : : {
497 : 0 : QMetaEnum metaEnum = QMetaEnum::fromType<T>();
498 : : Q_ASSERT( metaEnum.isValid() );
499 : 0 : bool ok = false;
500 : 0 : T v = static_cast<T>( metaEnum.keyToValue( key.toUtf8().data(), &ok ) );
501 : 0 : if ( ok )
502 : : {
503 : 0 : return v;
504 : : }
505 : : else
506 : : {
507 : : // if conversion has failed, try with conversion from int value
508 : 0 : if ( tryValueAsKey )
509 : : {
510 : 0 : bool canConvert = false;
511 : 0 : int intValue = key.toInt( &canConvert );
512 : 0 : if ( canConvert && metaEnum.valueToKey( intValue ) )
513 : : {
514 : 0 : return static_cast<T>( intValue );
515 : : }
516 : 0 : }
517 : : }
518 : 0 : return defaultValue;
519 : 0 : }
520 : :
521 : : /**
522 : : * Returns the value for the given keys of a flag.
523 : : * \since QGIS 3.16
524 : : */
525 : 0 : template<class T> QString qgsFlagValueToKeys( const T &value ) SIP_SKIP
526 : : {
527 : 0 : QMetaEnum metaEnum = QMetaEnum::fromType<T>();
528 : : Q_ASSERT( metaEnum.isValid() );
529 : 0 : return QString::fromUtf8( metaEnum.valueToKeys( static_cast<int>( value ) ) );
530 : 0 : }
531 : :
532 : : /**
533 : : * Returns the value corresponding to the given \a keys of a flag.
534 : : * If the keys are invalid, it will return the \a defaultValue.
535 : : * \since QGIS 3.16
536 : : */
537 : 0 : template<class T> T qgsFlagKeysToValue( const QString &keys, const T &defaultValue ) SIP_SKIP
538 : : {
539 : 0 : QMetaEnum metaEnum = QMetaEnum::fromType<T>();
540 : : Q_ASSERT( metaEnum.isValid() );
541 : 0 : bool ok = false;
542 : 0 : T v = static_cast<T>( metaEnum.keysToValue( keys.toUtf8().constData(), &ok ) );
543 : 0 : if ( ok )
544 : 0 : return v;
545 : : else
546 : 0 : return defaultValue;
547 : 0 : }
548 : :
549 : :
550 : : /**
551 : : * Converts a string to a double in a permissive way, e.g., allowing for incorrect
552 : : * numbers of digits between thousand separators
553 : : * \param string string to convert
554 : : * \param ok will be set to TRUE if conversion was successful
555 : : * \returns string converted to double if possible
556 : : * \see permissiveToInt
557 : : * \since QGIS 2.9
558 : : */
559 : : CORE_EXPORT double qgsPermissiveToDouble( QString string, bool &ok );
560 : :
561 : : /**
562 : : * Converts a string to an integer in a permissive way, e.g., allowing for incorrect
563 : : * numbers of digits between thousand separators
564 : : * \param string string to convert
565 : : * \param ok will be set to TRUE if conversion was successful
566 : : * \returns string converted to int if possible
567 : : * \see permissiveToDouble
568 : : * \since QGIS 2.9
569 : : */
570 : : CORE_EXPORT int qgsPermissiveToInt( QString string, bool &ok );
571 : :
572 : : /**
573 : : * Converts a string to an qlonglong in a permissive way, e.g., allowing for incorrect
574 : : * numbers of digits between thousand separators
575 : : * \param string string to convert
576 : : * \param ok will be set to TRUE if conversion was successful
577 : : * \returns string converted to int if possible
578 : : * \see permissiveToInt
579 : : * \since QGIS 3.4
580 : : */
581 : : CORE_EXPORT qlonglong qgsPermissiveToLongLong( QString string, bool &ok );
582 : :
583 : : /**
584 : : * Compares two QVariant values and returns whether the first is less than the second.
585 : : * Useful for sorting lists of variants, correctly handling sorting of the various
586 : : * QVariant data types (such as strings, numeric values, dates and times)
587 : : *
588 : : * Invalid < NULL < Values
589 : : *
590 : : * \see qgsVariantGreaterThan()
591 : : */
592 : : CORE_EXPORT bool qgsVariantLessThan( const QVariant &lhs, const QVariant &rhs );
593 : :
594 : : /**
595 : : * Compares two QVariant values and returns whether they are equal, two NULL values are
596 : : * always treated as equal and 0 is not treated as equal with NULL
597 : : *
598 : : * \param lhs first value
599 : : * \param rhs second value
600 : : * \return TRUE if values are equal
601 : : */
602 : : CORE_EXPORT bool qgsVariantEqual( const QVariant &lhs, const QVariant &rhs );
603 : :
604 : : /**
605 : : * Compares two QVariant values and returns whether the first is greater than the second.
606 : : * Useful for sorting lists of variants, correctly handling sorting of the various
607 : : * QVariant data types (such as strings, numeric values, dates and times)
608 : : * \see qgsVariantLessThan()
609 : : */
610 : : CORE_EXPORT bool qgsVariantGreaterThan( const QVariant &lhs, const QVariant &rhs );
611 : :
612 : : #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
613 : :
614 : : /**
615 : : * Compares two QVariant values and returns whether the first is greater than the second.
616 : : * Useful for sorting lists of variants, correctly handling sorting of the various
617 : : * QVariant data types (such as strings, numeric values, dates and times)
618 : : * \see qgsVariantLessThan()
619 : : */
620 : : inline bool operator> ( const QVariant &v1, const QVariant &v2 )
621 : : {
622 : : return qgsVariantGreaterThan( v1, v2 );
623 : : }
624 : :
625 : : /**
626 : : * Compares two QVariant values and returns whether the first is less than the second.
627 : : * Useful for sorting lists of variants, correctly handling sorting of the various
628 : : * QVariant data types (such as strings, numeric values, dates and times)
629 : : *
630 : : * Invalid < NULL < Values
631 : : *
632 : : * \see qgsVariantGreaterThan()
633 : : */
634 : : inline bool operator< ( const QVariant &v1, const QVariant &v2 )
635 : : {
636 : : return qgsVariantLessThan( v1, v2 );
637 : : }
638 : : #endif
639 : :
640 : :
641 : : #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
642 : :
643 : : /**
644 : : * Compares two QVariantList values and returns whether the first is less than the second.
645 : : */
646 : : template<> CORE_EXPORT bool qMapLessThanKey<QVariantList>( const QVariantList &key1, const QVariantList &key2 ) SIP_SKIP;
647 : : #endif
648 : :
649 : : CORE_EXPORT QString qgsVsiPrefix( const QString &path );
650 : :
651 : : /**
652 : : * Allocates size bytes and returns a pointer to the allocated memory.
653 : : * Works like C malloc() but prints debug message by QgsLogger if allocation fails.
654 : : * \param size size in bytes
655 : : */
656 : : void CORE_EXPORT *qgsMalloc( size_t size ) SIP_SKIP;
657 : :
658 : : /**
659 : : * Allocates memory for an array of nmemb elements of size bytes each and returns
660 : : * a pointer to the allocated memory. Works like C calloc() but prints debug message
661 : : * by QgsLogger if allocation fails.
662 : : * \param nmemb number of elements
663 : : * \param size size of element in bytes
664 : : */
665 : : void CORE_EXPORT *qgsCalloc( size_t nmemb, size_t size ) SIP_SKIP;
666 : :
667 : : /**
668 : : * Frees the memory space pointed to by ptr. Works like C free().
669 : : * \param ptr pointer to memory space
670 : : */
671 : : void CORE_EXPORT qgsFree( void *ptr ) SIP_SKIP;
672 : :
673 : : #ifndef SIP_RUN
674 : :
675 : : #ifdef _MSC_VER
676 : : #define CONSTLATIN1STRING inline const QLatin1String
677 : : #else
678 : : #define CONSTLATIN1STRING constexpr QLatin1String
679 : : #endif
680 : :
681 : : /**
682 : : * Wkt string that represents a geographic coord sys
683 : : * \since QGIS GEOWkt
684 : : */
685 : : CONSTLATIN1STRING geoWkt()
686 : : {
687 : : return QLatin1String(
688 : : R"""(GEOGCRS["WGS 84",DATUM["World Geodetic System 1984",ELLIPSOID["WGS 84",6378137,298.257223563,LENGTHUNIT["metre",1]]],PRIMEM["Greenwich",0,ANGLEUNIT["degree",0.0174532925199433]],CS[ellipsoidal,2],AXIS["geodetic latitude (Lat)",north,ORDER[1],ANGLEUNIT["degree",0.0174532925199433]],AXIS["geodetic longitude (Lon)",east,ORDER[2],ANGLEUNIT["degree",0.0174532925199433]],USAGE[SCOPE["unknown"],AREA["World"],BBOX[-90,-180,90,180]],ID["EPSG",4326]] )"""
689 : : );
690 : : }
691 : :
692 : : //! PROJ4 string that represents a geographic coord sys
693 : : CONSTLATIN1STRING geoProj4()
694 : : {
695 : : return QLatin1String( "+proj=longlat +datum=WGS84 +no_defs" );
696 : : }
697 : :
698 : : //! Geographic coord sys from EPSG authority
699 : 4 : CONSTLATIN1STRING geoEpsgCrsAuthId()
700 : : {
701 : 4 : return QLatin1String( "EPSG:4326" );
702 : : }
703 : :
704 : : //! Constant that holds the string representation for "No ellips/No CRS"
705 : 1 : CONSTLATIN1STRING geoNone()
706 : : {
707 : 1 : return QLatin1String( "NONE" );
708 : : }
709 : :
710 : : ///@cond PRIVATE
711 : :
712 : : //! Delay between the scheduling of 2 preview jobs
713 : : const int PREVIEW_JOB_DELAY_MS = 250;
714 : :
715 : : //! Maximum rendering time for a layer of a preview job
716 : : const int MAXIMUM_LAYER_PREVIEW_TIME_MS = 250;
717 : :
718 : : ///@endcond
719 : :
720 : : #endif
721 : :
722 : : //! Magic number for a geographic coord sys in POSTGIS SRID
723 : : const long GEOSRID = 4326;
724 : :
725 : : //! Magic number for a geographic coord sys in QGIS srs.db tbl_srs.srs_id
726 : : const long GEOCRS_ID = 3452;
727 : :
728 : : //! Magic number for a geographic coord sys in EpsgCrsId ID format
729 : : const long GEO_EPSG_CRS_ID = 4326;
730 : :
731 : : /**
732 : : * Magick number that determines whether a projection crsid is a system (srs.db)
733 : : * or user (~/.qgis.qgis.db) defined projection.
734 : : */
735 : : const int USER_CRS_START_ID = 100000;
736 : :
737 : : //
738 : : // Constants for point symbols
739 : : //
740 : :
741 : : //! Magic number that determines the default point size for point symbols
742 : : const double DEFAULT_POINT_SIZE = 2.0;
743 : : const double DEFAULT_LINE_WIDTH = 0.26;
744 : :
745 : : //! Default snapping tolerance for segments
746 : : const double DEFAULT_SEGMENT_EPSILON = 1e-8;
747 : :
748 : : typedef QMap<QString, QString> QgsStringMap SIP_SKIP;
749 : :
750 : : /**
751 : : * Qgssize is used instead of size_t, because size_t is stdlib type, unknown
752 : : * by SIP, and it would be hard to define size_t correctly in SIP.
753 : : * Currently used "unsigned long long" was introduced in C++11 (2011)
754 : : * but it was supported already before C++11 on common platforms.
755 : : * "unsigned long long int" gives syntax error in SIP.
756 : : * KEEP IN SYNC WITH qgssize defined in SIP!
757 : : */
758 : : typedef unsigned long long qgssize;
759 : :
760 : : #ifndef SIP_RUN
761 : : #if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__)
762 : :
763 : : #define Q_NOWARN_DEPRECATED_PUSH \
764 : : _Pragma("GCC diagnostic push") \
765 : : _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"");
766 : : #define Q_NOWARN_DEPRECATED_POP \
767 : : _Pragma("GCC diagnostic pop");
768 : : #define Q_NOWARN_UNREACHABLE_PUSH
769 : : #define Q_NOWARN_UNREACHABLE_POP
770 : :
771 : : #elif defined(_MSC_VER)
772 : :
773 : : #define Q_NOWARN_DEPRECATED_PUSH \
774 : : __pragma(warning(push)) \
775 : : __pragma(warning(disable:4996))
776 : : #define Q_NOWARN_DEPRECATED_POP \
777 : : __pragma(warning(pop))
778 : : #define Q_NOWARN_UNREACHABLE_PUSH \
779 : : __pragma(warning(push)) \
780 : : __pragma(warning(disable:4702))
781 : : #define Q_NOWARN_UNREACHABLE_POP \
782 : : __pragma(warning(pop))
783 : :
784 : : #else
785 : :
786 : : #define Q_NOWARN_DEPRECATED_PUSH
787 : : #define Q_NOWARN_DEPRECATED_POP
788 : : #define Q_NOWARN_UNREACHABLE_PUSH
789 : : #define Q_NOWARN_UNREACHABLE_POP
790 : :
791 : : #endif
792 : : #endif
793 : :
794 : : #ifndef QGISEXTERN
795 : : #ifdef Q_OS_WIN
796 : : # define QGISEXTERN extern "C" __declspec( dllexport )
797 : : # ifdef _MSC_VER
798 : : // do not warn about C bindings returning QString
799 : : # pragma warning(disable:4190)
800 : : # endif
801 : : #else
802 : : # if defined(__GNUC__) || defined(__clang__)
803 : : # define QGISEXTERN extern "C" __attribute__ ((visibility ("default")))
804 : : # else
805 : : # define QGISEXTERN extern "C"
806 : : # endif
807 : : #endif
808 : : #endif
809 : : #endif
810 : :
811 : : #if __cplusplus >= 201500
812 : : #define FALLTHROUGH [[fallthrough]];
813 : : #elif defined(__clang__)
814 : : #define FALLTHROUGH [[clang::fallthrough]];
815 : : #elif defined(__GNUC__) && __GNUC__ >= 7
816 : : #define FALLTHROUGH [[gnu::fallthrough]];
817 : : #else
818 : : #define FALLTHROUGH
819 : : #endif
820 : :
821 : : // see https://infektor.net/posts/2017-01-19-using-cpp17-attributes-today.html#using-the-nodiscard-attribute
822 : : #if __cplusplus >= 201703L
823 : : #define NODISCARD [[nodiscard]]
824 : : #elif defined(__clang__)
825 : : #define NODISCARD [[nodiscard]]
826 : : #elif defined(_MSC_VER)
827 : : #define NODISCARD // no support
828 : : #elif defined(__has_cpp_attribute)
829 : : #if __has_cpp_attribute(nodiscard)
830 : : #define NODISCARD [[nodiscard]]
831 : : #elif __has_cpp_attribute(gnu::warn_unused_result)
832 : : #define NODISCARD [[gnu::warn_unused_result]]
833 : : #else
834 : : #define NODISCARD Q_REQUIRED_RESULT
835 : : #endif
836 : : #else
837 : : #define NODISCARD Q_REQUIRED_RESULT
838 : : #endif
839 : :
840 : : #if __cplusplus >= 201703L
841 : : #define MAYBE_UNUSED [[maybe_unused]]
842 : : #elif defined(__clang__)
843 : : #define MAYBE_UNUSED [[maybe_unused]]
844 : : #elif defined(_MSC_VER)
845 : : #define MAYBE_UNUSED // no support
846 : : #elif defined(__has_cpp_attribute)
847 : : #if __has_cpp_attribute(gnu::unused)
848 : : #define MAYBE_UNUSED [[gnu::unused]]
849 : : #else
850 : : #define MAYBE_UNUSED
851 : : #endif
852 : : #else
853 : : #define MAYBE_UNUSED
854 : : #endif
855 : :
856 : : #ifndef FINAL
857 : : #define FINAL final
858 : : #endif
859 : :
860 : : #ifdef SIP_RUN
861 : :
862 : : /**
863 : : * Wkt string that represents a geographic coord sys
864 : : * \since QGIS GEOWkt
865 : : */
866 : : QString CORE_EXPORT geoWkt();
867 : :
868 : : //! PROJ4 string that represents a geographic coord sys
869 : : QString CORE_EXPORT geoProj4();
870 : :
871 : : //! Geographic coord sys from EPSG authority
872 : : QString CORE_EXPORT geoEpsgCrsAuthId();
873 : :
874 : : //! Constant that holds the string representation for "No ellips/No CRS"
875 : : QString CORE_EXPORT geoNone();
876 : :
877 : : #endif
|
