QGIS API Documentation  3.23.0-Master (eb871beae0)
qgswmsparameters.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  qgswmsparameters.cpp
3  --------------------
4  begin : March 17, 2017
5  copyright : (C) 2017 by Paul Blottiere
6  email : paul dot blottiere at oslandia dot 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 #include "qgswmsparameters.h"
19 #include "qgsdatasourceuri.h"
21 #include "qgsmessagelog.h"
22 #include "qgswmsserviceexception.h"
23 
24 const QString EXTERNAL_LAYER_PREFIX = QStringLiteral( "EXTERNAL_WMS:" );
25 
26 namespace QgsWms
27 {
28  //
29  // QgsWmsParameter
30  //
32  const QVariant::Type type,
33  const QVariant defaultValue )
34  : QgsServerParameterDefinition( type, defaultValue )
35  , mName( name )
36  {
37  }
38 
40  {
42  }
43 
45  {
46  const QString msg = QString( "%1 ('%2') cannot be converted into %3" ).arg( name( mName ), toString(), typeName() );
48  }
49 
50  QStringList QgsWmsParameter::toStyleList( const char delimiter ) const
51  {
52  return QgsServerParameterDefinition::toStringList( delimiter, false );
53  }
54 
55  QList<QgsGeometry> QgsWmsParameter::toGeomList( const char delimiter ) const
56  {
57  bool ok = true;
58  const QList<QgsGeometry> geoms = QgsServerParameterDefinition::toGeomList( ok, delimiter );
59 
60  if ( !ok )
61  {
62  const QString msg = QString( "%1 ('%2') cannot be converted into a list of geometries" ).arg( name( mName ), toString() );
64  }
65 
66  return geoms;
67  }
68 
70  {
71  bool ok = true;
73 
74  if ( !ok )
75  {
76  const QString msg = QString( "%1 ('%2') cannot be converted into a rectangle" ).arg( name( mName ), toString() );
78  }
79 
80  return rect;
81  }
82 
84  {
85  bool ok = false;
86  const int val = QgsServerParameterDefinition::toInt( ok );
87 
88  if ( !ok )
89  {
90  raiseError();
91  }
92 
93  return val;
94  }
95 
96  QString QgsWmsParameter::loadUrl() const
97  {
98  // Check URL -- it will be used in error messages
99  const QUrl url = toUrl();
100 
101  bool ok = false;
102  const QString content = QgsServerParameterDefinition::loadUrl( ok );
103 
104  if ( !ok )
105  {
106  const QString msg = QString( "%1 request error for %2" ).arg( name( mName ), url.toString() );
108  }
109 
110  return content;
111  }
112 
114  {
115  bool ok = false;
116  const QUrl url = QgsServerParameterDefinition::toUrl( ok );
117 
118  if ( !ok )
119  {
120  raiseError();
121  }
122 
123  return url;
124  }
125 
127  {
128  bool ok = false;
129  const QColor col = QgsServerParameterDefinition::toColor( ok );
130 
131  if ( !ok )
132  {
133  raiseError();
134  }
135 
136  return col;
137  }
138 
139  QList<QColor> QgsWmsParameter::toColorList( const char delimiter ) const
140  {
141  bool ok = false;
142  const QList<QColor> vals = QgsServerParameterDefinition::toColorList( ok, delimiter );
143 
144  if ( !ok )
145  {
146  const QString msg = QString( "%1 ('%2') cannot be converted into a list of colors" ).arg( name( mName ), toString() );
148  }
149 
150  return vals;
151  }
152 
153  QList<int> QgsWmsParameter::toIntList( const char delimiter ) const
154  {
155  bool ok = false;
156  const QList<int> vals = QgsServerParameterDefinition::toIntList( ok, delimiter );
157 
158  if ( !ok )
159  {
160  const QString msg = QString( "%1 ('%2') cannot be converted into a list of int" ).arg( name( mName ), toString() );
162  }
163 
164  return vals;
165  }
166 
167  QList<double> QgsWmsParameter::toDoubleList( const char delimiter ) const
168  {
169  bool ok = false;
170  const QList<double> vals = QgsServerParameterDefinition::toDoubleList( ok, delimiter );
171 
172  if ( !ok )
173  {
174  const QString msg = QString( "%1 ('%2') cannot be converted into a list of float" ).arg( name( mName ), toString() );
176  }
177 
178  return vals;
179  }
180 
182  {
183  bool ok = false;
184  const double val = QgsServerParameterDefinition::toDouble( ok );
185 
186  if ( !ok )
187  {
188  raiseError();
189  }
190 
191  return val;
192  }
193 
194  QString QgsWmsParameter::name() const
195  {
196  return QgsWmsParameter::name( mName );
197  }
198 
200  {
201  const QMetaEnum metaEnum( QMetaEnum::fromType<QgsWmsParameter::Name>() );
202  return metaEnum.valueToKey( name );
203  }
204 
206  {
207  const QMetaEnum metaEnum( QMetaEnum::fromType<QgsWmsParameter::Name>() );
208  return ( QgsWmsParameter::Name ) metaEnum.keyToValue( name.toUpper().toStdString().c_str() );
209  }
210 
211  //
212  // QgsWmsParameters
213  //
216  {
217  // Available version number
218  mVersions.append( QgsProjectVersion( 1, 1, 1 ) );
219  mVersions.append( QgsProjectVersion( 1, 3, 0 ) );
220 
221  // WMS parameters definition
223  QVariant::Int,
224  QVariant( 0 ) );
225  save( pQuality );
226 
228  QVariant::Bool,
229  QVariant( false ) );
230  save( pTiled );
231 
233  QVariant::Double,
234  QVariant( 2.0 ) );
235  save( pBoxSpace );
236 
238  QVariant::Double,
239  QVariant( 2.0 ) );
240  save( pSymbSpace );
241 
242  const QgsWmsParameter pLayerSpace( QgsWmsParameter::LAYERSPACE,
243  QVariant::Double,
244  QVariant( 3.0 ) );
245  save( pLayerSpace );
246 
248  QVariant::Double,
249  QVariant( 3.0 ) );
250  save( pTitleSpace );
251 
253  QVariant::Double,
254  QVariant( 4.0 ) );
255  save( pSymbHeight );
256 
258  QVariant::Double,
259  QVariant( 7.0 ) );
260  save( pSymbWidth );
261 
263  QVariant::Double,
264  QVariant( 2.0 ) );
265  save( pIcLabelSpace );
266 
267  const QgsWmsParameter pItFontFamily( QgsWmsParameter::ITEMFONTFAMILY );
268  save( pItFontFamily );
269 
271  QVariant::Bool,
272  QVariant( false ) );
273  save( pItFontBold );
274 
276  QVariant::Bool,
277  QVariant( false ) );
278  save( pItFontItalic );
279 
281  QVariant::Double,
282  QVariant( -1 ) );
283  save( pItFontSize );
284 
286  QVariant::String,
287  QVariant( "black" ) );
288  save( pItFontColor );
289 
290  const QgsWmsParameter pHighlightGeom( QgsWmsParameter::HIGHLIGHT_GEOM );
291  save( pHighlightGeom );
292 
293  const QgsWmsParameter pShowFeatureCount( QgsWmsParameter::SHOWFEATURECOUNT,
294  QVariant::Bool,
295  QVariant( false ) );
296  save( pShowFeatureCount );
297 
298  const QgsWmsParameter pHighlightSymbol( QgsWmsParameter::HIGHLIGHT_SYMBOL );
299  save( pHighlightSymbol );
300 
302  save( pHighlightLabel );
303 
305  QVariant::String,
306  QVariant( "black" ) );
307  save( pHighlightColor );
308 
309  const QgsWmsParameter pHighlightFontSize( QgsWmsParameter::HIGHLIGHT_LABELSIZE );
310  save( pHighlightFontSize );
311 
312  const QgsWmsParameter pHighlightFontWeight( QgsWmsParameter::HIGHLIGHT_LABELWEIGHT );
313  save( pHighlightFontWeight );
314 
316  save( pHighlightFont );
317 
319  QVariant::String,
320  QVariant( "black" ) );
321  save( pHighlightBufferColor );
322 
323  const QgsWmsParameter pHighlightBufferSize( QgsWmsParameter::HIGHLIGHT_LABELBUFFERSIZE );
324  save( pHighlightBufferSize );
325 
327  save( pCRS );
328 
330  save( pSRS );
331 
333  QVariant::String,
334  QVariant( "png" ) );
335  save( pFormat );
336 
337  const QgsWmsParameter pInfoFormat( QgsWmsParameter::INFO_FORMAT );
338  save( pInfoFormat );
339 
341  QVariant::Int,
342  QVariant( -1 ) );
343  save( pI );
344 
346  QVariant::Int,
347  QVariant( -1 ) );
348  save( pJ );
349 
351  QVariant::Int,
352  QVariant( -1 ) );
353  save( pX );
354 
356  QVariant::Int,
357  QVariant( -1 ) );
358  save( pY );
359 
360  const QgsWmsParameter pRule( QgsWmsParameter::RULE );
361  save( pRule );
362 
364  QVariant::Bool,
365  QVariant( true ) );
366  save( pRuleLabel );
367 
369  QVariant::Double,
370  QVariant( -1 ) );
371  save( pScale );
372 
374  QVariant::Int,
375  QVariant( 0 ) );
376  save( pHeight );
377 
379  QVariant::Int,
380  QVariant( 0 ) );
381  save( pWidth );
382 
384  QVariant::Int,
385  QVariant( 0 ) );
386  save( pSrcHeight );
387 
389  QVariant::Int,
390  QVariant( 0 ) );
391  save( pSrcWidth );
392 
393  const QgsWmsParameter pBbox( QgsWmsParameter::BBOX );
394  save( pBbox );
395 
397  save( pSld );
398 
399  const QgsWmsParameter pSldBody( QgsWmsParameter::SLD_BODY );
400  save( pSldBody );
401 
402  const QgsWmsParameter pLayer( QgsWmsParameter::LAYER );
403  save( pLayer );
404 
405  const QgsWmsParameter pLayers( QgsWmsParameter::LAYERS );
406  save( pLayers );
407 
408  const QgsWmsParameter pQueryLayers( QgsWmsParameter::QUERY_LAYERS );
409  save( pQueryLayers );
410 
411  const QgsWmsParameter pFeatureCount( QgsWmsParameter::FEATURE_COUNT,
412  QVariant::Int,
413  QVariant( 1 ) );
414  save( pFeatureCount );
415 
416  const QgsWmsParameter pLayerTitle( QgsWmsParameter::LAYERTITLE,
417  QVariant::Bool,
418  QVariant( true ) );
419  save( pLayerTitle );
420 
421  const QgsWmsParameter pLayerFtFamily( QgsWmsParameter::LAYERFONTFAMILY );
422  save( pLayerFtFamily );
423 
425  QVariant::Bool,
426  QVariant( false ) );
427  save( pLayerFtBold );
428 
430  QVariant::Bool,
431  QVariant( false ) );
432  save( pLayerFtItalic );
433 
435  QVariant::Double,
436  QVariant( -1 ) );
437  save( pLayerFtSize );
438 
440  QVariant::String,
441  QVariant( "black" ) );
442  save( pLayerFtColor );
443 
444  const QgsWmsParameter pStyle( QgsWmsParameter::STYLE );
445  save( pStyle );
446 
447  const QgsWmsParameter pStyles( QgsWmsParameter::STYLES );
448  save( pStyles );
449 
450  const QgsWmsParameter pOpacities( QgsWmsParameter::OPACITIES );
451  save( pOpacities );
452 
453  const QgsWmsParameter pFilter( QgsWmsParameter::FILTER );
454  save( pFilter );
455 
456  const QgsWmsParameter pFilterGeom( QgsWmsParameter::FILTER_GEOM );
457  save( pFilterGeom );
458 
460  QVariant::Double,
461  QVariant( 0.0 ) );
462  save( pPolygTol );
463 
465  QVariant::Double,
466  QVariant( 0.0 ) );
467  save( pLineTol );
468 
470  QVariant::Double,
471  QVariant( 0.0 ) );
472  save( pPointTol );
473 
474  const QgsWmsParameter pSelection( QgsWmsParameter::SELECTION );
475  save( pSelection );
476 
477  const QgsWmsParameter pWmsPrecision( QgsWmsParameter::WMS_PRECISION,
478  QVariant::Int,
479  QVariant( -1 ) );
480  save( pWmsPrecision );
481 
482  const QgsWmsParameter pTransparent( QgsWmsParameter::TRANSPARENT,
483  QVariant::Bool,
484  QVariant( false ) );
485  save( pTransparent );
486 
488  QVariant::String,
489  QVariant( "white" ) );
490  save( pBgColor );
491 
493  QVariant::Int,
494  QVariant( -1 ) );
495  save( pDpi );
496 
497  const QgsWmsParameter pTemplate( QgsWmsParameter::TEMPLATE );
498  save( pTemplate );
499 
500  const QgsWmsParameter pExtent( QgsWmsParameter::EXTENT );
501  save( pExtent );
502 
504  QVariant::Double,
505  QVariant( 0.0 ) );
506  save( pRotation );
507 
509  QVariant::Double,
510  QVariant( 0.0 ) );
511  save( pGridX );
512 
514  QVariant::Double,
515  QVariant( 0.0 ) );
516  save( pGridY );
517 
518  const QgsWmsParameter pWithGeometry( QgsWmsParameter::WITH_GEOMETRY,
519  QVariant::Bool,
520  QVariant( false ) );
521  save( pWithGeometry );
522 
524  QVariant::Bool,
525  QVariant( false ) );
526  save( pWithMapTip );
527 
528  const QgsWmsParameter pWmtver( QgsWmsParameter::WMTVER );
529  save( pWmtver );
530 
532  QVariant::StringList );
533  save( pAtlasPk );
534 
536  QVariant::String );
537  save( pFormatOpts );
538  }
539 
541  : QgsWmsParameters()
542  {
543  load( parameters.urlQuery() );
544 
545  const QString sld = mWmsParameters[ QgsWmsParameter::SLD ].toString();
546  if ( !sld.isEmpty() )
547  {
548  const QString sldBody = mWmsParameters[ QgsWmsParameter::SLD ].loadUrl();
549  if ( !sldBody.isEmpty() )
550  {
552  }
553  }
554  }
555 
557  {
558  return mWmsParameters[name];
559  }
560 
561  void QgsWmsParameters::set( QgsWmsParameter::Name name, const QVariant &value )
562  {
563  mWmsParameters[name].mValue = value;
564  }
565 
566  bool QgsWmsParameters::loadParameter( const QString &key, const QString &value )
567  {
568  bool loaded = false;
569 
570  const QRegExp composerParamRegExp( QStringLiteral( "^MAP\\d+:" ), Qt::CaseInsensitive );
571  if ( key.contains( composerParamRegExp ) )
572  {
573 #if QT_VERSION < QT_VERSION_CHECK(5, 15, 2)
574  const int mapId = key.midRef( 3, key.indexOf( ':' ) - 3 ).toInt();
575 #else
576  const int mapId = QStringView {key}.mid( 3, key.indexOf( ':' ) - 3 ).toInt();
577 #endif
578  const QString theKey = key.mid( key.indexOf( ':' ) + 1 );
579  const QgsWmsParameter::Name name = QgsWmsParameter::name( theKey );
580 
581  if ( name >= 0 )
582  {
583  QgsWmsParameter param = mWmsParameters[name];
584  param.mValue = value;
585  param.mId = mapId;
586 
587  if ( ! param.isValid() )
588  {
589  param.raiseError();
590  }
591 
592  save( param, true ); // multi MAP parameters for composer
593  loaded = true;
594  }
595  }
596  else
597  {
598  const QgsWmsParameter::Name name = QgsWmsParameter::name( key );
599  if ( name >= 0 )
600  {
601  mWmsParameters[name].mValue = value;
602  if ( ! mWmsParameters[name].isValid() )
603  {
604  mWmsParameters[name].raiseError();
605  }
606 
607  loaded = true;
608  }
609  else //maybe an external wms parameter?
610  {
611  int separator = key.indexOf( QLatin1Char( ':' ) );
612  if ( separator >= 1 )
613  {
614  QString id = key.left( separator );
615  QString param = key.right( key.length() - separator - 1 );
616  mExternalWMSParameters[id].insert( param, value );
617 
618  loaded = true;
619  }
620  }
621  }
622 
623  return loaded;
624  }
625 
627  {
628  log( QStringLiteral( "WMS Request parameters:" ) );
629  for ( auto parameter : mWmsParameters.toStdMap() )
630  {
631  const QString value = parameter.second.toString();
632 
633  if ( ! value.isEmpty() )
634  {
635  QString name = QgsWmsParameter::name( parameter.first );
636 
637  if ( parameter.second.mId >= 0 )
638  {
639  name = QStringLiteral( "%1:%2" ).arg( QString::number( parameter.second.mId ), name );
640  }
641 
642  log( QStringLiteral( " - %1 : %2" ).arg( name, value ) );
643  }
644  }
645 
646  if ( !version().isEmpty() )
647  log( QStringLiteral( " - VERSION : %1" ).arg( version() ) );
648  }
649 
650  void QgsWmsParameters::save( const QgsWmsParameter &parameter, bool multi )
651  {
652  if ( multi )
653  {
654  mWmsParameters.insertMulti( parameter.mName, parameter );
655  }
656  else
657  {
658  mWmsParameters[ parameter.mName ] = parameter;
659  }
660  }
661 
663  {
664  return mWmsParameters[ QgsWmsParameter::HIGHLIGHT_GEOM ].toStringList( ';' );
665  }
666 
667  QList<QgsGeometry> QgsWmsParameters::highlightGeomAsGeom() const
668  {
669  return mWmsParameters[QgsWmsParameter::HIGHLIGHT_GEOM].toGeomList( ';' );
670  }
671 
673  {
674  return mWmsParameters[ QgsWmsParameter::HIGHLIGHT_SYMBOL ].toStringList( ';' );
675  }
676 
677  QString QgsWmsParameters::crs() const
678  {
679  QString rs;
680  const QString srs = mWmsParameters[ QgsWmsParameter::SRS ].toString();
681  const QString crs = mWmsParameters[ QgsWmsParameter::CRS ].toString();
682 
683  // both SRS/CRS are supported but there's a priority according to the
684  // specified version when both are defined in the request
685  if ( !srs.isEmpty() && crs.isEmpty() )
686  rs = srs;
687  else if ( srs.isEmpty() && !crs.isEmpty() )
688  rs = crs;
689  else if ( !srs.isEmpty() && !crs.isEmpty() )
690  {
691  if ( versionAsNumber() >= QgsProjectVersion( 1, 3, 0 ) )
692  rs = crs;
693  else
694  rs = srs;
695  }
696 
697  return rs;
698  }
699 
700  QString QgsWmsParameters::bbox() const
701  {
702  return mWmsParameters[ QgsWmsParameter::BBOX ].toString();
703  }
704 
706  {
707  return mWmsParameters[ QgsWmsParameter::BBOX ].toRectangle();
708  }
709 
710  QString QgsWmsParameters::height() const
711  {
712  return mWmsParameters[ QgsWmsParameter::HEIGHT ].toString();
713  }
714 
715  QString QgsWmsParameters::width() const
716  {
717  return mWmsParameters[ QgsWmsParameter::WIDTH ].toString();
718  }
719 
721  {
722  return mWmsParameters[ QgsWmsParameter::HEIGHT ].toInt();
723  }
724 
726  {
727  return mWmsParameters[ QgsWmsParameter::WIDTH ].toInt();
728  }
729 
731  {
732  return mWmsParameters[ QgsWmsParameter::SRCHEIGHT ].toString();
733  }
734 
736  {
737  return mWmsParameters[ QgsWmsParameter::SRCWIDTH ].toString();
738  }
739 
741  {
742  return mWmsParameters[ QgsWmsParameter::SRCHEIGHT ].toInt();
743  }
744 
746  {
747  return mWmsParameters[ QgsWmsParameter::SRCWIDTH ].toInt();
748  }
749 
750  QString QgsWmsParameters::dpi() const
751  {
752  return mWmsParameters[ QgsWmsParameter::DPI ].toString();
753  }
754 
756  {
757  return mWmsParameters[ QgsWmsParameter::DPI ].toDouble();
758  }
759 
761  {
763 
764  if ( QgsServerParameters::request().compare( QLatin1String( "GetProjectSettings" ), Qt::CaseInsensitive ) == 0 )
765  {
766  version = QStringLiteral( "1.3.0" );
767  }
768  else if ( version.isEmpty() )
769  {
770  if ( ! wmtver().isEmpty() )
771  {
772  version = wmtver();
773  }
774  else
775  {
776  version = QStringLiteral( "1.3.0" );
777  }
778  }
779  else if ( !mVersions.contains( QgsProjectVersion( version ) ) )
780  {
781  // WMS 1.3.0 specification: If a version lower than any of those
782  // known to the server is requested, then the server shall send the
783  // lowest version it supports.
784  if ( QgsProjectVersion( 1, 1, 1 ) > QgsProjectVersion( version ) )
785  {
786  version = QStringLiteral( "1.1.1" );
787  }
788  else
789  {
790  version = QStringLiteral( "1.3.0" );
791  }
792  }
793 
794  return version;
795  }
796 
798  {
799  QString req = QgsServerParameters::request();
800 
801  if ( version().compare( QLatin1String( "1.1.1" ) ) == 0
802  && req.compare( QLatin1String( "capabilities" ), Qt::CaseInsensitive ) == 0 )
803  {
804  req = QStringLiteral( "GetCapabilities" );
805  }
806 
807  return req;
808  }
809 
811  {
812  return QgsProjectVersion( version() );
813  }
814 
815  bool QgsWmsParameters::versionIsValid( const QString version ) const
816  {
817  return mVersions.contains( QgsProjectVersion( version ) );
818  }
819 
821  {
822  return mWmsParameters[ QgsWmsParameter::FORMAT ].toString( true );
823  }
824 
826  {
827  const QMetaEnum metaEnum( QMetaEnum::fromType<QgsWmsParameters::Format>() );
828  return metaEnum.valueToKey( format );
829  }
830 
832  {
833  const QString fStr = formatAsString();
834 
835  Format f = Format::NONE;
836  if ( fStr.compare( QLatin1String( "image/png" ), Qt::CaseInsensitive ) == 0 ||
837  fStr.compare( QLatin1String( "png" ), Qt::CaseInsensitive ) == 0 )
838  {
839  f = Format::PNG;
840  }
841  else if ( fStr.compare( QLatin1String( "jpg" ), Qt::CaseInsensitive ) == 0
842  || fStr.compare( QLatin1String( "jpeg" ), Qt::CaseInsensitive ) == 0
843  || fStr.compare( QLatin1String( "image/jpeg" ), Qt::CaseInsensitive ) == 0 )
844  {
845  f = Format::JPG;
846  }
847  else if ( fStr.compare( QLatin1String( "image/svg" ), Qt::CaseInsensitive ) == 0 ||
848  fStr.compare( QLatin1String( "image/svg+xml" ), Qt::CaseInsensitive ) == 0 ||
849  fStr.compare( QLatin1String( "svg" ), Qt::CaseInsensitive ) == 0 )
850  {
851  f = Format::SVG;
852  }
853  else if ( fStr.compare( QLatin1String( "application/pdf" ), Qt::CaseInsensitive ) == 0 ||
854  fStr.compare( QLatin1String( "pdf" ), Qt::CaseInsensitive ) == 0 )
855  {
856  f = Format::PDF;
857  }
858  else if ( fStr.compare( QLatin1String( "application/json" ), Qt::CaseInsensitive ) == 0 ||
859  fStr.compare( QLatin1String( "json" ), Qt::CaseInsensitive ) == 0 )
860  {
861  f = Format::JSON;
862  }
863  return f;
864  }
865 
867  {
868  return mWmsParameters[ QgsWmsParameter::INFO_FORMAT ].toString();
869  }
870 
872  {
873  return infoFormat() == Format::PNG || infoFormat() == Format::JPG;
874  }
875 
877  {
878  QString fStr = infoFormatAsString();
879 
880  Format f = Format::TEXT;
881  if ( fStr.isEmpty() )
882  return f;
883 
884  if ( fStr.startsWith( QLatin1String( "text/xml" ), Qt::CaseInsensitive ) )
885  f = Format::XML;
886  else if ( fStr.startsWith( QLatin1String( "text/html" ), Qt::CaseInsensitive ) )
887  f = Format::HTML;
888  else if ( fStr.startsWith( QLatin1String( "text/plain" ), Qt::CaseInsensitive ) )
889  f = Format::TEXT;
890  else if ( fStr.startsWith( QLatin1String( "application/vnd.ogc.gml" ), Qt::CaseInsensitive ) )
891  f = Format::GML;
892  else if ( fStr.startsWith( QLatin1String( "application/json" ), Qt::CaseInsensitive )
893  || fStr.startsWith( QLatin1String( "application/geo+json" ), Qt::CaseInsensitive ) )
894  f = Format::JSON;
895  else
896  f = Format::NONE;
897 
898  return f;
899  }
900 
902  {
903  if ( infoFormat() != Format::GML )
904  return -1;
905 
906  QString fStr = infoFormatAsString();
907  if ( fStr.startsWith( QLatin1String( "application/vnd.ogc.gml/3" ), Qt::CaseInsensitive ) )
908  return 3;
909  else
910  return 2;
911  }
912 
913  QString QgsWmsParameters::i() const
914  {
915  return mWmsParameters[ QgsWmsParameter::I ].toString();
916  }
917 
918  QString QgsWmsParameters::j() const
919  {
920  return mWmsParameters[ QgsWmsParameter::J ].toString();
921  }
922 
924  {
925  return mWmsParameters[ QgsWmsParameter::I ].toInt();
926  }
927 
929  {
930  return mWmsParameters[ QgsWmsParameter::J ].toInt();
931  }
932 
933  QString QgsWmsParameters::x() const
934  {
935  return mWmsParameters[ QgsWmsParameter::X ].toString();
936  }
937 
938  QString QgsWmsParameters::y() const
939  {
940  return mWmsParameters[ QgsWmsParameter::Y ].toString();
941  }
942 
944  {
945  return mWmsParameters[ QgsWmsParameter::X ].toInt();
946  }
947 
949  {
950  return mWmsParameters[ QgsWmsParameter::Y ].toInt();
951  }
952 
953  QString QgsWmsParameters::rule() const
954  {
955  return mWmsParameters[ QgsWmsParameter::RULE ].toString();
956  }
957 
959  {
960  return mWmsParameters[ QgsWmsParameter::RULELABEL ].toString();
961  }
962 
964  {
965  return mWmsParameters[ QgsWmsParameter::RULELABEL ].toBool();
966  }
967 
969  {
970  return mWmsParameters[ QgsWmsParameter::TRANSPARENT ].toString();
971  }
972 
974  {
975  return mWmsParameters[ QgsWmsParameter::TRANSPARENT ].toBool();
976  }
977 
978  QString QgsWmsParameters::scale() const
979  {
980  return mWmsParameters[ QgsWmsParameter::SCALE ].toString();
981  }
982 
984  {
985  return mWmsParameters[ QgsWmsParameter::SCALE ].toDouble();
986  }
987 
989  {
990  return mWmsParameters[ QgsWmsParameter::IMAGE_QUALITY ].toString();
991  }
992 
994  {
995  return mWmsParameters[ QgsWmsParameter::IMAGE_QUALITY ].toInt();
996  }
997 
998  QString QgsWmsParameters::tiled() const
999  {
1000  return mWmsParameters[ QgsWmsParameter::TILED ].toString();
1001  }
1002 
1004  {
1005  return mWmsParameters[ QgsWmsParameter::TILED ].toBool();
1006  }
1007 
1009  {
1010  return mWmsParameters[ QgsWmsParameter::SHOWFEATURECOUNT ].toString();
1011  }
1012 
1014  {
1015  return mWmsParameters[ QgsWmsParameter::SHOWFEATURECOUNT ].toBool();
1016  }
1017 
1019  {
1020  return mWmsParameters[ QgsWmsParameter::FEATURE_COUNT ].toString();
1021  }
1022 
1024  {
1025  return mWmsParameters[ QgsWmsParameter::FEATURE_COUNT ].toInt();
1026  }
1027 
1029  {
1030  return mWmsParameters[ QgsWmsParameter::BOXSPACE ].toString();
1031  }
1032 
1034  {
1035  return mWmsParameters[ QgsWmsParameter::BOXSPACE ].toDouble();
1036  }
1037 
1039  {
1040  return mWmsParameters[ QgsWmsParameter::LAYERSPACE ].toString();
1041  }
1042 
1044  {
1045  return mWmsParameters[ QgsWmsParameter::LAYERSPACE ].toDouble();
1046  }
1047 
1049  {
1050  return mWmsParameters[ QgsWmsParameter::LAYERTITLESPACE ].toString();
1051  }
1052 
1054  {
1055  return mWmsParameters[ QgsWmsParameter::LAYERTITLESPACE ].toDouble();
1056  }
1057 
1059  {
1060  return mWmsParameters[ QgsWmsParameter::SYMBOLSPACE ].toString();
1061  }
1062 
1064  {
1065  return mWmsParameters[ QgsWmsParameter::SYMBOLSPACE ].toDouble();
1066  }
1067 
1069  {
1070  return mWmsParameters[ QgsWmsParameter::SYMBOLHEIGHT ].toString();
1071  }
1072 
1074  {
1075  return mWmsParameters[ QgsWmsParameter::SYMBOLHEIGHT ].toDouble();
1076  }
1077 
1079  {
1080  return mWmsParameters[ QgsWmsParameter::SYMBOLWIDTH ].toString();
1081  }
1082 
1084  {
1085  return mWmsParameters[ QgsWmsParameter::SYMBOLWIDTH ].toDouble();
1086  }
1087 
1089  {
1090  return mWmsParameters[ QgsWmsParameter::ICONLABELSPACE ].toString();
1091  }
1092 
1094  {
1095  return mWmsParameters[ QgsWmsParameter::ICONLABELSPACE ].toDouble();
1096  }
1097 
1099  {
1100  return mWmsParameters[ QgsWmsParameter::LAYERFONTFAMILY ].toString();
1101  }
1102 
1104  {
1105  return mWmsParameters[ QgsWmsParameter::ITEMFONTFAMILY ].toString();
1106  }
1107 
1109  {
1110  return mWmsParameters[ QgsWmsParameter::LAYERFONTBOLD ].toString();
1111  }
1112 
1114  {
1115  return mWmsParameters[ QgsWmsParameter::LAYERFONTBOLD ].toBool();
1116  }
1117 
1119  {
1120  return mWmsParameters[ QgsWmsParameter::ITEMFONTBOLD ].toString();
1121  }
1122 
1124  {
1125  return mWmsParameters[ QgsWmsParameter::FI_POLYGON_TOLERANCE ].toString();
1126  }
1127 
1129  {
1130  return mWmsParameters[ QgsWmsParameter::FI_LINE_TOLERANCE ].toString();
1131  }
1132 
1134  {
1135  return mWmsParameters[ QgsWmsParameter::FI_POINT_TOLERANCE ].toString();
1136  }
1137 
1139  {
1140  return mWmsParameters[ QgsWmsParameter::FI_POLYGON_TOLERANCE ].toInt();
1141  }
1142 
1144  {
1145  return mWmsParameters[ QgsWmsParameter::FI_LINE_TOLERANCE ].toInt();
1146  }
1147 
1149  {
1150  return mWmsParameters[ QgsWmsParameter::FI_POINT_TOLERANCE ].toInt();
1151  }
1152 
1154  {
1155  return mWmsParameters[ QgsWmsParameter::ITEMFONTBOLD ].toBool();
1156  }
1157 
1159  {
1160  return mWmsParameters[ QgsWmsParameter::LAYERFONTITALIC ].toString();
1161  }
1162 
1164  {
1165  return mWmsParameters[ QgsWmsParameter::LAYERFONTITALIC ].toBool();
1166  }
1167 
1169  {
1170  return mWmsParameters[ QgsWmsParameter::ITEMFONTITALIC ].toString();
1171  }
1172 
1174  {
1175  return mWmsParameters[ QgsWmsParameter::ITEMFONTITALIC ].toBool();
1176  }
1177 
1179  {
1180  return mWmsParameters[ QgsWmsParameter::LAYERFONTSIZE ].toString();
1181  }
1182 
1184  {
1185  return mWmsParameters[ QgsWmsParameter::LAYERFONTSIZE ].toDouble();
1186  }
1187 
1189  {
1190  return mWmsParameters[ QgsWmsParameter::LAYERFONTCOLOR ].toString();
1191  }
1192 
1194  {
1195  return mWmsParameters[ QgsWmsParameter::LAYERFONTCOLOR ].toColor();
1196  }
1197 
1199  {
1200  return mWmsParameters[ QgsWmsParameter::ITEMFONTSIZE ].toString();
1201  }
1202 
1204  {
1205  return mWmsParameters[ QgsWmsParameter::ITEMFONTSIZE ].toDouble();
1206  }
1207 
1209  {
1210  return mWmsParameters[ QgsWmsParameter::ITEMFONTCOLOR ].toString();
1211  }
1212 
1214  {
1215  return mWmsParameters[ QgsWmsParameter::ITEMFONTCOLOR ].toColor();
1216  }
1217 
1219  {
1220  QFont font;
1221  font.fromString( "" );
1222  font.setBold( layerFontBoldAsBool() );
1223  font.setItalic( layerFontItalicAsBool() );
1224 
1225  if ( ! layerFontSize().isEmpty() )
1226  font.setPointSizeF( layerFontSizeAsDouble() );
1227 
1228  if ( !layerFontFamily().isEmpty() )
1229  font.setFamily( layerFontFamily() );
1230 
1231  return font;
1232  }
1233 
1235  {
1236  QFont font;
1237  font.fromString( "" );
1238 
1239  font.setBold( itemFontBoldAsBool() );
1240  font.setItalic( itemFontItalicAsBool() );
1241 
1242  if ( ! itemFontSize().isEmpty() )
1243  font.setPointSizeF( itemFontSizeAsDouble() );
1244 
1245  if ( !itemFontFamily().isEmpty() )
1246  font.setFamily( itemFontFamily() );
1247 
1248  return font;
1249  }
1250 
1252  {
1253  return mWmsParameters[ QgsWmsParameter::LAYERTITLE ].toString();
1254  }
1255 
1257  {
1258  return mWmsParameters[ QgsWmsParameter::LAYERTITLE ].toBool();
1259  }
1260 
1262  {
1263  QgsLegendSettings settings;
1264  settings.setTitle( QString() );
1265  settings.setBoxSpace( boxSpaceAsDouble() );
1266  settings.setSymbolSize( QSizeF( symbolWidthAsDouble(), symbolHeightAsDouble() ) );
1267 
1268  settings.rstyle( QgsLegendStyle::Style::Subgroup ).setMargin( QgsLegendStyle::Side::Top, layerSpaceAsDouble() );
1269  settings.rstyle( QgsLegendStyle::Style::Subgroup ).setMargin( QgsLegendStyle::Side::Bottom, layerTitleSpaceAsDouble() );
1270  settings.rstyle( QgsLegendStyle::Style::Subgroup ).setFont( layerFont() );
1271 
1272  if ( !itemFontColor().isEmpty() )
1273  {
1274  settings.setFontColor( itemFontColorAsColor() );
1275  }
1276 
1277  // Ok, this is tricky: because QgsLegendSettings's layerFontColor was added to the API after
1278  // fontColor, to fix regressions #21871 and #21870 and the previous behavior was to use fontColor
1279  // for the whole legend we need to preserve that behavior.
1280  // But, the 2.18 server parameters ITEMFONTCOLOR did not have effect on the layer titles too, so
1281  // we set explicitly layerFontColor to black if it's not overridden by LAYERFONTCOLOR argument.
1282  settings.setLayerFontColor( layerFontColor().isEmpty() ? QColor( Qt::black ) : layerFontColorAsColor() );
1283 
1284  settings.rstyle( QgsLegendStyle::Style::SymbolLabel ).setFont( itemFont() );
1285  settings.rstyle( QgsLegendStyle::Style::Symbol ).setMargin( QgsLegendStyle::Side::Top, symbolSpaceAsDouble() );
1286  settings.rstyle( QgsLegendStyle::Style::SymbolLabel ).setMargin( QgsLegendStyle::Side::Left, iconLabelSpaceAsDouble() );
1287 
1288  return settings;
1289  }
1290 
1291  QString QgsWmsParameters::layoutParameter( const QString &id, bool &ok ) const
1292  {
1293  QString label;
1294  ok = false;
1295 
1296  if ( mUnmanagedParameters.contains( id.toUpper() ) )
1297  {
1298  label = mUnmanagedParameters[id.toUpper()];
1299  ok = true;
1300  }
1301 
1302  return label;
1303  }
1304 
1305  QStringList QgsWmsParameters::atlasPk() const
1306  {
1307  return mWmsParameters[ QgsWmsParameter::ATLAS_PK ].toStringList();
1308  }
1309 
1311  {
1312  return mWmsParameters[ QgsWmsParameter::HIGHLIGHT_LABELSTRING ].toStringList( ';' );
1313  }
1314 
1316  {
1317  return mWmsParameters[ QgsWmsParameter::HIGHLIGHT_LABELSIZE ].toStringList( ';' );
1318  }
1319 
1321  {
1322  return mWmsParameters[ QgsWmsParameter::HIGHLIGHT_LABELSIZE ].toIntList( ';' );
1323  }
1324 
1326  {
1327  return mWmsParameters[ QgsWmsParameter::HIGHLIGHT_LABELCOLOR ].toStringList( ';' );
1328  }
1329 
1331  {
1332  return mWmsParameters[ QgsWmsParameter::HIGHLIGHT_LABELCOLOR ].toColorList( ';' );
1333  }
1334 
1336  {
1337  return mWmsParameters[ QgsWmsParameter::HIGHLIGHT_LABELWEIGHT ].toStringList( ';' );
1338  }
1339 
1341  {
1342  return mWmsParameters[ QgsWmsParameter::HIGHLIGHT_LABELWEIGHT ].toIntList( ';' );
1343  }
1344 
1346  {
1347  return mWmsParameters[ QgsWmsParameter::HIGHLIGHT_LABELFONT ].toStringList( ';' );
1348  }
1349 
1351  {
1352  return mWmsParameters[ QgsWmsParameter::HIGHLIGHT_LABELBUFFERCOLOR ].toStringList( ';' );
1353  }
1354 
1356  {
1357  return mWmsParameters[ QgsWmsParameter::HIGHLIGHT_LABELBUFFERCOLOR ].toColorList( ';' );
1358  }
1359 
1361  {
1362  return mWmsParameters[ QgsWmsParameter::HIGHLIGHT_LABELBUFFERSIZE ].toStringList( ';' );
1363  }
1364 
1366  {
1367  return mWmsParameters[ QgsWmsParameter::HIGHLIGHT_LABELBUFFERSIZE ].toDoubleList( ';' );
1368  }
1369 
1371  {
1372  return mWmsParameters[ QgsWmsParameter::WMS_PRECISION ].toString();
1373  }
1374 
1376  {
1377  return mWmsParameters[ QgsWmsParameter::WMS_PRECISION ].toInt();
1378  }
1379 
1381  {
1382  return mWmsParameters[ QgsWmsParameter::SLD_BODY ].toString();
1383  }
1384 
1385  QStringList QgsWmsParameters::filters() const
1386  {
1387  const QString filter = mWmsParameters[ QgsWmsParameter::FILTER ].toString();
1388  QStringList results;
1389  int pos = 0;
1390  while ( pos < filter.size() )
1391  {
1392  if ( pos + 1 < filter.size() && filter[pos] == '(' && filter[pos + 1] == '<' )
1393  {
1394  // OGC filter on multiple layers
1395  int posEnd = filter.indexOf( "Filter>)", pos );
1396  if ( posEnd < 0 )
1397  {
1398  posEnd = filter.size();
1399  }
1400  results.append( filter.mid( pos + 1, posEnd - pos + 6 ) );
1401  pos = posEnd + 8;
1402  }
1403  else if ( pos + 1 < filter.size() && filter[pos] == '(' && filter[pos + 1] == ')' )
1404  {
1405  // empty OGC filter
1406  results.append( "" );
1407  pos += 2;
1408  }
1409  else if ( filter[pos] == '<' )
1410  {
1411  // Single OGC filter
1412  results.append( filter.mid( pos ) );
1413  break;
1414  }
1415  else
1416  {
1417  // QGIS specific filter
1418  int posEnd = filter.indexOf( ';', pos + 1 );
1419  if ( posEnd < 0 )
1420  {
1421  posEnd = filter.size();
1422  }
1423  results.append( filter.mid( pos, posEnd - pos ) );
1424  pos = posEnd + 1;
1425  }
1426  }
1427  return results;
1428  }
1429 
1431  {
1432  return mWmsParameters[ QgsWmsParameter::FILTER_GEOM ].toString();
1433  }
1434 
1435  QStringList QgsWmsParameters::selections() const
1436  {
1437  return mWmsParameters[ QgsWmsParameter::SELECTION ].toStringList( ';' );
1438  }
1439 
1440  QStringList QgsWmsParameters::opacities() const
1441  {
1442  return mWmsParameters[ QgsWmsParameter::OPACITIES ].toStringList();
1443  }
1444 
1446  {
1447  return mWmsParameters[ QgsWmsParameter::OPACITIES ].toIntList();
1448  }
1449 
1451  {
1452  QStringList layer = mWmsParameters[ QgsWmsParameter::LAYER ].toStringList();
1453  const QStringList layers = mWmsParameters[ QgsWmsParameter::LAYERS ].toStringList();
1454  return layer << layers;
1455  }
1456 
1458  {
1459  return mWmsParameters[ QgsWmsParameter::QUERY_LAYERS ].toStringList();
1460  }
1461 
1462  QStringList QgsWmsParameters::allStyles() const
1463  {
1464  QStringList style = mWmsParameters[ QgsWmsParameter::STYLE ].toStyleList();
1465  const QStringList styles = mWmsParameters[ QgsWmsParameter::STYLES ].toStyleList();
1466  return style << styles;
1467  }
1468 
1469  QMultiMap<QString, QgsWmsParametersFilter> QgsWmsParameters::layerFilters( const QStringList &layers ) const
1470  {
1471  const QString nsWfs2 = QStringLiteral( "http://www.opengis.net/fes/2.0" );
1472  const QString prefixWfs2 = QStringLiteral( "<fes:" );
1473 
1474  const QStringList rawFilters = filters();
1475  QMultiMap<QString, QgsWmsParametersFilter> filters;
1476  for ( int i = 0; i < rawFilters.size(); i++ )
1477  {
1478  const QString f = rawFilters[i];
1479  if ( f.startsWith( QLatin1Char( '<' ) ) \
1480  && f.endsWith( QLatin1String( "Filter>" ) ) \
1481  && i < layers.size() )
1482  {
1483  QgsWmsParametersFilter filter;
1484  filter.mFilter = f;
1487 
1488  if ( filter.mFilter.contains( nsWfs2 ) \
1489  || filter.mFilter.contains( prefixWfs2 ) )
1490  {
1492  }
1493 
1494  filters.insert( layers[i], filter );
1495  }
1496  else if ( !f.isEmpty() )
1497  {
1498  // filter format: "LayerName,LayerName2:filterString;LayerName3:filterString2;..."
1499  // several filters can be defined for one layer
1500  const int colonIndex = f.indexOf( ':' );
1501  if ( colonIndex != -1 )
1502  {
1503  const QString layers = f.section( ':', 0, 0 );
1504  const QString filter = f.section( ':', 1 );
1505  const QStringList layersList = layers.split( ',' );
1506  for ( const QString &layer : layersList )
1507  {
1508  QgsWmsParametersFilter parametersFilter;
1509  parametersFilter.mFilter = filter;
1510  parametersFilter.mType = QgsWmsParametersFilter::SQL;
1511  filters.insert( layer, parametersFilter );
1512  }
1513  }
1514  else
1515  {
1516  QString filterStr = mWmsParameters[ QgsWmsParameter::FILTER ].toString();
1517  raiseError( QStringLiteral( "FILTER ('" ) + filterStr + QStringLiteral( "') is not properly formatted" ) );
1518  }
1519  }
1520  }
1521  return filters;
1522  }
1523 
1525  {
1526  bool force2D = false;
1527  const QMap<DxfFormatOption, QString> options = dxfFormatOptions();
1528 
1529  if ( options.contains( DxfFormatOption::FORCE_2D ) )
1530  {
1531  force2D = QVariant( options[ DxfFormatOption::FORCE_2D ] ).toBool();
1532  }
1533 
1534  return force2D;
1535  }
1536 
1538  {
1539  bool noMText = false;
1540  const QMap<DxfFormatOption, QString> options = dxfFormatOptions();
1541 
1542  if ( options.contains( DxfFormatOption::NO_MTEXT ) )
1543  {
1544  noMText = QVariant( options[ DxfFormatOption::NO_MTEXT ] ).toBool();
1545  }
1546 
1547  return noMText;
1548  }
1549 
1550  QList<QgsWmsParametersLayer> QgsWmsParameters::layersParameters() const
1551  {
1552  const QStringList layers = allLayersNickname();
1553  const QStringList styles = allStyles();
1554  const QStringList selection = selections();
1555  const QList<int> opacities = opacitiesAsInt();
1556  const QMultiMap<QString, QgsWmsParametersFilter> filters = layerFilters( layers );
1557 
1558  // selection format: "LayerName:id0,id1;LayerName2:id0,id1;..."
1559  // several filters can be defined for one layer
1560  QMultiMap<QString, QString> layerSelections;
1561  for ( const QString &s : selection )
1562  {
1563  const QStringList splits = s.split( ':' );
1564  if ( splits.size() == 2 )
1565  {
1566  layerSelections.insert( splits[0], splits[1] );
1567  }
1568  else
1569  {
1570  QString selStr = mWmsParameters[ QgsWmsParameter::SELECTION ].toString();
1571  raiseError( QStringLiteral( "SELECTION ('" ) + selStr + QStringLiteral( "') is not properly formatted" ) );
1572  }
1573  }
1574 
1575  QList<QgsWmsParametersLayer> parameters;
1576  for ( int i = 0; i < layers.size(); i++ )
1577  {
1578  QString layer = layers[i];
1579 
1580  QgsWmsParametersLayer param;
1581  param.mNickname = layer;
1582 
1583  if ( i < opacities.count() )
1584  param.mOpacity = opacities[i];
1585 
1586  if ( isExternalLayer( layer ) )
1587  {
1588  const QgsWmsParametersExternalLayer extParam = externalLayerParameter( layer );
1589  param.mNickname = extParam.mName;
1590  param.mExternalUri = extParam.mUri;
1591  }
1592  else
1593  {
1594  if ( i < styles.count() )
1595  param.mStyle = styles[i];
1596 
1597  if ( filters.contains( layer ) )
1598  {
1599  auto it = filters.find( layer );
1600  while ( it != filters.end() && it.key() == layer )
1601  {
1602  param.mFilter.append( it.value() );
1603  ++it;
1604  }
1605  }
1606 
1607  if ( layerSelections.contains( layer ) )
1608  {
1609  QMultiMap<QString, QString>::const_iterator it;
1610  it = layerSelections.constFind( layer );
1611  while ( it != layerSelections.constEnd() && it.key() == layer )
1612  {
1613  param.mSelection << it.value().split( ',' );
1614  ++it;
1615  }
1616  }
1617  }
1618 
1619  parameters.append( param );
1620  }
1621 
1622  return parameters;
1623  }
1624 
1625  QList<QgsWmsParametersHighlightLayer> QgsWmsParameters::highlightLayersParameters() const
1626  {
1627  QList<QgsWmsParametersHighlightLayer> params;
1628  QList<QgsGeometry> geoms = highlightGeomAsGeom();
1629  QStringList slds = highlightSymbol();
1630  QStringList labels = highlightLabelString();
1631  QList<QColor> colors = highlightLabelColorAsColor();
1632  QList<int> sizes = highlightLabelSizeAsInt();
1633  QList<int> weights = highlightLabelWeightAsInt();
1634  QStringList fonts = highlightLabelFont();
1635  QList<QColor> bufferColors = highlightLabelBufferColorAsColor();
1636  QList<double> bufferSizes = highlightLabelBufferSizeAsFloat();
1637 
1638  int nLayers = std::min( geoms.size(), slds.size() );
1639  for ( int i = 0; i < nLayers; i++ )
1640  {
1642  param.mName = QStringLiteral( "highlight_" ) + QString::number( i );
1643  param.mGeom = geoms[i];
1644  param.mSld = slds[i];
1645 
1646  if ( i < labels.count() )
1647  param.mLabel = labels[i];
1648 
1649  if ( i < colors.count() )
1650  param.mColor = colors[i];
1651 
1652  if ( i < sizes.count() )
1653  param.mSize = sizes[i];
1654 
1655  if ( i < weights.count() )
1656  param.mWeight = weights[i];
1657 
1658  if ( i < fonts.count() )
1659  param.mFont = fonts[ i ];
1660 
1661  if ( i < bufferColors.count() )
1662  param.mBufferColor = bufferColors[i];
1663 
1664  if ( i < bufferSizes.count() )
1665  param.mBufferSize = bufferSizes[i];
1666 
1667  params.append( param );
1668  }
1669 
1670  return params;
1671  }
1672 
1673  QList<QgsWmsParametersExternalLayer> QgsWmsParameters::externalLayersParameters() const
1674  {
1675  auto notExternalLayer = []( const QString & name ) { return ! QgsWmsParameters::isExternalLayer( name ); };
1676 
1677  QList<QgsWmsParametersExternalLayer> externalLayers;
1678 
1679  QStringList layers = allLayersNickname();
1680  QStringList::iterator rit = std::remove_if( layers.begin(), layers.end(), notExternalLayer );
1681 
1682  for ( QStringList::iterator it = layers.begin(); it != rit; ++it )
1683  {
1684  externalLayers << externalLayerParameter( *it );
1685  }
1686 
1687  return externalLayers;
1688  }
1689 
1691  {
1692  return mWmsParameters[ QgsWmsParameter::BGCOLOR ].toString();
1693  }
1694 
1696  {
1697  return mWmsParameters[ QgsWmsParameter::BGCOLOR ].toColor();
1698  }
1699 
1701  {
1702  return mWmsParameters[ QgsWmsParameter::TEMPLATE ].toString();
1703  }
1704 
1706  {
1707  QgsWmsParameter wmsParam;
1709  param.mId = mapId;
1710 
1711  //map extent is mandatory
1712  QString extentStr;
1713  wmsParam = idParameter( QgsWmsParameter::EXTENT, mapId );
1714  if ( wmsParam.isValid() )
1715  {
1716  extentStr = wmsParam.toString();
1717  }
1718 
1719  if ( extentStr.isEmpty() )
1720  {
1721  return param;
1722  }
1723 
1724  QString pMapId = QStringLiteral( "MAP" ) + QString::number( mapId );
1725 
1726  wmsParam = idParameter( QgsWmsParameter::EXTENT, mapId );
1727  QgsRectangle extent;
1728  if ( wmsParam.isValid() )
1729  {
1730  extent = wmsParam.toRectangle();
1731  }
1732 
1733  if ( extent.isEmpty() )
1734  return param;
1735 
1736  param.mHasExtent = !extent.isEmpty();
1737  param.mExtent = extent;
1738 
1739  // scale
1740  wmsParam = idParameter( QgsWmsParameter::SCALE, mapId );
1741  if ( wmsParam.isValid() && !wmsParam.toString().isEmpty() )
1742  {
1743  param.mScale = wmsParam.toDouble();
1744  }
1745 
1746  // rotation
1747  wmsParam = idParameter( QgsWmsParameter::ROTATION, mapId );
1748  if ( wmsParam.isValid() && !wmsParam.toString().isEmpty() )
1749  {
1750  param.mRotation = wmsParam.toDouble();
1751  }
1752 
1753  //grid space x / y
1754  double gridx( -1 ), gridy( -1 );
1755 
1756  wmsParam = idParameter( QgsWmsParameter::GRID_INTERVAL_X, mapId );
1757  if ( wmsParam.isValid() && !wmsParam.toString().isEmpty() )
1758  {
1759  gridx = wmsParam.toDouble();
1760  }
1761 
1762  wmsParam = idParameter( QgsWmsParameter::GRID_INTERVAL_Y, mapId );
1763  if ( wmsParam.isValid() && !wmsParam.toString().isEmpty() )
1764  {
1765  gridy = wmsParam.toDouble();
1766  }
1767 
1768  if ( gridx != -1 && gridy != -1 )
1769  {
1770  param.mGridX = gridx;
1771  param.mGridY = gridy;
1772  }
1773 
1774  //layers
1775  QStringList allLayers;
1776  wmsParam = idParameter( QgsWmsParameter::LAYERS, mapId );
1777  if ( wmsParam.isValid() )
1778  {
1779  allLayers = wmsParam.toStringList();
1780  }
1781 
1782  // external layers
1783  QStringList layers;
1784 
1785  for ( const auto &layer : std::as_const( allLayers ) )
1786  {
1787  if ( isExternalLayer( layer ) )
1788  {
1789  const QgsWmsParametersExternalLayer extParam = externalLayerParameter( layer );
1790  layers << extParam.mName;
1791  }
1792  else
1793  {
1794  layers << layer;
1795  }
1796  }
1797 
1798  QStringList styles;
1799  wmsParam = idParameter( QgsWmsParameter::STYLES, mapId );
1800  if ( wmsParam.isValid() )
1801  {
1802  styles = wmsParam.toStyleList();
1803  }
1804 
1805  QList<QgsWmsParametersLayer> lParams;
1806  for ( int i = 0; i < layers.size(); i++ )
1807  {
1808  QString layer = layers[i];
1809  QgsWmsParametersLayer lParam;
1810  lParam.mNickname = layer;
1811 
1812  if ( i < styles.count() )
1813  lParam.mStyle = styles[i];
1814 
1815  lParams.append( lParam );
1816  }
1817  param.mLayers = lParams;
1818 
1819  //highlight layers
1820  QList<QgsWmsParametersHighlightLayer> hParams;
1821 
1822  QList<QgsGeometry> geoms;
1823  wmsParam = idParameter( QgsWmsParameter::HIGHLIGHT_GEOM, mapId );
1824  if ( wmsParam.isValid() )
1825  {
1826  geoms = wmsParam.toGeomList( ';' );
1827  }
1828 
1829  QStringList slds;
1830  wmsParam = idParameter( QgsWmsParameter::HIGHLIGHT_SYMBOL, mapId );
1831  if ( wmsParam.isValid() )
1832  {
1833  slds = wmsParam.toStringList( ';' );
1834  }
1835 
1836  QStringList labels;
1837  wmsParam = idParameter( QgsWmsParameter::HIGHLIGHT_LABELSTRING, mapId );
1838  if ( wmsParam.isValid() )
1839  {
1840  labels = wmsParam.toStringList( ';' );
1841  }
1842 
1843  QStringList fonts;
1844  wmsParam = idParameter( QgsWmsParameter::HIGHLIGHT_LABELFONT, mapId );
1845  if ( wmsParam.isValid() )
1846  {
1847  fonts = wmsParam.toStringList( ';' );
1848  }
1849 
1850  QList<QColor> colors;
1851  wmsParam = idParameter( QgsWmsParameter::HIGHLIGHT_LABELCOLOR, mapId );
1852  if ( wmsParam.isValid() )
1853  {
1854  colors = wmsParam.toColorList( ';' );
1855  }
1856 
1857  QList<int> sizes;
1858  wmsParam = idParameter( QgsWmsParameter::HIGHLIGHT_LABELSIZE, mapId );
1859  if ( wmsParam.isValid() )
1860  {
1861  sizes = wmsParam.toIntList( ';' );
1862  }
1863 
1864  QList<int> weights;
1865  wmsParam = idParameter( QgsWmsParameter::HIGHLIGHT_LABELWEIGHT, mapId );
1866  if ( wmsParam.isValid() )
1867  {
1868  weights = wmsParam.toIntList( ';' );
1869  }
1870 
1871  QList<QColor> bufferColors;
1872  wmsParam = idParameter( QgsWmsParameter::HIGHLIGHT_LABELBUFFERCOLOR, mapId );
1873  if ( wmsParam.isValid() )
1874  {
1875  bufferColors = wmsParam.toColorList( ';' );
1876  }
1877 
1878  QList<double> bufferSizes;
1879  wmsParam = idParameter( QgsWmsParameter::HIGHLIGHT_LABELBUFFERSIZE, mapId );
1880  if ( wmsParam.isValid() )
1881  {
1882  bufferSizes = wmsParam.toDoubleList( ';' );
1883  }
1884 
1885  int nHLayers = std::min( geoms.size(), slds.size() );
1886  for ( int i = 0; i < nHLayers; i++ )
1887  {
1889  hParam.mName = pMapId + QStringLiteral( "_highlight_" ) + QString::number( i );
1890  hParam.mGeom = geoms[i];
1891  hParam.mSld = slds[i];
1892 
1893  if ( i < labels.count() )
1894  hParam.mLabel = labels[i];
1895 
1896  if ( i < colors.count() )
1897  hParam.mColor = colors[i];
1898 
1899  if ( i < sizes.count() )
1900  hParam.mSize = sizes[i];
1901 
1902  if ( i < weights.count() )
1903  hParam.mWeight = weights[i];
1904 
1905  if ( i < fonts.count() )
1906  hParam.mFont = fonts[ i ];
1907 
1908  if ( i < bufferColors.count() )
1909  hParam.mBufferColor = bufferColors[i];
1910 
1911  if ( i < bufferSizes.count() )
1912  hParam.mBufferSize = bufferSizes[i];
1913 
1914  hParams.append( hParam );
1915  }
1916  param.mHighlightLayers = hParams;
1917 
1918  return param;
1919  }
1920 
1921  QString QgsWmsParameters::externalWMSUri( const QString &id ) const
1922  {
1923  if ( !mExternalWMSParameters.contains( id ) )
1924  {
1925  return QString();
1926  }
1927 
1928  QgsDataSourceUri wmsUri;
1929  const QMap<QString, QString> &paramMap = mExternalWMSParameters[ id ];
1930  QMap<QString, QString>::const_iterator paramIt = paramMap.constBegin();
1931  for ( ; paramIt != paramMap.constEnd(); ++paramIt )
1932  {
1933  QString paramName = paramIt.key().toLower();
1934  if ( paramName == QLatin1String( "layers" ) || paramName == QLatin1String( "styles" ) || paramName == QLatin1String( "opacities" ) )
1935  {
1936  const QStringList values = paramIt.value().split( ',' );
1937  for ( const QString &value : values )
1938  wmsUri.setParam( paramName, value );
1939  }
1940  else
1941  {
1942  wmsUri.setParam( paramName, paramIt.value() );
1943  }
1944  }
1945  return wmsUri.encodedUri();
1946  }
1947 
1949  {
1950  return mWmsParameters[ QgsWmsParameter::WITH_GEOMETRY ].toBool();
1951  }
1952 
1954  {
1955  return mWmsParameters[ QgsWmsParameter::WITH_MAPTIP ].toBool();
1956  }
1957 
1959  {
1960  return mWmsParameters[ QgsWmsParameter::WMTVER ].toString();
1961  }
1962 
1963  void QgsWmsParameters::log( const QString &msg ) const
1964  {
1965  QgsMessageLog::logMessage( msg, QStringLiteral( "Server" ), Qgis::MessageLevel::Info );
1966  }
1967 
1968  void QgsWmsParameters::raiseError( const QString &msg ) const
1969  {
1971  }
1972 
1973  QgsWmsParameter QgsWmsParameters::idParameter( const QgsWmsParameter::Name name, const int id ) const
1974  {
1975  QgsWmsParameter p;
1976 
1977  for ( const auto &param : mWmsParameters.values( name ) )
1978  {
1979  if ( param.mId == id )
1980  {
1981  p = param;
1982  }
1983  }
1984 
1985  return p;
1986  }
1987 
1988  QgsWmsParametersExternalLayer QgsWmsParameters::externalLayerParameter( const QString &name ) const
1989  {
1990  QgsWmsParametersExternalLayer param;
1991 
1992  param.mName = name;
1993  param.mName.remove( 0, EXTERNAL_LAYER_PREFIX.size() );
1994  param.mUri = externalWMSUri( param.mName );
1995 
1996  return param;
1997  }
1998 
1999  bool QgsWmsParameters::isExternalLayer( const QString &name )
2000  {
2001  return name.startsWith( EXTERNAL_LAYER_PREFIX );
2002  }
2003 
2005  {
2006  QStringList attributes;
2007  const QMap<DxfFormatOption, QString> options = dxfFormatOptions();
2008 
2009  if ( options.contains( DxfFormatOption::LAYERATTRIBUTES ) )
2010  {
2011  attributes = options[ DxfFormatOption::LAYERATTRIBUTES ].split( ',' );
2012  }
2013 
2014  return attributes;
2015  }
2016 
2018  {
2019  bool use = false;
2020  const QMap<DxfFormatOption, QString> options = dxfFormatOptions();
2021 
2022  if ( options.contains( DxfFormatOption::USE_TITLE_AS_LAYERNAME ) )
2023  {
2024  use = QVariant( options[ DxfFormatOption::USE_TITLE_AS_LAYERNAME ] ).toBool();
2025  }
2026 
2027  return use;
2028  }
2029 
2031  {
2032  const QMap<DxfFormatOption, QString> options = dxfFormatOptions();
2033 
2034  double scale = -1;
2035  if ( options.contains( DxfFormatOption::SCALE ) )
2036  {
2037  scale = options[ DxfFormatOption::SCALE ].toDouble();
2038  }
2039 
2040  return scale;
2041  }
2042 
2044  {
2045  const QMap<DxfFormatOption, QString> options = dxfFormatOptions();
2046 
2048 
2049  if ( ! options.contains( DxfFormatOption::MODE ) )
2050  {
2051  return symbol;
2052  }
2053 
2054  const QString mode = options[ DxfFormatOption::MODE ];
2055  if ( mode.compare( QLatin1String( "SymbolLayerSymbology" ), Qt::CaseInsensitive ) == 0 )
2056  {
2058  }
2059  else if ( mode.compare( QLatin1String( "FeatureSymbology" ), Qt::CaseInsensitive ) == 0 )
2060  {
2062  }
2063 
2064  return symbol;
2065  }
2066 
2068  {
2069  QString codec = QStringLiteral( "ISO-8859-1" );
2070 
2071  if ( dxfFormatOptions().contains( DxfFormatOption::CODEC ) )
2072  {
2073  codec = dxfFormatOptions()[ DxfFormatOption::CODEC ];
2074  }
2075 
2076  return codec;
2077  }
2078 
2079  QMap<QgsWmsParameters::DxfFormatOption, QString> QgsWmsParameters::dxfFormatOptions() const
2080  {
2081  QMap<QgsWmsParameters::DxfFormatOption, QString> options;
2082 
2083  const QMetaEnum metaEnum( QMetaEnum::fromType<QgsWmsParameters::DxfFormatOption>() );
2084  const QStringList opts = mWmsParameters[ QgsWmsParameter::FORMAT_OPTIONS ].toStringList( ';' );
2085 
2086  for ( auto it = opts.constBegin(); it != opts.constEnd(); ++it )
2087  {
2088  const int equalIdx = it->indexOf( ':' );
2089  if ( equalIdx > 0 && equalIdx < ( it->length() - 1 ) )
2090  {
2091  const QString name = it->left( equalIdx ).toUpper();
2092  const QgsWmsParameters::DxfFormatOption option =
2093  ( QgsWmsParameters::DxfFormatOption ) metaEnum.keyToValue( name.toStdString().c_str() );
2094  const QString value = it->right( it->length() - equalIdx - 1 );
2095  options.insert( option, value );
2096  }
2097  }
2098 
2099  return options;
2100  }
2101 
2102  QMap<QString, QString> QgsWmsParameters::dimensionValues() const
2103  {
2104  QMap<QString, QString> dimValues;
2105  const QMetaEnum pnMetaEnum( QMetaEnum::fromType<QgsMapLayerServerProperties::PredefinedWmsDimensionName>() );
2106  const QStringList unmanagedNames = mUnmanagedParameters.keys();
2107  for ( const QString &key : unmanagedNames )
2108  {
2109  if ( key.startsWith( QLatin1String( "DIM_" ) ) )
2110  {
2111  dimValues[key.mid( 4 )] = mUnmanagedParameters[key];
2112  }
2113  else if ( pnMetaEnum.keyToValue( key.toUpper().toStdString().c_str() ) != -1 )
2114  {
2115  dimValues[key] = mUnmanagedParameters[key];
2116  }
2117  }
2118  return dimValues;
2119  }
2120 }
Exception thrown in case of malformed request.
Class for storing the component parts of a RDBMS data source URI (e.g.
QByteArray encodedUri() const
Returns the complete encoded URI as a byte array.
void setParam(const QString &key, const QString &value)
Sets a generic parameter value on the URI.
@ FeatureSymbology
Keeps the number of features and export symbology per feature (using the first symbol level)
Definition: qgsdxfexport.h:106
@ SymbolLayerSymbology
Exports one feature per symbol layer (considering symbol levels)
Definition: qgsdxfexport.h:107
@ NoSymbology
Export only data.
Definition: qgsdxfexport.h:105
The QgsLegendSettings class stores the appearance and layout settings for legend drawing with QgsLege...
void setFontColor(const QColor &c)
Sets the font color used for legend items.
void setLayerFontColor(const QColor &fontColor)
Sets layer font color to fontColor Overrides fontColor()
void setTitle(const QString &t)
Sets the title for the legend, which will be rendered above all legend items.
QgsLegendStyle & rstyle(QgsLegendStyle::Style s)
Returns modifiable reference to the style for a legend component.
void setBoxSpace(double s)
Sets the legend box space (in millimeters), which is the empty margin around the inside of the legend...
void setSymbolSize(QSizeF s)
Sets the default symbol size (in millimeters) used for legend items.
void setMargin(Side side, double margin)
Sets the margin (in mm) for the specified side of the component.
void setFont(const QFont &font)
Sets the font used for rendering this legend component.
static void logMessage(const QString &message, const QString &tag=QString(), Qgis::MessageLevel level=Qgis::MessageLevel::Warning, bool notifyUser=true)
Adds a message to the log instance (and creates it if necessary).
A class to describe the version of a project.
A rectangle specified with double values.
Definition: qgsrectangle.h:42
bool isEmpty() const
Returns true if the rectangle is empty.
Definition: qgsrectangle.h:469
Definition of a parameter with basic conversion methods.
QList< QgsGeometry > toGeomList(bool &ok, char delimiter=',') const
Converts the parameter into a list of geometries.
QString loadUrl(bool &ok) const
Loads the data associated to the parameter converted into an url.
QUrl toUrl(bool &ok) const
Converts the parameter into an url.
QString toString(bool defaultValue=false) const
Converts the parameter into a string.
QList< double > toDoubleList(bool &ok, char delimiter=',') const
Converts the parameter into a list of doubles.
QStringList toStringList(char delimiter=',', bool skipEmptyParts=true) const
Converts the parameter into a list of strings.
virtual bool isValid() const
Returns true if the parameter is valid, false otherwise.
QString typeName() const
Returns the type of the parameter as a string.
static void raiseError(const QString &msg)
Raises an exception in case of an invalid parameters.
int toInt(bool &ok) const
Converts the parameter into an integer.
QList< int > toIntList(bool &ok, char delimiter=',') const
Converts the parameter into a list of integers.
QColor toColor(bool &ok) const
Converts the parameter into a color.
double toDouble(bool &ok) const
Converts the parameter into a double.
QgsRectangle toRectangle(bool &ok) const
Converts the parameter into a rectangle.
QList< QColor > toColorList(bool &ok, char delimiter=',') const
Converts the parameter into a list of colors.
QgsServerParameters provides an interface to retrieve and manipulate global parameters received from ...
virtual QString request() const
Returns REQUEST parameter as a string or an empty string if not defined.
QUrlQuery urlQuery() const
Returns a url query with underlying parameters.
QMap< QString, QString > mUnmanagedParameters
void load(const QUrlQuery &query)
Loads new parameters.
virtual QString version() const
Returns VERSION parameter as a string or an empty string if not defined.
QString value(const QString &key) const
Returns the value of a parameter.
WMS parameter received from the client.
int toInt() const
Converts the parameter into an integer.
QList< double > toDoubleList(const char delimiter=',') const
Converts the parameter into a list of doubles.
QList< QColor > toColorList(const char delimiter=',') const
Converts the parameter into a list of colors.
double toDouble() const
Converts the parameter into a double.
void raiseError() const
Raises an error in case of an invalid conversion.
Name
Available parameters for WMS requests.
QUrl toUrl() const
Converts the parameter into an url.
QList< QgsGeometry > toGeomList(const char delimiter=',') const
Converts the parameter into a list of geometries.
bool isValid() const override
Returns true if the parameter is valid, false otherwise.
QString name() const
Returns the name of the parameter.
QgsRectangle toRectangle() const
Converts the parameter into a rectangle.
QgsWmsParameter(const QgsWmsParameter::Name name=QgsWmsParameter::UNKNOWN, const QVariant::Type type=QVariant::String, const QVariant defaultValue=QVariant(""))
Constructor for QgsWmsParameter.
QColor toColor() const
Converts the parameter into a color.
QgsWmsParameter::Name mName
QList< int > toIntList(const char delimiter=',') const
Converts the parameter into a list of integers.
QStringList toStyleList(const char delimiter=',') const
Converts the parameter into a list of strings and keeps empty parts Default style value is an empty s...
QString loadUrl() const
Loads the data associated to the parameter converted into an url.
Provides an interface to retrieve and manipulate WMS parameters received from the client.
QString rule() const
Returns RULE parameter or an empty string if none is defined.
QString layerTitle() const
Returns LAYERTITLE parameter or an empty string if not defined.
double layerSpaceAsDouble() const
Returns LAYERSPACE as a double or its default value if not defined.
QString boxSpace() const
Returns BOXSPACE parameter or an empty string if not defined.
QString wmsPrecision() const
Returns WMS_PRECISION parameter or an empty string if not defined.
double dxfScale() const
Returns the DXF SCALE parameter.
QString featureCount() const
Returns FEATURE_COUNT parameter or an empty string if none is defined.
QFont layerFont() const
Returns the layer font (built thanks to the LAYERFONTFAMILY, LAYERFONTSIZE, LAYERFONTBOLD,...
QList< int > opacitiesAsInt() const
Returns the list of opacities found in OPACITIES parameter as integers.
bool transparentAsBool() const
Returns TRANSPARENT parameter as a bool or its default value if not defined.
QString transparent() const
Returns TRANSPARENT parameter or an empty string if not defined.
QList< int > highlightLabelWeightAsInt() const
Returns HIGHLIGHT_LABELWEIGHT as a list of int.
QString iconLabelSpace() const
Returns ICONLABELSPACE parameter or an empty string if not defined.
QString layerTitleSpace() const
Returns LAYERTITLESPACE parameter or an empty string if not defined.
QString x() const
Returns X parameter or an empty string if not defined.
QString layerSpace() const
Returns LAYERSPACE parameter or an empty string if not defined.
int wmsPrecisionAsInt() const
Returns WMS_PRECISION parameter as an int or its default value if not defined.
QMap< DxfFormatOption, QString > dxfFormatOptions() const
Returns a map of DXF options defined within FORMAT_OPTIONS parameter.
QStringList highlightLabelBufferSize() const
Returns HIGHLIGHT_LABELBUFFERSIZE.
QStringList allLayersNickname() const
Returns nickname of layers found in LAYER and LAYERS parameters.
QString formatAsString() const
Returns FORMAT parameter as a string.
double layerFontSizeAsDouble() const
Returns LAYERFONTSIZE as a double.
QString externalWMSUri(const QString &id) const
Returns the external WMS uri.
QgsProjectVersion versionAsNumber() const
Returns VERSION parameter if defined or its default value.
QString scale() const
Returns SCALE parameter or an empty string if none is defined.
QString ruleLabel() const
Returns RULELABEL parameter or an empty string if none is defined.
double scaleAsDouble() const
Returns SCALE as a double.
bool layerFontItalicAsBool() const
Returns LAYERFONTITALIC as a boolean or its default value if not defined.
QgsWmsParametersComposerMap composerMapParameters(int mapId) const
Returns the requested parameters for a composer map parameter.
QgsRectangle bboxAsRectangle() const
Returns BBOX as a rectangle if defined and valid.
bool withGeometry() const
Returns if the client wants the feature info response with geometry information.
QStringList highlightLabelString() const
Returns HIGHLIGHT_LABELSTRING as a list of string.
QString tiled() const
Returns TILED parameter or an empty string if not defined.
QString layerFontSize() const
Returns LAYERFONTSIZE parameter or an empty string if not defined.
DxfFormatOption
Options for DXF format.
QList< QColor > highlightLabelColorAsColor() const
Returns HIGHLIGHT_LABELCOLOR as a list of color.
bool itemFontBoldAsBool() const
Returns ITEMFONTBOLD as a boolean or its default value if not defined.
void set(QgsWmsParameter::Name name, const QVariant &value)
Sets a parameter value thanks to its name.
QString pointTolerance() const
Returns FI_POINT_TOLERANCE parameter or an empty string if not defined.
QString filterGeom() const
Returns the filter geometry found in FILTER_GEOM parameter.
QString composerTemplate() const
Returns TEMPLATE parameter or an empty string if not defined.
Format infoFormat() const
Returns infoFormat.
QString dxfCodec() const
Returns the DXF CODEC parameter.
QString y() const
Returns Y parameter or an empty string if not defined.
QString srcHeight() const
Returns SRCHEIGHT parameter or an empty string if not defined.
double dpiAsDouble() const
Returns DPI parameter as an int or its default value if not defined.
void dump() const
Dumps parameters.
int pointToleranceAsInt() const
Returns FI_POINT_TOLERANCE parameter as an integer.
bool withMapTip() const
withMapTip
QString polygonTolerance() const
Returns FI_POLYGON_TOLERANCE parameter or an empty string if not defined.
QStringList highlightGeom() const
Returns HIGHLIGHT_GEOM as a list of string in WKT.
QString i() const
Returns I parameter or an empty string if not defined.
QList< QColor > highlightLabelBufferColorAsColor() const
Returns HIGHLIGHT_LABELBUFFERCOLOR as a list of colors.
QString request() const override
Returns REQUEST parameter as a string or an empty string if not defined.
double layerTitleSpaceAsDouble() const
Returns LAYERTITLESPACE as a double.
QList< QgsWmsParametersLayer > layersParameters() const
Returns parameters for each layer found in LAYER/LAYERS.
int lineToleranceAsInt() const
Returns FI_LINE_TOLERANCE parameter as an integer.
QList< double > highlightLabelBufferSizeAsFloat() const
Returns HIGHLIGHT_LABELBUFFERSIZE as a list of float.
QString lineTolerance() const
Returns FI_LINE_TOLERANCE parameter or an empty string if not defined.
bool showFeatureCountAsBool() const
Returns SHOWFEATURECOUNT as a bool.
QStringList highlightLabelColor() const
Returns HIGHLIGHT_LABELCOLOR as a list of string.
bool versionIsValid(const QString version) const
Returns true if version is valid, false otherwise.
QString j() const
Returns J parameter or an empty string if not defined.
int xAsInt() const
Returns X parameter as an int or its default value if not defined.
QColor layerFontColorAsColor() const
Returns LAYERFONTCOLOR as a color or its defined value if not defined.
QString bbox() const
Returns BBOX if defined or an empty string.
QgsWmsParameters()
Constructor for WMS parameters with default values only.
int heightAsInt() const
Returns HEIGHT parameter as an int or its default value if not defined.
QStringList highlightLabelWeight() const
Returns HIGHLIGHT_LABELWEIGHT as a list of string.
QString backgroundColor() const
Returns BGCOLOR parameter or an empty string if not defined.
QStringList allStyles() const
Returns styles found in STYLE and STYLES parameters.
double symbolWidthAsDouble() const
Returns SYMBOLWIDTH as a double or its default value if not defined.
QColor backgroundColorAsColor() const
Returns BGCOLOR parameter as a QColor or its default value if not defined.
Format format() const
Returns format.
QgsWmsParameter operator[](QgsWmsParameter::Name name) const
Returns the parameter corresponding to name.
QString itemFontSize() const
Returns ITEMFONTSIZE parameter or an empty string if not defined.
QStringList atlasPk() const
Returns the ATLAS_PK parameter.
QList< QgsGeometry > highlightGeomAsGeom() const
Returns HIGHLIGHT_GEOM as a list of geometries.
QString layerFontFamily() const
Returns LAYERFONTFAMILY parameter or an empty string if not defined.
QList< QgsWmsParametersHighlightLayer > highlightLayersParameters() const
Returns parameters for each highlight layer.
int iAsInt() const
Returns I parameter as an int or its default value if not defined.
QStringList highlightLabelBufferColor() const
Returns HIGHLIGHT_LABELBUFFERCOLOR as a list of string.
int polygonToleranceAsInt() const
Returns FI_POLYGON_TOLERANCE parameter as an integer.
QgsDxfExport::SymbologyExport dxfMode() const
Returns the DXF MODE parameter.
bool ruleLabelAsBool() const
Returns RULELABEL as a bool.
QList< int > highlightLabelSizeAsInt() const
Returns HIGHLIGHT_LABELSIZE as a list of int An exception is raised if an invalid size is found.
int widthAsInt() const
Returns WIDTH parameter as an int or its default value if not defined.
QString sldBody() const
Returns SLD_body if defined or an empty string.
bool itemFontItalicAsBool() const
Returns ITEMFONTITALIC as a boolean or its default value if not defined.
QColor itemFontColorAsColor() const
Returns ITEMFONTCOLOR as a color.
double itemFontSizeAsDouble() const
Returns ITEMFONTSIZE as a double.
QString layerFontColor() const
Returns LAYERFONTCOLOR parameter or an empty string if not defined.
QString layoutParameter(const QString &id, bool &ok) const
Returns a layout parameter thanks to its id.
bool dxfUseLayerTitleAsName() const
Returns the DXF USE_TITLE_AS_LAYERNAME parameter.
QString symbolHeight() const
Returns SYMBOLHEIGHT parameter or an empty string if not defined.
int imageQualityAsInt() const
Returns IMAGE_QUALITY parameter as an integer.
QMap< QString, QString > dimensionValues() const
Returns the dimensions parameter.
QList< QgsWmsParametersExternalLayer > externalLayersParameters() const
Returns parameters for each external layer.
int infoFormatVersion() const
Returns the infoFormat version for GML.
QString layerFontBold() const
Returns LAYERFONTBOLD parameter or an empty string if not defined.
QgsLegendSettings legendSettings() const
Returns legend settings.
int srcHeightAsInt() const
Returns SRCHEIGHT parameter as an int or its default value if not defined.
QString symbolSpace() const
Returns SYMBOLSPACE parameter or an empty string if not defined.
QString itemFontBold() const
Returns ITEMFONTBOLD parameter or an empty string if not defined.
double symbolSpaceAsDouble() const
Returns SYMBOLSPACE as a double or its default value if not defined.
QString infoFormatAsString() const
Returns INFO_FORMAT parameter as a string.
QStringList highlightLabelFont() const
Returns HIGHLIGHT_LABELFONT.
QString wmtver() const
Returns WMTVER parameter or an empty string if not defined.
QStringList dxfLayerAttributes() const
Returns the DXF LAYERATTRIBUTES parameter.
QString srcWidth() const
Returns SRCWIDTH parameter or an empty string if not defined.
QStringList highlightLabelSize() const
Returns HIGHLIGHT_LABELSIZE as a list of string.
QString imageQuality() const
Returns IMAGE_QUALITY parameter or an empty string if not defined.
QString height() const
Returns HEIGHT parameter or an empty string if not defined.
QString crs() const
Returns CRS or an empty string if none is defined.
QStringList selections() const
Returns the list of feature selection found in SELECTION parameter.
int featureCountAsInt() const
Returns FEATURE_COUNT as an integer.
int yAsInt() const
Returns Y parameter as an int or its default value if not defined.
bool layerTitleAsBool() const
Returns LAYERTITLE as a bool or its default value if not defined.
QString itemFontColor() const
Returns ITEMFONTCOLOR parameter or an empty string if not defined.
double boxSpaceAsDouble() const
Returns BOXSPACE as a double or its default value if not defined.
QString symbolWidth() const
Returns SYMBOLWIDTH parameter or an empty string if not defined.
bool tiledAsBool() const
Returns TILED parameter as a boolean.
Format
Output format for the response.
QString width() const
Returns WIDTH parameter or an empty string if not defined.
QFont itemFont() const
Returns the item font (built thanks to the ITEMFONTFAMILY, ITEMFONTSIZE, ITEMFONTBOLD,...
QStringList opacities() const
Returns the list of opacities found in OPACITIES parameter.
QString version() const override
Returns VERSION parameter as a string or an empty string if not defined.
QString layerFontItalic() const
Returns LAYERFONTITALIC parameter or an empty string if not defined.
QString itemFontItalic() const
Returns ITEMFONTITALIC parameter or an empty string if not defined.
QStringList filters() const
Returns the list of filters found in FILTER parameter.
QString dpi() const
Returns DPI parameter or an empty string if not defined.
QString itemFontFamily() const
Returns ITEMFONTFAMILY parameter or an empty string if not defined.
int jAsInt() const
Returns J parameter as an int or its default value if not defined.
QString showFeatureCount() const
Returns SHOWFEATURECOUNT parameter or an empty string if none is defined.
bool layerFontBoldAsBool() const
Returns LAYERFONTBOLD as a boolean or its default value if not defined.
double iconLabelSpaceAsDouble() const
Returns ICONLABELSPACE as a double or its default value if not defined.
QStringList highlightSymbol() const
Returns HIGHLIGHT_SYMBOL as a list of string.
QStringList queryLayersNickname() const
Returns nickname of layers found in QUERY_LAYERS parameter.
double symbolHeightAsDouble() const
Returns SYMBOLHEIGHT as a double or its default value if not defined.
bool infoFormatIsImage() const
Checks if INFO_FORMAT parameter is one of the image formats (PNG, JPG).
int srcWidthAsInt() const
Returns SRCWIDTH parameter as an int or its default value if not defined.
Median cut implementation.
const QString EXTERNAL_LAYER_PREFIX
QList< QgsWmsParametersLayer > mLayers
QList< QgsWmsParametersHighlightLayer > mHighlightLayers
QgsWmsParametersFilter::Type mType
QgsOgcUtils::FilterVersion mVersion
QList< QgsWmsParametersFilter > mFilter