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 : : // hack to workaround warnings when casting void pointers
206 : : // retrieved from QLibrary::resolve to function pointers.
207 : : // It's assumed that this works on all systems supporting
208 : : // QLibrary
209 : : #define cast_to_fptr(f) f
210 : :
211 : :
212 : : /**
213 : : * \ingroup core
214 : : * \brief RAII signal blocking class. Used for temporarily blocking signals from a QObject
215 : : * for the lifetime of QgsSignalBlocker object.
216 : : * \see whileBlocking()
217 : : * \note not available in Python bindings
218 : : * \since QGIS 2.16
219 : : */
220 : : // based on Boojum's code from http://stackoverflow.com/questions/3556687/prevent-firing-signals-in-qt
221 : : template<class Object> class QgsSignalBlocker SIP_SKIP SIP_SKIP // clazy:exclude=rule-of-three
222 : : {
223 : : public:
224 : :
225 : : /**
226 : : * Constructor for QgsSignalBlocker
227 : : * \param object QObject to block signals from
228 : : */
229 : 0 : explicit QgsSignalBlocker( Object *object )
230 : 0 : : mObject( object )
231 : 0 : , mPreviousState( object->blockSignals( true ) )
232 : 0 : {}
233 : :
234 : 0 : ~QgsSignalBlocker()
235 : : {
236 : 0 : mObject->blockSignals( mPreviousState );
237 : 0 : }
238 : :
239 : : //! Returns pointer to blocked QObject
240 : 0 : Object *operator->() { return mObject; }
241 : :
242 : : private:
243 : :
244 : : Object *mObject = nullptr;
245 : : bool mPreviousState;
246 : :
247 : : };
248 : :
249 : : /**
250 : : * Temporarily blocks signals from a QObject while calling a single method from the object.
251 : : *
252 : : * Usage:
253 : : * whileBlocking( checkBox )->setChecked( true );
254 : : * whileBlocking( spinBox )->setValue( 50 );
255 : : *
256 : : * No signals will be emitted when calling these methods.
257 : : *
258 : : * \see QgsSignalBlocker
259 : : * \note not available in Python bindings
260 : : * \since QGIS 2.16
261 : : */
262 : : // based on Boojum's code from http://stackoverflow.com/questions/3556687/prevent-firing-signals-in-qt
263 : 0 : template<class Object> inline QgsSignalBlocker<Object> whileBlocking( Object *object ) SIP_SKIP SIP_SKIP
264 : : {
265 : 0 : return QgsSignalBlocker<Object>( object );
266 : : }
267 : :
268 : : //! Hash for QVariant
269 : : CORE_EXPORT uint qHash( const QVariant &variant );
270 : :
271 : : /**
272 : : * Returns a string representation of a double
273 : : * \param a double value
274 : : * \param precision number of decimal places to retain
275 : : */
276 : 12344 : inline QString qgsDoubleToString( double a, int precision = 17 )
277 : : {
278 : 12344 : QString str = QString::number( a, 'f', precision );
279 : 12344 : if ( precision )
280 : : {
281 : 12205 : if ( str.contains( QLatin1Char( '.' ) ) )
282 : : {
283 : : // remove ending 0s
284 : 12205 : int idx = str.length() - 1;
285 : 65467 : while ( str.at( idx ) == '0' && idx > 1 )
286 : : {
287 : 53262 : idx--;
288 : : }
289 : 12205 : if ( idx < str.length() - 1 )
290 : 5343 : str.truncate( str.at( idx ) == '.' ? idx : idx + 1 );
291 : 12205 : }
292 : 12205 : }
293 : : // avoid printing -0
294 : : // see https://bugreports.qt.io/browse/QTBUG-71439
295 : 12344 : if ( str == QLatin1String( "-0" ) )
296 : : {
297 : 6 : return QLatin1String( "0" );
298 : : }
299 : 12338 : return str;
300 : 12344 : }
301 : :
302 : : /**
303 : : * Compare two doubles (but allow some difference)
304 : : * \param a first double
305 : : * \param b second double
306 : : * \param epsilon maximum difference allowable between doubles
307 : : */
308 : 762003 : inline bool qgsDoubleNear( double a, double b, double epsilon = 4 * std::numeric_limits<double>::epsilon() )
309 : : {
310 : 762003 : if ( std::isnan( a ) || std::isnan( b ) )
311 : 14 : return std::isnan( a ) && std::isnan( b ) ;
312 : :
313 : 761989 : const double diff = a - b;
314 : 761989 : return diff > -epsilon && diff <= epsilon;
315 : 762003 : }
316 : :
317 : : /**
318 : : * Compare two floats (but allow some difference)
319 : : * \param a first float
320 : : * \param b second float
321 : : * \param epsilon maximum difference allowable between floats
322 : : */
323 : 0 : inline bool qgsFloatNear( float a, float b, float epsilon = 4 * FLT_EPSILON )
324 : : {
325 : 0 : if ( std::isnan( a ) || std::isnan( b ) )
326 : 0 : return std::isnan( a ) && std::isnan( b ) ;
327 : :
328 : 0 : const float diff = a - b;
329 : 0 : return diff > -epsilon && diff <= epsilon;
330 : 0 : }
331 : :
332 : : //! Compare two doubles using specified number of significant digits
333 : : inline bool qgsDoubleNearSig( double a, double b, int significantDigits = 10 )
334 : : {
335 : : if ( std::isnan( a ) || std::isnan( b ) )
336 : : return std::isnan( a ) && std::isnan( b ) ;
337 : :
338 : : // The most simple would be to print numbers as %.xe and compare as strings
339 : : // but that is probably too costly
340 : : // Then the fastest would be to set some bits directly, but little/big endian
341 : : // has to be considered (maybe TODO)
342 : : // Is there a better way?
343 : : int aexp, bexp;
344 : : double ar = std::frexp( a, &aexp );
345 : : double br = std::frexp( b, &bexp );
346 : :
347 : : return aexp == bexp &&
348 : : std::round( ar * std::pow( 10.0, significantDigits ) ) == std::round( br * std::pow( 10.0, significantDigits ) );
349 : : }
350 : :
351 : : /**
352 : : * Returns a double \a number, rounded (as close as possible) to the specified number of \a places.
353 : : *
354 : : * \since QGIS 3.0
355 : : */
356 : 5510 : inline double qgsRound( double number, int places )
357 : : {
358 : 5510 : double m = ( number < 0.0 ) ? -1.0 : 1.0;
359 : 5510 : double scaleFactor = std::pow( 10.0, places );
360 : 5510 : return ( std::round( number * m * scaleFactor ) / scaleFactor ) * m;
361 : : }
362 : :
363 : :
364 : : #ifndef SIP_RUN
365 : :
366 : : ///@cond PRIVATE
367 : :
368 : : /**
369 : : * Contains "polyfills" for backporting c++ features from standards > c++11 and Qt global methods
370 : : * added later than our minimum version.
371 : : *
372 : : * To be removed when minimum c++ or Qt build requirement includes the std implementation
373 : : * for these features.
374 : : *
375 : : * \note not available in Python bindings.
376 : : */
377 : : namespace qgis
378 : : {
379 : :
380 : : template<class T>
381 : 343 : QSet<T> listToSet( const QList<T> &list )
382 : : {
383 : : #if QT_VERSION < QT_VERSION_CHECK(5, 14, 0)
384 : : return list.toSet();
385 : : #else
386 : 343 : return QSet<T>( list.begin(), list.end() );
387 : : #endif
388 : : }
389 : :
390 : : template<class T>
391 : 121 : QList<T> setToList( const QSet<T> &set )
392 : : {
393 : : #if QT_VERSION < QT_VERSION_CHECK(5, 14, 0)
394 : : return set.toList();
395 : : #else
396 : 121 : return QList<T>( set.begin(), set.end() );
397 : : #endif
398 : : }
399 : : }
400 : : ///@endcond
401 : : #endif
402 : :
403 : : /**
404 : : * Returns a map of all enum entries.
405 : : * The map has the enum values (int) as keys and the enum keys (QString) as values.
406 : : * The enum must have been declared using Q_ENUM or Q_FLAG.
407 : : */
408 : 0 : template<class T> const QMap<T, QString> qgsEnumMap() SIP_SKIP
409 : : {
410 : 0 : QMetaEnum metaEnum = QMetaEnum::fromType<T>();
411 : : Q_ASSERT( metaEnum.isValid() );
412 : 0 : QMap<T, QString> enumMap;
413 : 0 : for ( int idx = 0; idx < metaEnum.keyCount(); ++idx )
414 : : {
415 : 0 : const char *enumKey = metaEnum.key( idx );
416 : 0 : enumMap.insert( static_cast<T>( metaEnum.keyToValue( enumKey ) ), QString( enumKey ) );
417 : 0 : }
418 : 0 : return enumMap;
419 : 0 : }
420 : :
421 : : /**
422 : : * Returns the value for the given key of an enum.
423 : : * \since QGIS 3.6
424 : : */
425 : 0 : template<class T> QString qgsEnumValueToKey( const T &value ) SIP_SKIP
426 : : {
427 : 0 : QMetaEnum metaEnum = QMetaEnum::fromType<T>();
428 : : Q_ASSERT( metaEnum.isValid() );
429 : 0 : return QString::fromUtf8( metaEnum.valueToKey( static_cast<int>( value ) ) );
430 : : }
431 : :
432 : : /**
433 : : * Returns the value corresponding to the given \a key of an enum.
434 : : * If the key is invalid, it will return the \a defaultValue.
435 : : * If \a tryValueAsKey is TRUE, it will try to convert the string key to an enum value
436 : : * \since QGIS 3.6
437 : : */
438 : 0 : template<class T> T qgsEnumKeyToValue( const QString &key, const T &defaultValue, bool tryValueAsKey = true ) SIP_SKIP
439 : : {
440 : 0 : QMetaEnum metaEnum = QMetaEnum::fromType<T>();
441 : : Q_ASSERT( metaEnum.isValid() );
442 : 0 : bool ok = false;
443 : 0 : T v = static_cast<T>( metaEnum.keyToValue( key.toUtf8().data(), &ok ) );
444 : 0 : if ( ok )
445 : : {
446 : 0 : return v;
447 : : }
448 : : else
449 : : {
450 : : // if conversion has failed, try with conversion from int value
451 : 0 : if ( tryValueAsKey )
452 : : {
453 : 0 : bool canConvert = false;
454 : 0 : int intValue = key.toInt( &canConvert );
455 : 0 : if ( canConvert && metaEnum.valueToKey( intValue ) )
456 : : {
457 : 0 : return static_cast<T>( intValue );
458 : : }
459 : 0 : }
460 : : }
461 : 0 : return defaultValue;
462 : 0 : }
463 : :
464 : : /**
465 : : * Returns the value for the given keys of a flag.
466 : : * \since QGIS 3.16
467 : : */
468 : 0 : template<class T> QString qgsFlagValueToKeys( const T &value ) SIP_SKIP
469 : : {
470 : 0 : QMetaEnum metaEnum = QMetaEnum::fromType<T>();
471 : : Q_ASSERT( metaEnum.isValid() );
472 : 0 : return QString::fromUtf8( metaEnum.valueToKeys( static_cast<int>( value ) ) );
473 : 0 : }
474 : :
475 : : /**
476 : : * Returns the value corresponding to the given \a keys of a flag.
477 : : * If the keys are invalid, it will return the \a defaultValue.
478 : : * \since QGIS 3.16
479 : : */
480 : 0 : template<class T> T qgsFlagKeysToValue( const QString &keys, const T &defaultValue ) SIP_SKIP
481 : : {
482 : 0 : QMetaEnum metaEnum = QMetaEnum::fromType<T>();
483 : : Q_ASSERT( metaEnum.isValid() );
484 : 0 : bool ok = false;
485 : 0 : T v = static_cast<T>( metaEnum.keysToValue( keys.toUtf8().constData(), &ok ) );
486 : 0 : if ( ok )
487 : 0 : return v;
488 : : else
489 : 0 : return defaultValue;
490 : 0 : }
491 : :
492 : :
493 : : /**
494 : : * Converts a string to a double in a permissive way, e.g., allowing for incorrect
495 : : * numbers of digits between thousand separators
496 : : * \param string string to convert
497 : : * \param ok will be set to TRUE if conversion was successful
498 : : * \returns string converted to double if possible
499 : : * \see permissiveToInt
500 : : * \since QGIS 2.9
501 : : */
502 : : CORE_EXPORT double qgsPermissiveToDouble( QString string, bool &ok );
503 : :
504 : : /**
505 : : * Converts a string to an integer in a permissive way, e.g., allowing for incorrect
506 : : * numbers of digits between thousand separators
507 : : * \param string string to convert
508 : : * \param ok will be set to TRUE if conversion was successful
509 : : * \returns string converted to int if possible
510 : : * \see permissiveToDouble
511 : : * \since QGIS 2.9
512 : : */
513 : : CORE_EXPORT int qgsPermissiveToInt( QString string, bool &ok );
514 : :
515 : : /**
516 : : * Converts a string to an qlonglong in a permissive way, e.g., allowing for incorrect
517 : : * numbers of digits between thousand separators
518 : : * \param string string to convert
519 : : * \param ok will be set to TRUE if conversion was successful
520 : : * \returns string converted to int if possible
521 : : * \see permissiveToInt
522 : : * \since QGIS 3.4
523 : : */
524 : : CORE_EXPORT qlonglong qgsPermissiveToLongLong( QString string, bool &ok );
525 : :
526 : : /**
527 : : * Compares two QVariant values and returns whether the first is less than the second.
528 : : * Useful for sorting lists of variants, correctly handling sorting of the various
529 : : * QVariant data types (such as strings, numeric values, dates and times)
530 : : *
531 : : * Invalid < NULL < Values
532 : : *
533 : : * \see qgsVariantGreaterThan()
534 : : */
535 : : CORE_EXPORT bool qgsVariantLessThan( const QVariant &lhs, const QVariant &rhs );
536 : :
537 : : /**
538 : : * Compares two QVariant values and returns whether they are equal, two NULL values are
539 : : * always treated as equal and 0 is not treated as equal with NULL
540 : : *
541 : : * \param lhs first value
542 : : * \param rhs second value
543 : : * \return TRUE if values are equal
544 : : */
545 : : CORE_EXPORT bool qgsVariantEqual( const QVariant &lhs, const QVariant &rhs );
546 : :
547 : : /**
548 : : * Compares two QVariant values and returns whether the first is greater than the second.
549 : : * Useful for sorting lists of variants, correctly handling sorting of the various
550 : : * QVariant data types (such as strings, numeric values, dates and times)
551 : : * \see qgsVariantLessThan()
552 : : */
553 : : CORE_EXPORT bool qgsVariantGreaterThan( const QVariant &lhs, const QVariant &rhs );
554 : :
555 : : #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
556 : :
557 : : /**
558 : : * Compares two QVariant values and returns whether the first is greater than the second.
559 : : * Useful for sorting lists of variants, correctly handling sorting of the various
560 : : * QVariant data types (such as strings, numeric values, dates and times)
561 : : * \see qgsVariantLessThan()
562 : : */
563 : : inline bool operator> ( const QVariant &v1, const QVariant &v2 )
564 : : {
565 : : return qgsVariantGreaterThan( v1, v2 );
566 : : }
567 : :
568 : : /**
569 : : * Compares two QVariant values and returns whether the first is less than the second.
570 : : * Useful for sorting lists of variants, correctly handling sorting of the various
571 : : * QVariant data types (such as strings, numeric values, dates and times)
572 : : *
573 : : * Invalid < NULL < Values
574 : : *
575 : : * \see qgsVariantGreaterThan()
576 : : */
577 : : inline bool operator< ( const QVariant &v1, const QVariant &v2 )
578 : : {
579 : : return qgsVariantLessThan( v1, v2 );
580 : : }
581 : : #endif
582 : :
583 : :
584 : : #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
585 : :
586 : : /**
587 : : * Compares two QVariantList values and returns whether the first is less than the second.
588 : : */
589 : : template<> CORE_EXPORT bool qMapLessThanKey<QVariantList>( const QVariantList &key1, const QVariantList &key2 ) SIP_SKIP;
590 : : #endif
591 : :
592 : : CORE_EXPORT QString qgsVsiPrefix( const QString &path );
593 : :
594 : : /**
595 : : * Allocates size bytes and returns a pointer to the allocated memory.
596 : : * Works like C malloc() but prints debug message by QgsLogger if allocation fails.
597 : : * \param size size in bytes
598 : : */
599 : : void CORE_EXPORT *qgsMalloc( size_t size ) SIP_SKIP;
600 : :
601 : : /**
602 : : * Allocates memory for an array of nmemb elements of size bytes each and returns
603 : : * a pointer to the allocated memory. Works like C calloc() but prints debug message
604 : : * by QgsLogger if allocation fails.
605 : : * \param nmemb number of elements
606 : : * \param size size of element in bytes
607 : : */
608 : : void CORE_EXPORT *qgsCalloc( size_t nmemb, size_t size ) SIP_SKIP;
609 : :
610 : : /**
611 : : * Frees the memory space pointed to by ptr. Works like C free().
612 : : * \param ptr pointer to memory space
613 : : */
614 : : void CORE_EXPORT qgsFree( void *ptr ) SIP_SKIP;
615 : :
616 : : #ifndef SIP_RUN
617 : :
618 : : #ifdef _MSC_VER
619 : : #define CONSTLATIN1STRING inline const QLatin1String
620 : : #else
621 : : #define CONSTLATIN1STRING constexpr QLatin1String
622 : : #endif
623 : :
624 : : /**
625 : : * Wkt string that represents a geographic coord sys
626 : : * \since QGIS GEOWkt
627 : : */
628 : : CONSTLATIN1STRING geoWkt()
629 : : {
630 : : return QLatin1String(
631 : : 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]] )"""
632 : : );
633 : : }
634 : :
635 : : //! PROJ4 string that represents a geographic coord sys
636 : : CONSTLATIN1STRING geoProj4()
637 : : {
638 : : return QLatin1String( "+proj=longlat +datum=WGS84 +no_defs" );
639 : : }
640 : :
641 : : //! Geographic coord sys from EPSG authority
642 : 4 : CONSTLATIN1STRING geoEpsgCrsAuthId()
643 : : {
644 : 4 : return QLatin1String( "EPSG:4326" );
645 : : }
646 : :
647 : : //! Constant that holds the string representation for "No ellips/No CRS"
648 : 1 : CONSTLATIN1STRING geoNone()
649 : : {
650 : 1 : return QLatin1String( "NONE" );
651 : : }
652 : :
653 : : ///@cond PRIVATE
654 : :
655 : : //! Delay between the scheduling of 2 preview jobs
656 : : const int PREVIEW_JOB_DELAY_MS = 250;
657 : :
658 : : //! Maximum rendering time for a layer of a preview job
659 : : const int MAXIMUM_LAYER_PREVIEW_TIME_MS = 250;
660 : :
661 : : ///@endcond
662 : :
663 : : #endif
664 : :
665 : : //! Magic number for a geographic coord sys in POSTGIS SRID
666 : : const long GEOSRID = 4326;
667 : :
668 : : //! Magic number for a geographic coord sys in QGIS srs.db tbl_srs.srs_id
669 : : const long GEOCRS_ID = 3452;
670 : :
671 : : //! Magic number for a geographic coord sys in EpsgCrsId ID format
672 : : const long GEO_EPSG_CRS_ID = 4326;
673 : :
674 : : /**
675 : : * Magick number that determines whether a projection crsid is a system (srs.db)
676 : : * or user (~/.qgis.qgis.db) defined projection.
677 : : */
678 : : const int USER_CRS_START_ID = 100000;
679 : :
680 : : //
681 : : // Constants for point symbols
682 : : //
683 : :
684 : : //! Magic number that determines the default point size for point symbols
685 : : const double DEFAULT_POINT_SIZE = 2.0;
686 : : const double DEFAULT_LINE_WIDTH = 0.26;
687 : :
688 : : //! Default snapping tolerance for segments
689 : : const double DEFAULT_SEGMENT_EPSILON = 1e-8;
690 : :
691 : : typedef QMap<QString, QString> QgsStringMap SIP_SKIP;
692 : :
693 : : /**
694 : : * Qgssize is used instead of size_t, because size_t is stdlib type, unknown
695 : : * by SIP, and it would be hard to define size_t correctly in SIP.
696 : : * Currently used "unsigned long long" was introduced in C++11 (2011)
697 : : * but it was supported already before C++11 on common platforms.
698 : : * "unsigned long long int" gives syntax error in SIP.
699 : : * KEEP IN SYNC WITH qgssize defined in SIP!
700 : : */
701 : : typedef unsigned long long qgssize;
702 : :
703 : : #ifndef SIP_RUN
704 : : #if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__)
705 : :
706 : : #define Q_NOWARN_DEPRECATED_PUSH \
707 : : _Pragma("GCC diagnostic push") \
708 : : _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"");
709 : : #define Q_NOWARN_DEPRECATED_POP \
710 : : _Pragma("GCC diagnostic pop");
711 : : #define Q_NOWARN_UNREACHABLE_PUSH
712 : : #define Q_NOWARN_UNREACHABLE_POP
713 : :
714 : : #elif defined(_MSC_VER)
715 : :
716 : : #define Q_NOWARN_DEPRECATED_PUSH \
717 : : __pragma(warning(push)) \
718 : : __pragma(warning(disable:4996))
719 : : #define Q_NOWARN_DEPRECATED_POP \
720 : : __pragma(warning(pop))
721 : : #define Q_NOWARN_UNREACHABLE_PUSH \
722 : : __pragma(warning(push)) \
723 : : __pragma(warning(disable:4702))
724 : : #define Q_NOWARN_UNREACHABLE_POP \
725 : : __pragma(warning(pop))
726 : :
727 : : #else
728 : :
729 : : #define Q_NOWARN_DEPRECATED_PUSH
730 : : #define Q_NOWARN_DEPRECATED_POP
731 : : #define Q_NOWARN_UNREACHABLE_PUSH
732 : : #define Q_NOWARN_UNREACHABLE_POP
733 : :
734 : : #endif
735 : : #endif
736 : :
737 : : #ifndef QGISEXTERN
738 : : #ifdef Q_OS_WIN
739 : : # define QGISEXTERN extern "C" __declspec( dllexport )
740 : : # ifdef _MSC_VER
741 : : // do not warn about C bindings returning QString
742 : : # pragma warning(disable:4190)
743 : : # endif
744 : : #else
745 : : # if defined(__GNUC__) || defined(__clang__)
746 : : # define QGISEXTERN extern "C" __attribute__ ((visibility ("default")))
747 : : # else
748 : : # define QGISEXTERN extern "C"
749 : : # endif
750 : : #endif
751 : : #endif
752 : : #endif
753 : :
754 : : #if __cplusplus >= 201500
755 : : #define FALLTHROUGH [[fallthrough]];
756 : : #elif defined(__clang__)
757 : : #define FALLTHROUGH [[clang::fallthrough]];
758 : : #elif defined(__GNUC__) && __GNUC__ >= 7
759 : : #define FALLTHROUGH [[gnu::fallthrough]];
760 : : #else
761 : : #define FALLTHROUGH
762 : : #endif
763 : :
764 : : // see https://infektor.net/posts/2017-01-19-using-cpp17-attributes-today.html#using-the-nodiscard-attribute
765 : : #if __cplusplus >= 201703L
766 : : #define NODISCARD [[nodiscard]]
767 : : #elif defined(__clang__)
768 : : #define NODISCARD [[nodiscard]]
769 : : #elif defined(_MSC_VER)
770 : : #define NODISCARD // no support
771 : : #elif defined(__has_cpp_attribute)
772 : : #if __has_cpp_attribute(nodiscard)
773 : : #define NODISCARD [[nodiscard]]
774 : : #elif __has_cpp_attribute(gnu::warn_unused_result)
775 : : #define NODISCARD [[gnu::warn_unused_result]]
776 : : #else
777 : : #define NODISCARD Q_REQUIRED_RESULT
778 : : #endif
779 : : #else
780 : : #define NODISCARD Q_REQUIRED_RESULT
781 : : #endif
782 : :
783 : : #if __cplusplus >= 201703L
784 : : #define MAYBE_UNUSED [[maybe_unused]]
785 : : #elif defined(__clang__)
786 : : #define MAYBE_UNUSED [[maybe_unused]]
787 : : #elif defined(_MSC_VER)
788 : : #define MAYBE_UNUSED // no support
789 : : #elif defined(__has_cpp_attribute)
790 : : #if __has_cpp_attribute(gnu::unused)
791 : : #define MAYBE_UNUSED [[gnu::unused]]
792 : : #else
793 : : #define MAYBE_UNUSED
794 : : #endif
795 : : #else
796 : : #define MAYBE_UNUSED
797 : : #endif
798 : :
799 : : #ifndef FINAL
800 : : #define FINAL final
801 : : #endif
802 : :
803 : : #ifdef SIP_RUN
804 : :
805 : : /**
806 : : * Wkt string that represents a geographic coord sys
807 : : * \since QGIS GEOWkt
808 : : */
809 : : QString CORE_EXPORT geoWkt();
810 : :
811 : : //! PROJ4 string that represents a geographic coord sys
812 : : QString CORE_EXPORT geoProj4();
813 : :
814 : : //! Geographic coord sys from EPSG authority
815 : : QString CORE_EXPORT geoEpsgCrsAuthId();
816 : :
817 : : //! Constant that holds the string representation for "No ellips/No CRS"
818 : : QString CORE_EXPORT geoNone();
819 : :
820 : : #endif
|
