sharpetronics/QGIS
1
0
Fork 0
mirror of https://github.com/qgis/QGIS.git synced 2025-02-25 00:58:06 -05:00
Code Issues Packages Projects Releases Wiki Activity

Fix more qt deprecation warnings

Browse Source
This commit is contained in:
Nyall Dawson 2020-02-05 10:54:37 +10:00
parent 05c3186324
commit b8a12be5b7
14 changed files with 160 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
python/gui/auto_generated/symbology/qgsgraduatedsymbolrendererwidget.sip.in
View File

@ -63,7 +63,13 @@ Toggle the link between classes boundaries
void rowsMoved(); void rowsMoved();
void modelDataChanged(); void modelDataChanged();
void refreshRanges( bool reset = false );
void refreshRanges( bool reset );
%Docstring
Refreshes the ranges for the renderer.
The ``reset`` argument is deprecated and has no effect.
%End
protected slots: protected slots:

9
src/app/qgsidentifyresultsdialog.cpp
View File

@ -37,6 +37,7 @@
#include <QFileDialog> #include <QFileDialog>
#include <QFileInfo> #include <QFileInfo>
#include <QRegExp> #include <QRegExp>
#include <QScreen>
//graph //graph
#include <qwt_plot.h> #include <qwt_plot.h>
@ -951,7 +952,15 @@ void QgsIdentifyResultsDialog::addFeature( QgsRasterLayer *layer,
QgsIdentifyResultsWebViewItem *attrItem = new QgsIdentifyResultsWebViewItem( lstResults ); QgsIdentifyResultsWebViewItem *attrItem = new QgsIdentifyResultsWebViewItem( lstResults );
#ifdef WITH_QTWEBKIT #ifdef WITH_QTWEBKIT
attrItem->webView()->page()->setLinkDelegationPolicy( QWebPage::DelegateExternalLinks ); attrItem->webView()->page()->setLinkDelegationPolicy( QWebPage::DelegateExternalLinks );
#if QT_VERSION < QT_VERSION_CHECK(5, 10, 0)
const int horizontalDpi = qApp->desktop()->screen()->logicalDpiX(); const int horizontalDpi = qApp->desktop()->screen()->logicalDpiX();
#else
QScreen *screen = QGuiApplication::screenAt( mapToGlobal( QPoint( width() / 2, 0 ) ) );
const int horizontalDpi = screen->logicalDotsPerInchX();
#endif
// Adjust zoom: text is ok, but HTML seems rather big at least on Linux/KDE // Adjust zoom: text is ok, but HTML seems rather big at least on Linux/KDE
if ( horizontalDpi > 96 ) if ( horizontalDpi > 96 )
{ {

2
src/app/qgssnappinglayertreemodel.h
View File

@ -72,7 +72,7 @@ class APP_EXPORT QgsSnappingLayerTreeModel : public QSortFilterProxyModel
QgsLayerTreeModel *layerTreeModel() const; QgsLayerTreeModel *layerTreeModel() const;
void setLayerTreeModel( QgsLayerTreeModel *layerTreeModel ); void setLayerTreeModel( QgsLayerTreeModel *layerTreeModel );
void resetLayerTreeModel() { reset(); } void resetLayerTreeModel() { beginResetModel(); endResetModel(); }
QgsVectorLayer *vectorLayer( const QModelIndex &idx ) const; QgsVectorLayer *vectorLayer( const QModelIndex &idx ) const;

15
src/gui/symbology/qgsgraduatedsymbolrendererwidget.cpp
View File

@ -373,16 +373,9 @@ void QgsGraduatedSymbolRendererModel::sort( int column, Qt::SortOrder order )
emit dataChanged( createIndex( 0, 0 ), createIndex( mRenderer->ranges().size(), 0 ) ); emit dataChanged( createIndex( 0, 0 ), createIndex( mRenderer->ranges().size(), 0 ) );
} }
void QgsGraduatedSymbolRendererModel::updateSymbology( bool resetModel ) void QgsGraduatedSymbolRendererModel::updateSymbology()
{ {
if ( resetModel ) emit dataChanged( createIndex( 0, 0 ), createIndex( mRenderer->ranges().size(), 0 ) );
{
reset();
}
else
{
emit dataChanged( createIndex( 0, 0 ), createIndex( mRenderer->ranges().size(), 0 ) );
}
} }
void QgsGraduatedSymbolRendererModel::updateLabels() void QgsGraduatedSymbolRendererModel::updateLabels()
@ -898,12 +891,12 @@ void QgsGraduatedSymbolRendererWidget::clearParameterWidgets()
mParameterWidgetWrappers.clear(); mParameterWidgetWrappers.clear();
} }
void QgsGraduatedSymbolRendererWidget::refreshRanges( bool reset ) void QgsGraduatedSymbolRendererWidget::refreshRanges( bool )
{ {
if ( !mModel ) if ( !mModel )
return; return;
mModel->updateSymbology( reset ); mModel->updateSymbology();
disconnectUpdateHandlers(); disconnectUpdateHandlers();
spinGraduatedClasses->setValue( mRenderer->ranges().count() ); spinGraduatedClasses->setValue( mRenderer->ranges().count() );

10
src/gui/symbology/qgsgraduatedsymbolrendererwidget.h
View File

@ -59,7 +59,7 @@ class GUI_EXPORT QgsGraduatedSymbolRendererModel : public QAbstractItemModel
void deleteRows( QList<int> rows ); void deleteRows( QList<int> rows );
void removeAllRows(); void removeAllRows();
void sort( int column, Qt::SortOrder order = Qt::AscendingOrder ) override; void sort( int column, Qt::SortOrder order = Qt::AscendingOrder ) override;
void updateSymbology( bool resetModel = false ); void updateSymbology();
void updateLabels(); void updateLabels();
signals: signals:
@ -125,7 +125,13 @@ class GUI_EXPORT QgsGraduatedSymbolRendererWidget : public QgsRendererWidget, pr
void rowsMoved(); void rowsMoved();
void modelDataChanged(); void modelDataChanged();
void refreshRanges( bool reset = false );
/**
* Refreshes the ranges for the renderer.
*
* The \a reset argument is deprecated and has no effect.
*/
void refreshRanges( bool reset );
private slots: private slots:
void mSizeUnitWidget_changed(); void mSizeUnitWidget_changed();

2
src/providers/arcgisrest/qgsamsprovider.cpp
View File

@ -165,7 +165,7 @@ void QgsAmsLegendFetcher::handleFinished()
{ {
maxImageSize.setWidth( std::max( maxImageSize.width(), legendEntry.second.width() ) ); maxImageSize.setWidth( std::max( maxImageSize.width(), legendEntry.second.width() ) );
maxImageSize.setHeight( std::max( maxImageSize.height(), legendEntry.second.height() ) ); maxImageSize.setHeight( std::max( maxImageSize.height(), legendEntry.second.height() ) );
textWidth = std::max( textWidth, fm.width( legendEntry.first ) + 10 ); textWidth = std::max( textWidth, fm.boundingRect( legendEntry.first ).width() + 10 );
} }
double scaleFactor = maxImageSize.width() == 0 || maxImageSize.height() == 0 ? 1.0 : double scaleFactor = maxImageSize.width() == 0 || maxImageSize.height() == 0 ? 1.0 :
std::min( 1., std::min( double( imageSize ) / maxImageSize.width(), double( imageSize ) / maxImageSize.height() ) ); std::min( 1., std::min( double( imageSize ) / maxImageSize.width(), double( imageSize ) / maxImageSize.height() ) );

6
src/providers/delimitedtext/qgsdelimitedtextfeatureiterator.cpp
View File

@ -536,10 +536,12 @@ QgsDelimitedTextFeatureSource::QgsDelimitedTextFeatureSource( const QgsDelimited
QUrl url = p->mFile->url(); QUrl url = p->mFile->url();
// make sure watcher not created when using iterator (e.g. for rendering, see issue #15558) // make sure watcher not created when using iterator (e.g. for rendering, see issue #15558)
if ( url.hasQueryItem( QStringLiteral( "watchFile" ) ) ) QUrlQuery query( url );
if ( query.hasQueryItem( QStringLiteral( "watchFile" ) ) )
{ {
url.removeQueryItem( QStringLiteral( "watchFile" ) ); query.removeQueryItem( QStringLiteral( "watchFile" ) );
} }
url.setQuery( query );
mFile.reset( new QgsDelimitedTextFile() ); mFile.reset( new QgsDelimitedTextFile() );
mFile->setFromUrl( url ); mFile->setFromUrl( url );

77
src/providers/delimitedtext/qgsdelimitedtextfile.cpp
View File

@ -133,15 +133,16 @@ bool QgsDelimitedTextFile::setFromUrl( const QUrl &url )
setFileName( url.toLocalFile() ); setFileName( url.toLocalFile() );
// Extract the encoding // Extract the encoding
if ( url.hasQueryItem( QStringLiteral( "encoding" ) ) ) const QUrlQuery query( url );
if ( query.hasQueryItem( QStringLiteral( "encoding" ) ) )
{ {
mEncoding = url.queryItemValue( QStringLiteral( "encoding" ) ); mEncoding = query.queryItemValue( QStringLiteral( "encoding" ) );
} }
// //
if ( url.hasQueryItem( QStringLiteral( "watchFile" ) ) ) if ( query.hasQueryItem( QStringLiteral( "watchFile" ) ) )
{ {
mUseWatcher = url.queryItemValue( QStringLiteral( "watchFile" ) ).toUpper().startsWith( 'Y' ); mUseWatcher = query.queryItemValue( QStringLiteral( "watchFile" ) ).toUpper().startsWith( 'Y' );
} }
// The default type is csv, to be consistent with the // The default type is csv, to be consistent with the
@ -156,12 +157,12 @@ bool QgsDelimitedTextFile::setFromUrl( const QUrl &url )
// Prefer simple "type" for delimiter type, but include delimiterType // Prefer simple "type" for delimiter type, but include delimiterType
// as optional name for backwards compatibility // as optional name for backwards compatibility
if ( url.hasQueryItem( QStringLiteral( "type" ) ) || url.hasQueryItem( QStringLiteral( "delimiterType" ) ) ) if ( query.hasQueryItem( QStringLiteral( "type" ) ) || query.hasQueryItem( QStringLiteral( "delimiterType" ) ) )
{ {
if ( url.hasQueryItem( QStringLiteral( "type" ) ) ) if ( query.hasQueryItem( QStringLiteral( "type" ) ) )
type = url.queryItemValue( QStringLiteral( "type" ) ); type = query.queryItemValue( QStringLiteral( "type" ) );
else if ( url.hasQueryItem( QStringLiteral( "delimiterType" ) ) ) else if ( query.hasQueryItem( QStringLiteral( "delimiterType" ) ) )
type = url.queryItemValue( QStringLiteral( "delimiterType" ) ); type = query.queryItemValue( QStringLiteral( "delimiterType" ) );
// Support for previous version of Qgs - plain chars had // Support for previous version of Qgs - plain chars had
// quote characters ' or " // quote characters ' or "
@ -177,37 +178,37 @@ bool QgsDelimitedTextFile::setFromUrl( const QUrl &url )
escape.clear(); escape.clear();
} }
} }
if ( url.hasQueryItem( QStringLiteral( "delimiter" ) ) ) if ( query.hasQueryItem( QStringLiteral( "delimiter" ) ) )
{ {
delimiter = url.queryItemValue( QStringLiteral( "delimiter" ) ); delimiter = query.queryItemValue( QStringLiteral( "delimiter" ) );
} }
if ( url.hasQueryItem( QStringLiteral( "quote" ) ) ) if ( query.hasQueryItem( QStringLiteral( "quote" ) ) )
{ {
quote = url.queryItemValue( QStringLiteral( "quote" ) ); quote = query.queryItemValue( QStringLiteral( "quote" ) );
} }
if ( url.hasQueryItem( QStringLiteral( "escape" ) ) ) if ( query.hasQueryItem( QStringLiteral( "escape" ) ) )
{ {
escape = url.queryItemValue( QStringLiteral( "escape" ) ); escape = query.queryItemValue( QStringLiteral( "escape" ) );
} }
if ( url.hasQueryItem( QStringLiteral( "skipLines" ) ) ) if ( query.hasQueryItem( QStringLiteral( "skipLines" ) ) )
{ {
mSkipLines = url.queryItemValue( QStringLiteral( "skipLines" ) ).toInt(); mSkipLines = query.queryItemValue( QStringLiteral( "skipLines" ) ).toInt();
} }
if ( url.hasQueryItem( QStringLiteral( "useHeader" ) ) ) if ( query.hasQueryItem( QStringLiteral( "useHeader" ) ) )
{ {
mUseHeader = ! url.queryItemValue( QStringLiteral( "useHeader" ) ).toUpper().startsWith( 'N' ); mUseHeader = ! query.queryItemValue( QStringLiteral( "useHeader" ) ).toUpper().startsWith( 'N' );
} }
if ( url.hasQueryItem( QStringLiteral( "skipEmptyFields" ) ) ) if ( query.hasQueryItem( QStringLiteral( "skipEmptyFields" ) ) )
{ {
mDiscardEmptyFields = ! url.queryItemValue( QStringLiteral( "skipEmptyFields" ) ).toUpper().startsWith( 'N' ); mDiscardEmptyFields = ! query.queryItemValue( QStringLiteral( "skipEmptyFields" ) ).toUpper().startsWith( 'N' );
} }
if ( url.hasQueryItem( QStringLiteral( "trimFields" ) ) ) if ( query.hasQueryItem( QStringLiteral( "trimFields" ) ) )
{ {
mTrimFields = ! url.queryItemValue( QStringLiteral( "trimFields" ) ).toUpper().startsWith( 'N' ); mTrimFields = ! query.queryItemValue( QStringLiteral( "trimFields" ) ).toUpper().startsWith( 'N' );
} }
if ( url.hasQueryItem( QStringLiteral( "maxFields" ) ) ) if ( query.hasQueryItem( QStringLiteral( "maxFields" ) ) )
{ {
mMaxFields = url.queryItemValue( QStringLiteral( "maxFields" ) ).toInt(); mMaxFields = query.queryItemValue( QStringLiteral( "maxFields" ) ).toInt();
} }
QgsDebugMsg( "Delimited text file is: " + mFileName ); QgsDebugMsg( "Delimited text file is: " + mFileName );
@ -245,47 +246,49 @@ bool QgsDelimitedTextFile::setFromUrl( const QUrl &url )
QUrl QgsDelimitedTextFile::url() QUrl QgsDelimitedTextFile::url()
{ {
QUrl url = QUrl::fromLocalFile( mFileName ); QUrl url = QUrl::fromLocalFile( mFileName );
QUrlQuery query( url );
if ( mEncoding != QLatin1String( "UTF-8" ) ) if ( mEncoding != QLatin1String( "UTF-8" ) )
{ {
url.addQueryItem( QStringLiteral( "encoding" ), mEncoding ); query.addQueryItem( QStringLiteral( "encoding" ), mEncoding );
} }
if ( mUseWatcher ) if ( mUseWatcher )
{ {
url.addQueryItem( QStringLiteral( "watchFile" ), QStringLiteral( "yes" ) ); query.addQueryItem( QStringLiteral( "watchFile" ), QStringLiteral( "yes" ) );
} }
url.addQueryItem( QStringLiteral( "type" ), type() ); query.addQueryItem( QStringLiteral( "type" ), type() );
if ( mType == DelimTypeRegexp ) if ( mType == DelimTypeRegexp )
{ {
url.addQueryItem( QStringLiteral( "delimiter" ), mDelimRegexp.pattern() ); query.addQueryItem( QStringLiteral( "delimiter" ), mDelimRegexp.pattern() );
} }
if ( mType == DelimTypeCSV ) if ( mType == DelimTypeCSV )
{ {
if ( mDelimChars != QLatin1String( "," ) ) url.addQueryItem( QStringLiteral( "delimiter" ), encodeChars( mDelimChars ) ); if ( mDelimChars != QLatin1String( "," ) ) query.addQueryItem( QStringLiteral( "delimiter" ), encodeChars( mDelimChars ) );
if ( mQuoteChar != QLatin1String( "\"" ) ) url.addQueryItem( QStringLiteral( "quote" ), encodeChars( mQuoteChar ) ); if ( mQuoteChar != QLatin1String( "\"" ) ) query.addQueryItem( QStringLiteral( "quote" ), encodeChars( mQuoteChar ) );
if ( mEscapeChar != QLatin1String( "\"" ) ) url.addQueryItem( QStringLiteral( "escape" ), encodeChars( mEscapeChar ) ); if ( mEscapeChar != QLatin1String( "\"" ) ) query.addQueryItem( QStringLiteral( "escape" ), encodeChars( mEscapeChar ) );
} }
if ( mSkipLines > 0 ) if ( mSkipLines > 0 )
{ {
url.addQueryItem( QStringLiteral( "skipLines" ), QString::number( mSkipLines ) ); query.addQueryItem( QStringLiteral( "skipLines" ), QString::number( mSkipLines ) );
} }
if ( ! mUseHeader ) if ( ! mUseHeader )
{ {
url.addQueryItem( QStringLiteral( "useHeader" ), QStringLiteral( "No" ) ); query.addQueryItem( QStringLiteral( "useHeader" ), QStringLiteral( "No" ) );
} }
if ( mTrimFields ) if ( mTrimFields )
{ {
url.addQueryItem( QStringLiteral( "trimFields" ), QStringLiteral( "Yes" ) ); query.addQueryItem( QStringLiteral( "trimFields" ), QStringLiteral( "Yes" ) );
} }
if ( mDiscardEmptyFields && mType != DelimTypeWhitespace ) if ( mDiscardEmptyFields && mType != DelimTypeWhitespace )
{ {
url.addQueryItem( QStringLiteral( "skipEmptyFields" ), QStringLiteral( "Yes" ) ); query.addQueryItem( QStringLiteral( "skipEmptyFields" ), QStringLiteral( "Yes" ) );
} }
if ( mMaxFields > 0 ) if ( mMaxFields > 0 )
{ {
url.addQueryItem( QStringLiteral( "maxFields" ), QString::number( mMaxFields ) ); query.addQueryItem( QStringLiteral( "maxFields" ), QString::number( mMaxFields ) );
} }
url.setQuery( query );
return url; return url;
} }

63
src/providers/delimitedtext/qgsdelimitedtextprovider.cpp
View File

@ -72,15 +72,16 @@ QgsDelimitedTextProvider::QgsDelimitedTextProvider( const QString &uri, const Pr
QgsDebugMsg( "Delimited text file uri is " + uri ); QgsDebugMsg( "Delimited text file uri is " + uri );
QUrl url = QUrl::fromEncoded( uri.toLatin1() ); const QUrl url = QUrl::fromEncoded( uri.toLatin1() );
mFile = qgis::make_unique< QgsDelimitedTextFile >(); mFile = qgis::make_unique< QgsDelimitedTextFile >();
mFile->setFromUrl( url ); mFile->setFromUrl( url );
QString subset; QString subset;
if ( url.hasQueryItem( QStringLiteral( "geomType" ) ) ) const QUrlQuery query( url );
if ( query.hasQueryItem( QStringLiteral( "geomType" ) ) )
{ {
QString gtype = url.queryItemValue( QStringLiteral( "geomType" ) ).toLower(); QString gtype = query.queryItemValue( QStringLiteral( "geomType" ) ).toLower();
if ( gtype == QLatin1String( "point" ) ) mGeometryType = QgsWkbTypes::PointGeometry; if ( gtype == QLatin1String( "point" ) ) mGeometryType = QgsWkbTypes::PointGeometry;
else if ( gtype == QLatin1String( "line" ) ) mGeometryType = QgsWkbTypes::LineGeometry; else if ( gtype == QLatin1String( "line" ) ) mGeometryType = QgsWkbTypes::LineGeometry;
else if ( gtype == QLatin1String( "polygon" ) ) mGeometryType = QgsWkbTypes::PolygonGeometry; else if ( gtype == QLatin1String( "polygon" ) ) mGeometryType = QgsWkbTypes::PolygonGeometry;
@ -89,30 +90,30 @@ QgsDelimitedTextProvider::QgsDelimitedTextProvider( const QString &uri, const Pr
if ( mGeometryType != QgsWkbTypes::NullGeometry ) if ( mGeometryType != QgsWkbTypes::NullGeometry )
{ {
if ( url.hasQueryItem( QStringLiteral( "wktField" ) ) ) if ( query.hasQueryItem( QStringLiteral( "wktField" ) ) )
{ {
mWktFieldName = url.queryItemValue( QStringLiteral( "wktField" ) ); mWktFieldName = query.queryItemValue( QStringLiteral( "wktField" ) );
mGeomRep = GeomAsWkt; mGeomRep = GeomAsWkt;
QgsDebugMsg( "wktField is: " + mWktFieldName ); QgsDebugMsg( "wktField is: " + mWktFieldName );
} }
else if ( url.hasQueryItem( QStringLiteral( "xField" ) ) && url.hasQueryItem( QStringLiteral( "yField" ) ) ) else if ( query.hasQueryItem( QStringLiteral( "xField" ) ) && query.hasQueryItem( QStringLiteral( "yField" ) ) )
{ {
mGeomRep = GeomAsXy; mGeomRep = GeomAsXy;
mGeometryType = QgsWkbTypes::PointGeometry; mGeometryType = QgsWkbTypes::PointGeometry;
mXFieldName = url.queryItemValue( QStringLiteral( "xField" ) ); mXFieldName = query.queryItemValue( QStringLiteral( "xField" ) );
mYFieldName = url.queryItemValue( QStringLiteral( "yField" ) ); mYFieldName = query.queryItemValue( QStringLiteral( "yField" ) );
if ( url.hasQueryItem( QStringLiteral( "zField" ) ) ) if ( query.hasQueryItem( QStringLiteral( "zField" ) ) )
mZFieldName = url.queryItemValue( QStringLiteral( "zField" ) ); mZFieldName = query.queryItemValue( QStringLiteral( "zField" ) );
if ( url.hasQueryItem( QStringLiteral( "mField" ) ) ) if ( query.hasQueryItem( QStringLiteral( "mField" ) ) )
mMFieldName = url.queryItemValue( QStringLiteral( "mField" ) ); mMFieldName = query.queryItemValue( QStringLiteral( "mField" ) );
QgsDebugMsg( "xField is: " + mXFieldName ); QgsDebugMsg( "xField is: " + mXFieldName );
QgsDebugMsg( "yField is: " + mYFieldName ); QgsDebugMsg( "yField is: " + mYFieldName );
QgsDebugMsg( "zField is: " + mZFieldName ); QgsDebugMsg( "zField is: " + mZFieldName );
QgsDebugMsg( "mField is: " + mMFieldName ); QgsDebugMsg( "mField is: " + mMFieldName );
if ( url.hasQueryItem( QStringLiteral( "xyDms" ) ) ) if ( query.hasQueryItem( QStringLiteral( "xyDms" ) ) )
{ {
mXyDms = ! url.queryItemValue( QStringLiteral( "xyDms" ) ).toLower().startsWith( 'n' ); mXyDms = ! query.queryItemValue( QStringLiteral( "xyDms" ) ).toLower().startsWith( 'n' );
} }
} }
else else
@ -122,33 +123,33 @@ QgsDelimitedTextProvider::QgsDelimitedTextProvider( const QString &uri, const Pr
} }
mDetectTypes = true; mDetectTypes = true;
if ( url.hasQueryItem( QStringLiteral( "detectTypes" ) ) ) if ( query.hasQueryItem( QStringLiteral( "detectTypes" ) ) )
mDetectTypes = ! url.queryItemValue( QStringLiteral( "detectTypes" ) ).toLower().startsWith( 'n' ); mDetectTypes = ! query.queryItemValue( QStringLiteral( "detectTypes" ) ).toLower().startsWith( 'n' );
if ( url.hasQueryItem( QStringLiteral( "decimalPoint" ) ) ) if ( query.hasQueryItem( QStringLiteral( "decimalPoint" ) ) )
mDecimalPoint = url.queryItemValue( QStringLiteral( "decimalPoint" ) ); mDecimalPoint = query.queryItemValue( QStringLiteral( "decimalPoint" ) );
if ( url.hasQueryItem( QStringLiteral( "crs" ) ) ) if ( query.hasQueryItem( QStringLiteral( "crs" ) ) )
mCrs.createFromString( url.queryItemValue( QStringLiteral( "crs" ) ) ); mCrs.createFromString( query.queryItemValue( QStringLiteral( "crs" ) ) );
if ( url.hasQueryItem( QStringLiteral( "subsetIndex" ) ) ) if ( query.hasQueryItem( QStringLiteral( "subsetIndex" ) ) )
{ {
mBuildSubsetIndex = ! url.queryItemValue( QStringLiteral( "subsetIndex" ) ).toLower().startsWith( 'n' ); mBuildSubsetIndex = ! query.queryItemValue( QStringLiteral( "subsetIndex" ) ).toLower().startsWith( 'n' );
} }
if ( url.hasQueryItem( QStringLiteral( "spatialIndex" ) ) ) if ( query.hasQueryItem( QStringLiteral( "spatialIndex" ) ) )
{ {
mBuildSpatialIndex = ! url.queryItemValue( QStringLiteral( "spatialIndex" ) ).toLower().startsWith( 'n' ); mBuildSpatialIndex = ! query.queryItemValue( QStringLiteral( "spatialIndex" ) ).toLower().startsWith( 'n' );
} }
if ( url.hasQueryItem( QStringLiteral( "subset" ) ) ) if ( query.hasQueryItem( QStringLiteral( "subset" ) ) )
{ {
// We need to specify FullyDecoded so that %25 is decoded as % // We need to specify FullyDecoded so that %25 is decoded as %
subset = QUrlQuery( url ).queryItemValue( QStringLiteral( "subset" ), QUrl::FullyDecoded ); subset = query.queryItemValue( QStringLiteral( "subset" ), QUrl::FullyDecoded );
QgsDebugMsg( "subset is: " + subset ); QgsDebugMsg( "subset is: " + subset );
} }
if ( url.hasQueryItem( QStringLiteral( "quiet" ) ) ) mShowInvalidLines = false; if ( query.hasQueryItem( QStringLiteral( "quiet" ) ) ) mShowInvalidLines = false;
// Do an initial scan of the file to determine field names, types, // Do an initial scan of the file to determine field names, types,
// geometry type (for Wkt), extents, etc. Parameter value subset.isEmpty() // geometry type (for Wkt), extents, etc. Parameter value subset.isEmpty()
@ -1128,10 +1129,12 @@ bool QgsDelimitedTextProvider::setSubsetString( const QString &subset, bool upda
void QgsDelimitedTextProvider::setUriParameter( const QString &parameter, const QString &value ) void QgsDelimitedTextProvider::setUriParameter( const QString &parameter, const QString &value )
{ {
QUrl url = QUrl::fromEncoded( dataSourceUri().toLatin1() ); QUrl url = QUrl::fromEncoded( dataSourceUri().toLatin1() );
if ( url.hasQueryItem( parameter ) ) QUrlQuery query( url );
url.removeAllQueryItems( parameter ); if ( query.hasQueryItem( parameter ) )
query.removeAllQueryItems( parameter );
if ( ! value.isEmpty() ) if ( ! value.isEmpty() )
url.addQueryItem( parameter, value ); query.addQueryItem( parameter, value );
url.setQuery( query );
setDataSourceUri( QString::fromLatin1( url.toEncoded() ) ); setDataSourceUri( QString::fromLatin1( url.toEncoded() ) );
} }

30
src/providers/delimitedtext/qgsdelimitedtextsourceselect.cpp
View File

@ -138,16 +138,17 @@ void QgsDelimitedTextSourceSelect::addButtonClicked()
//Build the delimited text URI from the user provided information //Build the delimited text URI from the user provided information
QUrl url = mFile->url(); QUrl url = mFile->url();
QUrlQuery query( url );
url.addQueryItem( QStringLiteral( "detectTypes" ), cbxDetectTypes->isChecked() ? QStringLiteral( "yes" ) : QStringLiteral( "no" ) ); query.addQueryItem( QStringLiteral( "detectTypes" ), cbxDetectTypes->isChecked() ? QStringLiteral( "yes" ) : QStringLiteral( "no" ) );
if ( cbxPointIsComma->isChecked() ) if ( cbxPointIsComma->isChecked() )
{ {
url.addQueryItem( QStringLiteral( "decimalPoint" ), QStringLiteral( "," ) ); query.addQueryItem( QStringLiteral( "decimalPoint" ), QStringLiteral( "," ) );
} }
if ( cbxXyDms->isChecked() ) if ( cbxXyDms->isChecked() )
{ {
url.addQueryItem( QStringLiteral( "xyDms" ), QStringLiteral( "yes" ) ); query.addQueryItem( QStringLiteral( "xyDms" ), QStringLiteral( "yes" ) );
} }
bool haveGeom = true; bool haveGeom = true;
@ -157,19 +158,19 @@ void QgsDelimitedTextSourceSelect::addButtonClicked()
if ( !cmbXField->currentText().isEmpty() && !cmbYField->currentText().isEmpty() ) if ( !cmbXField->currentText().isEmpty() && !cmbYField->currentText().isEmpty() )
{ {
field = cmbXField->currentText(); field = cmbXField->currentText();
url.addQueryItem( QStringLiteral( "xField" ), field ); query.addQueryItem( QStringLiteral( "xField" ), field );
field = cmbYField->currentText(); field = cmbYField->currentText();
url.addQueryItem( QStringLiteral( "yField" ), field ); query.addQueryItem( QStringLiteral( "yField" ), field );
} }
if ( !cmbZField->currentText().isEmpty() ) if ( !cmbZField->currentText().isEmpty() )
{ {
field = cmbZField->currentText(); field = cmbZField->currentText();
url.addQueryItem( QStringLiteral( "zField" ), field ); query.addQueryItem( QStringLiteral( "zField" ), field );
} }
if ( !cmbMField->currentText().isEmpty() ) if ( !cmbMField->currentText().isEmpty() )
{ {
field = cmbMField->currentText(); field = cmbMField->currentText();
url.addQueryItem( QStringLiteral( "mField" ), field ); query.addQueryItem( QStringLiteral( "mField" ), field );
} }
} }
else if ( geomTypeWKT->isChecked() ) else if ( geomTypeWKT->isChecked() )
@ -177,36 +178,37 @@ void QgsDelimitedTextSourceSelect::addButtonClicked()
if ( ! cmbWktField->currentText().isEmpty() ) if ( ! cmbWktField->currentText().isEmpty() )
{ {
QString field = cmbWktField->currentText(); QString field = cmbWktField->currentText();
url.addQueryItem( QStringLiteral( "wktField" ), field ); query.addQueryItem( QStringLiteral( "wktField" ), field );
} }
if ( cmbGeometryType->currentIndex() > 0 ) if ( cmbGeometryType->currentIndex() > 0 )
{ {
url.addQueryItem( QStringLiteral( "geomType" ), cmbGeometryType->currentText() ); query.addQueryItem( QStringLiteral( "geomType" ), cmbGeometryType->currentText() );
} }
} }
else else
{ {
haveGeom = false; haveGeom = false;
url.addQueryItem( QStringLiteral( "geomType" ), QStringLiteral( "none" ) ); query.addQueryItem( QStringLiteral( "geomType" ), QStringLiteral( "none" ) );
} }
if ( haveGeom ) if ( haveGeom )
{ {
QgsCoordinateReferenceSystem crs = crsGeometry->crs(); QgsCoordinateReferenceSystem crs = crsGeometry->crs();
if ( crs.isValid() ) if ( crs.isValid() )
{ {
url.addQueryItem( QStringLiteral( "crs" ), crs.authid() ); query.addQueryItem( QStringLiteral( "crs" ), crs.authid() );
} }
} }
if ( ! geomTypeNone->isChecked() ) if ( ! geomTypeNone->isChecked() )
{ {
url.addQueryItem( QStringLiteral( "spatialIndex" ), cbxSpatialIndex->isChecked() ? QStringLiteral( "yes" ) : QStringLiteral( "no" ) ); query.addQueryItem( QStringLiteral( "spatialIndex" ), cbxSpatialIndex->isChecked() ? QStringLiteral( "yes" ) : QStringLiteral( "no" ) );
} }
url.addQueryItem( QStringLiteral( "subsetIndex" ), cbxSubsetIndex->isChecked() ? QStringLiteral( "yes" ) : QStringLiteral( "no" ) ); query.addQueryItem( QStringLiteral( "subsetIndex" ), cbxSubsetIndex->isChecked() ? QStringLiteral( "yes" ) : QStringLiteral( "no" ) );
url.addQueryItem( QStringLiteral( "watchFile" ), cbxWatchFile->isChecked() ? QStringLiteral( "yes" ) : QStringLiteral( "no" ) ); query.addQueryItem( QStringLiteral( "watchFile" ), cbxWatchFile->isChecked() ? QStringLiteral( "yes" ) : QStringLiteral( "no" ) );
url.setQuery( query );
// store the settings // store the settings
saveSettings(); saveSettings();
saveSettingsForFile( mFileWidget->filePath() ); saveSettingsForFile( mFileWidget->filePath() );

6
src/providers/wcs/qgswcsprovider.cpp
View File

@ -526,8 +526,10 @@ void QgsWcsProvider::setCoverageCrs( QString const &crs )
void QgsWcsProvider::setQueryItem( QUrl &url, const QString &item, const QString &value ) const void QgsWcsProvider::setQueryItem( QUrl &url, const QString &item, const QString &value ) const
{ {
url.removeQueryItem( item ); QUrlQuery query( url );
url.addQueryItem( item, value ); query.removeQueryItem( item );
query.addQueryItem( item, value );
url.setQuery( query );
} }
bool QgsWcsProvider::readBlock( int bandNo, QgsRectangle const &viewExtent, int pixelWidth, int pixelHeight, void *block, QgsRasterBlockFeedback *feedback ) bool QgsWcsProvider::readBlock( int bandNo, QgsRectangle const &viewExtent, int pixelWidth, int pixelHeight, void *block, QgsRasterBlockFeedback *feedback )

4
src/providers/wfs/qgsbasenetworkrequest.cpp
View File

@ -264,7 +264,9 @@ bool QgsBaseNetworkRequest::sendPOST( const QUrl &url, const QString &contentTyp
{ {
// Hack for testing purposes // Hack for testing purposes
QUrl modifiedUrl( url ); QUrl modifiedUrl( url );
modifiedUrl.addQueryItem( QStringLiteral( "POSTDATA" ), QString::fromUtf8( data ) ); QUrlQuery query( modifiedUrl );
query.addQueryItem( QStringLiteral( "POSTDATA" ), QString::fromUtf8( data ) );
modifiedUrl.setQuery( query );
return sendGET( modifiedUrl, QString(), true, true, false ); return sendGET( modifiedUrl, QString(), true, true, false );
} }

8
src/providers/wfs/qgswfscapabilities.cpp
View File

@ -41,15 +41,17 @@ QgsWfsCapabilities::QgsWfsCapabilities( const QString &uri, const QgsDataProvide
bool QgsWfsCapabilities::requestCapabilities( bool synchronous, bool forceRefresh ) bool QgsWfsCapabilities::requestCapabilities( bool synchronous, bool forceRefresh )
{ {
QUrl url( mUri.baseURL( ) ); QUrl url( mUri.baseURL( ) );
url.addQueryItem( QStringLiteral( "REQUEST" ), QStringLiteral( "GetCapabilities" ) ); QUrlQuery query( url );
query.addQueryItem( QStringLiteral( "REQUEST" ), QStringLiteral( "GetCapabilities" ) );
const QString &version = mUri.version(); const QString &version = mUri.version();
if ( version == QgsWFSConstants::VERSION_AUTO ) if ( version == QgsWFSConstants::VERSION_AUTO )
// MapServer honours the order with the first value being the preferred one // MapServer honours the order with the first value being the preferred one
url.addQueryItem( QStringLiteral( "ACCEPTVERSIONS" ), QStringLiteral( "2.0.0,1.1.0,1.0.0" ) ); query.addQueryItem( QStringLiteral( "ACCEPTVERSIONS" ), QStringLiteral( "2.0.0,1.1.0,1.0.0" ) );
else else
url.addQueryItem( QStringLiteral( "VERSION" ), version ); query.addQueryItem( QStringLiteral( "VERSION" ), version );
url.setQuery( query );
if ( !sendGET( url, QString(), synchronous, forceRefresh ) ) if ( !sendGET( url, QString(), synchronous, forceRefresh ) )
{ {
emit gotCapabilities(); emit gotCapabilities();

44
src/providers/wfs/qgswfsdatasourceuri.cpp
View File

@ -46,40 +46,42 @@ QgsWFSDataSourceURI::QgsWFSDataSourceURI( const QString &uri )
}; };
QUrl url( uri ); QUrl url( uri );
QUrlQuery query( url );
// Transform all param keys to lowercase // Transform all param keys to lowercase
const auto items( url.queryItems() ); const QList<QPair<QString, QString> > items( query.queryItems() );
for ( const queryItem &item : items ) for ( const queryItem &item : items )
{ {
url.removeQueryItem( item.first ); query.removeQueryItem( item.first );
url.addQueryItem( item.first.toLower(), item.second ); query.addQueryItem( item.first.toLower(), item.second );
} }
QString srsname = url.queryItemValue( QgsWFSConstants::URI_PARAM_SRSNAME ); QString srsname = query.queryItemValue( QgsWFSConstants::URI_PARAM_SRSNAME );
QString bbox = url.queryItemValue( QgsWFSConstants::URI_PARAM_BBOX ); QString bbox = query.queryItemValue( QgsWFSConstants::URI_PARAM_BBOX );
QString typeName = url.queryItemValue( QgsWFSConstants::URI_PARAM_TYPENAME ); QString typeName = query.queryItemValue( QgsWFSConstants::URI_PARAM_TYPENAME );
QString version = url.queryItemValue( QgsWFSConstants::URI_PARAM_VERSION ); QString version = query.queryItemValue( QgsWFSConstants::URI_PARAM_VERSION );
QString filter = url.queryItemValue( QgsWFSConstants::URI_PARAM_FILTER ); QString filter = query.queryItemValue( QgsWFSConstants::URI_PARAM_FILTER );
QString outputFormat = url.queryItemValue( QgsWFSConstants::URI_PARAM_OUTPUTFORMAT ); QString outputFormat = query.queryItemValue( QgsWFSConstants::URI_PARAM_OUTPUTFORMAT );
mAuth.mAuthCfg = url.queryItemValue( QgsWFSConstants::URI_PARAM_AUTHCFG ); mAuth.mAuthCfg = query.queryItemValue( QgsWFSConstants::URI_PARAM_AUTHCFG );
// NOTE: A defined authcfg overrides any older username/password auth // NOTE: A defined authcfg overrides any older username/password auth
// Only check for older auth if it is undefined // Only check for older auth if it is undefined
if ( mAuth.mAuthCfg.isEmpty() ) if ( mAuth.mAuthCfg.isEmpty() )
{ {
mAuth.mUserName = url.queryItemValue( QgsWFSConstants::URI_PARAM_USERNAME ); mAuth.mUserName = query.queryItemValue( QgsWFSConstants::URI_PARAM_USERNAME );
// In QgsDataSourceURI, the "username" param is named "user", check it // In QgsDataSourceURI, the "username" param is named "user", check it
if ( mAuth.mUserName.isEmpty() ) if ( mAuth.mUserName.isEmpty() )
{ {
mAuth.mUserName = url.queryItemValue( QgsWFSConstants::URI_PARAM_USER ); mAuth.mUserName = query.queryItemValue( QgsWFSConstants::URI_PARAM_USER );
} }
mAuth.mPassword = url.queryItemValue( QgsWFSConstants::URI_PARAM_PASSWORD ); mAuth.mPassword = query.queryItemValue( QgsWFSConstants::URI_PARAM_PASSWORD );
} }
// Now remove all stuff that is not the core URL // Now remove all stuff that is not the core URL
for ( auto param : url.queryItems() ) for ( const QPair<QString, QString> &param : query.queryItems() )
{ {
if ( sFilter.contains( param.first.toLower() ) ) if ( sFilter.contains( param.first.toLower() ) )
url.removeAllQueryItems( param.first ); query.removeAllQueryItems( param.first );
} }
url.setQuery( query );
mURI = QgsDataSourceUri(); mURI = QgsDataSourceUri();
mURI.setParam( QgsWFSConstants::URI_PARAM_URL, url.toEncoded() ); mURI.setParam( QgsWFSConstants::URI_PARAM_URL, url.toEncoded() );
@ -102,19 +104,20 @@ QgsWFSDataSourceURI::QgsWFSDataSourceURI( const QString &uri )
else else
{ {
QUrl url( mURI.param( QgsWFSConstants::URI_PARAM_URL ) ); QUrl url( mURI.param( QgsWFSConstants::URI_PARAM_URL ) );
QUrlQuery query( url );
bool URLModified = false; bool URLModified = false;
bool somethingChanged = false; bool somethingChanged = false;
do do
{ {
somethingChanged = false; somethingChanged = false;
const auto items( url.queryItems() ); const QList<QPair<QString, QString> > items( query.queryItems() );
for ( const queryItem &item : items ) for ( const queryItem &item : items )
{ {
const QString lowerName( item.first.toLower() ); const QString lowerName( item.first.toLower() );
if ( lowerName == QgsWFSConstants::URI_PARAM_OUTPUTFORMAT ) if ( lowerName == QgsWFSConstants::URI_PARAM_OUTPUTFORMAT )
{ {
setOutputFormat( item.second ); setOutputFormat( item.second );
url.removeQueryItem( item.first ); query.removeQueryItem( item.first );
somethingChanged = true; somethingChanged = true;
URLModified = true; URLModified = true;
break; break;
@ -125,7 +128,7 @@ QgsWFSDataSourceURI::QgsWFSDataSourceURI( const QString &uri )
lowerName == QLatin1String( "typenames" ) || lowerName == QLatin1String( "typenames" ) ||
lowerName == QLatin1String( "version" ) ) lowerName == QLatin1String( "version" ) )
{ {
url.removeQueryItem( item.first ); query.removeQueryItem( item.first );
somethingChanged = true; somethingChanged = true;
URLModified = true; URLModified = true;
break; break;
@ -133,6 +136,7 @@ QgsWFSDataSourceURI::QgsWFSDataSourceURI( const QString &uri )
} }
} }
while ( somethingChanged ); while ( somethingChanged );
url.setQuery( query );
if ( URLModified ) if ( URLModified )
{ {
mURI.setParam( QgsWFSConstants::URI_PARAM_URL, url.toEncoded() ); mURI.setParam( QgsWFSConstants::URI_PARAM_URL, url.toEncoded() );
@ -172,10 +176,12 @@ const QString QgsWFSDataSourceURI::uri() const
QUrl QgsWFSDataSourceURI::baseURL( bool bIncludeServiceWFS ) const QUrl QgsWFSDataSourceURI::baseURL( bool bIncludeServiceWFS ) const
{ {
QUrl url( mURI.param( QgsWFSConstants::URI_PARAM_URL ) ); QUrl url( mURI.param( QgsWFSConstants::URI_PARAM_URL ) );
QUrlQuery query( url );
if ( bIncludeServiceWFS ) if ( bIncludeServiceWFS )
{ {
url.addQueryItem( QStringLiteral( "SERVICE" ), QStringLiteral( "WFS" ) ); query.addQueryItem( QStringLiteral( "SERVICE" ), QStringLiteral( "WFS" ) );
} }
url.setQuery( query );
return url; return url;
} }