3.10 backports

cmake/FindProj.cmake

@@ -57,9 +57,9 @@ IF (PROJ_FOUND)
      STRING(REGEX REPLACE "^.*PROJ_VERSION_MINOR +([0-9]+).*$" "\\1" PROJ_VERSION_MINOR "${proj_version}")
      STRING(REGEX REPLACE "^.*PROJ_VERSION_PATCH +([0-9]+).*$" "\\1" PROJ_VERSION_PATCH "${proj_version}")
      STRING(CONCAT PROJ_VERSION_STR "(" ${PROJ_VERSION_MAJOR} "." ${PROJ_VERSION_MINOR} "." ${PROJ_VERSION_PATCH} ")")
-     IF ((PROJ_VERSION_MAJOR EQUAL 6) AND (PROJ_VERSION_MINOR LESS 3))
-       MESSAGE (FATAL_ERROR "Cannot build QGIS using Proj ${PROJ_VERSION_MAJOR}.${PROJ_VERSION_MINOR}.${PROJ_VERSION_PATCH} Use 6.3.0 or higher.")
-     ENDIF ((PROJ_VERSION_MAJOR EQUAL 6) AND (PROJ_VERSION_MINOR LESS 3))
+     IF ((PROJ_VERSION_MAJOR EQUAL 6) AND ((PROJ_VERSION_MINOR LESS 3) OR (PROJ_VERSION_MINOR EQUAL 3 AND PROJ_VERSION_PATCH LESS 1)))
+       MESSAGE (FATAL_ERROR "Cannot build QGIS using Proj ${PROJ_VERSION_MAJOR}.${PROJ_VERSION_MINOR}.${PROJ_VERSION_PATCH} Use 6.3.1 or higher.")
+     ENDIF ((PROJ_VERSION_MAJOR EQUAL 6) AND ((PROJ_VERSION_MINOR LESS 3) OR (PROJ_VERSION_MINOR EQUAL 3 AND PROJ_VERSION_PATCH LESS 1)))
    ELSE(EXISTS ${PROJ_INCLUDE_DIR}/proj.h AND EXISTS ${PROJ_INCLUDE_DIR}/proj_experimental.h)
      FILE(READ ${PROJ_INCLUDE_DIR}/proj_api.h proj_version)
      STRING(REGEX REPLACE "^.*PJ_VERSION ([0-9]+).*$" "\\1" PJ_VERSION "${proj_version}")

python/core/auto_generated/geometry/qgspoint.sip.in

@@ -56,7 +56,7 @@ based on the following rules:
     if ( sipCanConvertToType( a0, sipType_QgsPointXY, SIP_NOT_NONE ) && a1 == Py_None && a2 == Py_None && a3 == Py_None && a4 == Py_None )
     {
       int state;
-      int sipIsErr = 0;
+      sipIsErr = 0;
 
       QgsPointXY *p = reinterpret_cast<QgsPointXY *>( sipConvertToType( a0, sipType_QgsPointXY, 0, SIP_NOT_NONE, &state, &sipIsErr ) );
       if ( sipIsErr )
@@ -71,7 +71,7 @@ based on the following rules:
     else if ( sipCanConvertToType( a0, sipType_QPointF, SIP_NOT_NONE ) && a1 == Py_None && a2 == Py_None && a3 == Py_None && a4 == Py_None )
     {
       int state;
-      int sipIsErr = 0;
+      sipIsErr = 0;
 
       QPointF *p = reinterpret_cast<QPointF *>( sipConvertToType( a0, sipType_QPointF, 0, SIP_NOT_NONE, &state, &sipIsErr ) );
       if ( sipIsErr )
@@ -97,6 +97,11 @@ based on the following rules:
       QgsWkbTypes::Type wkbType = a4 == Py_None ? QgsWkbTypes::Unknown : static_cast<QgsWkbTypes::Type>( sipConvertToEnum( a4, sipType_QgsWkbTypes_Type ) );
       sipCpp = new sipQgsPoint( QgsPoint( x, y, z, m, wkbType ) );
     }
+    else // Invalid ctor arguments
+    {
+      PyErr_SetString( PyExc_TypeError, QStringLiteral( "Invalid type in constructor arguments." ).toUtf8().constData() );
+      sipIsErr = 1;
+    }
 %End
 
 

python/core/auto_generated/qgscoordinatetransform.sip.in

@@ -350,6 +350,119 @@ coordinates.
 .. seealso:: :py:func:`coordinateOperation`
 
 .. versionadded:: 3.8
+%End
+
+    void setAllowFallbackTransforms( bool allowed );
+%Docstring
+Sets whether "ballpark" fallback transformations can be used in the case that the specified
+coordinate operation fails (such as when coordinates from outside a required grid shift file
+are transformed). See fallbackOperationOccurred() for further details.
+
+.. note::
+
+   Requires Proj 6.0 or later. Builds based on earlier Proj versions will ignore this setting.
+
+.. warning::
+
+   If setBallparkTransformsAreAppropriate() is set to ``True``, this setting will be ignored
+   and fallback transformations will always be permitted.
+
+
+.. seealso:: :py:func:`allowFallbackTransforms`
+
+.. seealso:: :py:func:`setBallparkTransformsAreAppropriate`
+
+.. versionadded:: 3.12
+%End
+
+    bool allowFallbackTransforms() const;
+%Docstring
+Returns whether "ballpark" fallback transformations will be used in the case that the specified
+coordinate operation fails (such as when coordinates from outside a required grid shift file
+are transformed). See fallbackOperationOccurred() for further details.
+
+.. note::
+
+   Requires Proj 6.0 or later. Builds based on earlier Proj versions will ignore this setting.
+
+.. seealso:: :py:func:`setAllowFallbackTransforms`
+
+.. seealso:: :py:func:`setBallparkTransformsAreAppropriate`
+
+.. versionadded:: 3.12
+%End
+
+    void setBallparkTransformsAreAppropriate( bool appropriate );
+%Docstring
+Sets whether approximate "ballpark" results are appropriate for this coordinate transform.
+
+When a coordinate transform is only being used to generate ballpark results then the
+``appropriate`` argument should be set to ``True``. This indicates that its perfectable
+acceptable (and even expected!) for the transform to use fallback coordinate operations
+in the case that the preferred or user-specified operation fails (such as when coordinates
+from outside of a grid shift file's extent are transformed).
+
+When ``appropriate`` is ``True``, then no warnings will be generated when the transform
+falls back to a default operation, which may introduce inaccuracies when compared to
+the default/specified coordinate operation.
+
+This should be set when a transform expects that coordinates outside of the direct
+area of use while be transformed, e.g. when transforming from a global extent to a
+CRS with a localized area of use.
+
+If ``appropriate`` is ``False`` (the default behavior), then transforms MAY STILL fallback to default operations
+when the preferred or user-specified operation fails, however whenever this occurs
+a user-visible warning will be generated.
+
+If ``appropriate`` is ``True``, then this setting overrides allowFallbackTransforms()
+and fallback transforms will always be allowed when required.
+
+.. warning::
+
+   This setting applies to a single instance of a coordinate transform only,
+   and is not copied when a coordinate transform object is copied or assigned.
+
+.. note::
+
+   Requires Proj 6.0 or later. Builds based on earlier Proj versions will ignore this setting.
+
+
+.. versionadded:: 3.12
+%End
+
+    void disableFallbackOperationHandler( bool disabled );
+%Docstring
+Sets whether the default fallback operation handler is disabled for this transform instance.
+
+If the default handler is ``disabled`` then it is possible to determine whether a fallback
+operation occurred by testing fallbackOperationOccurred() immediately after a transformation.
+
+.. warning::
+
+   This setting applies to a single instance of a coordinate transform only,
+   and is not copied when a coordinate transform object is copied or assigned.
+
+.. note::
+
+   Requires Proj 6.0 or later. Builds based on earlier Proj versions will never perform fallback operations.
+
+
+.. seealso:: :py:func:`fallbackOperationOccurred`
+
+.. versionadded:: 3.12
+%End
+
+    bool fallbackOperationOccurred() const;
+%Docstring
+Returns ``True`` if a fallback operation occurred for the most recent transform.
+
+.. note::
+
+   Requires Proj 6.0 or later. Builds based on earlier Proj versions will never perform fallback operations.
+
+.. seealso:: :py:func:`disableFallbackOperationHandler`
+
+.. versionadded:: 3.12
 %End
 
  int sourceDatumTransformId() const /Deprecated/;

python/core/auto_generated/qgscoordinatetransformcontext.sip.in

@@ -125,7 +125,7 @@ Returns ``True`` if the new transform pair was added successfully.
    Has no effect on builds based on Proj 6.0 or later, use addCoordinateOperation() instead.
 %End
 
-    bool addCoordinateOperation( const QgsCoordinateReferenceSystem &sourceCrs, const QgsCoordinateReferenceSystem &destinationCrs, const QString &coordinateOperationProjString );
+    bool addCoordinateOperation( const QgsCoordinateReferenceSystem &sourceCrs, const QgsCoordinateReferenceSystem &destinationCrs, const QString &coordinateOperationProjString, bool allowFallback = true );
 %Docstring
 Adds a new ``coordinateOperationProjString`` to use when projecting coordinates
 from the specified ``sourceCrs`` to the specified ``destinationCrs``.
@@ -134,6 +134,14 @@ from the specified ``sourceCrs`` to the specified ``destinationCrs``.
 string. If ``coordinateOperationProjString`` is empty, then the default Proj operation
 will be used when transforming between the coordinate reference systems.
 
+If ``allowFallback`` is ``True`` (since QGIS 3.12), then "ballpark" fallback transformations
+will be used in the case that the specified coordinate operation fails (such as when
+coordinates from outside a required grid shift file are transformed). See
+QgsCoordinateTransform.fallbackOperationOccurred() for further details. Note that if an
+existing ``sourceCrs`` and ``destinationCrs`` pair are added with a different ``allowFallback``
+value, that value will replace the existing one (i.e. each combination of ``sourceCrs`` and
+``destinationCrs`` must be unique).
+
 .. warning::
 
    coordinateOperationProjString MUST be a proj string which has been normalized for
@@ -229,6 +237,17 @@ be used.
 
 
 .. versionadded:: 3.8
+%End
+
+    bool allowFallbackTransform( const QgsCoordinateReferenceSystem &source, const QgsCoordinateReferenceSystem &destination ) const;
+%Docstring
+Returns ``True`` if approximate "ballpark" transforms may be used when transforming
+between a ``source`` and ``destination`` CRS pair, in the case that the preferred
+coordinate operation fails (such as when
+coordinates from outside a required grid shift file are transformed). See
+QgsCoordinateTransform.fallbackOperationOccurred() for further details.
+
+.. versionadded:: 3.12
 %End
 
     bool mustReverseCoordinateOperation( const QgsCoordinateReferenceSystem &source, const QgsCoordinateReferenceSystem &destination ) const;

python/core/auto_generated/qgsvectordataprovider.sip.in

@@ -410,12 +410,25 @@ Returns the above in friendly format.
 
     virtual void setEncoding( const QString &e );
 %Docstring
-Set encoding used for accessing data from layer
+Set encoding used for accessing data from layer.
+
+An empty encoding string indicates that the provider should automatically
+select the most appropriate encoding for the data source.
+
+.. warning::
+
+   Support for setting the provider encoding depends on the underlying data
+   provider. Check capabilities() for the QgsVectorDataProvider.SelectEncoding
+   capability in order to determine if the provider supports this ability.
+
+.. seealso:: :py:func:`encoding`
 %End
 
     QString encoding() const;
 %Docstring
-Gets encoding which is used for accessing data
+Returns the encoding which is used for accessing data.
+
+.. seealso:: :py:func:`setEncoding`
 %End
 
     int fieldNameIndex( const QString &fieldName ) const;

python/core/auto_generated/qgsvectorlayer.sip.in

@@ -435,7 +435,16 @@ Uses :py:class:`QgsExpression`
 
     void setProviderEncoding( const QString &encoding );
 %Docstring
-Sets the textencoding of the data provider
+Sets the text ``encoding`` of the data provider.
+
+An empty ``encoding`` string indicates that the provider should automatically
+select the most appropriate encoding.
+
+.. warning::
+
+   Support for setting the provider encoding depends on the underlying data
+   provider. Check dataProvider().capabilities() for the QgsVectorDataProvider.SelectEncoding
+   capability in order to determine if the provider supports this ability.
 %End
 
     void setCoordinateSystem();

python/gui/auto_generated/qgsactionmenu.sip.in

@@ -92,6 +92,13 @@ Sets an expression context scope used to resolve underlying actions.
 Returns an expression context scope used to resolve underlying actions.
 
 .. versionadded:: 3.0
+%End
+
+    QList<QgsAction> menuActions();
+%Docstring
+Returns menu actions
+
+.. versionadded:: 3.12
 %End
 
   signals:

src/analysis/processing/qgsalgorithmtransform.cpp

@@ -92,6 +92,8 @@ QgsFeatureList QgsTransformAlgorithm::processFeature( const QgsFeature &f, QgsPr
   {
     mCreatedTransform = true;
     mTransform = QgsCoordinateTransform( sourceCrs(), mDestCrs, mTransformContext );
+
+    mTransform.disableFallbackOperationHandler( true );
   }
 
   if ( feature.hasGeometry() )
@@ -107,6 +109,14 @@ QgsFeatureList QgsTransformAlgorithm::processFeature( const QgsFeature &f, QgsPr
       {
         feature.clearGeometry();
       }
+
+      if ( !mWarnedAboutFallbackTransform && mTransform.fallbackOperationOccurred() )
+      {
+        feedback->reportError( QObject::tr( "An alternative, ballpark-only transform was used when transforming coordinates for one or more features. "
+                                            "(Possibly an incorrect choice of operation was made for transformations between these reference systems - check "
+                                            "that the selected operation is valid for the full extent of the input layer.)" ) );
+        mWarnedAboutFallbackTransform = true; // only warn once to avoid flooding the log
+      }
     }
     catch ( QgsCsException & )
     {

src/analysis/processing/qgsalgorithmtransform.h

@@ -58,6 +58,7 @@ class QgsTransformAlgorithm : public QgsProcessingFeatureBasedAlgorithm
     QgsCoordinateReferenceSystem mDestCrs;
     QgsCoordinateTransform mTransform;
     QgsCoordinateTransformContext mTransformContext;
+    bool mWarnedAboutFallbackTransform = false;
 
 };
 

src/app/qgisapp.cpp

@@ -4976,7 +4976,8 @@ bool QgisApp::addVectorLayersPrivate( const QStringList &layerQStringList, const
     if ( layer->isValid() )
     {
       userAskedToAddLayers = true;
-      layer->setProviderEncoding( enc );
+      if ( !enc.isEmpty() )
+        layer->setProviderEncoding( enc );
 
       QStringList sublayers = layer->dataProvider()->subLayers();
       QgsDebugMsg( QStringLiteral( "got valid layer with %1 sublayers" ).arg( sublayers.count() ) );
@@ -5206,7 +5207,7 @@ bool QgisApp::askUserForZipItemLayers( const QString &path )
     }
     else if ( layerItem->providerKey() == QLatin1String( "ogr" ) )
     {
-      if ( addVectorLayers( QStringList( item->path() ), QStringLiteral( "System" ), QStringLiteral( "file" ) ) )
+      if ( addVectorLayers( QStringList( item->path() ), QString(), QStringLiteral( "file" ) ) )
         ok = true;
     }
   }
@@ -6724,7 +6725,7 @@ bool QgisApp::openLayer( const QString &fileName, bool allowInteractive )
   {
     if ( allowInteractive )
     {
-      ok = ok || addVectorLayersPrivate( QStringList( fileName ), QStringLiteral( "System" ), QStringLiteral( "file" ), false );
+      ok = ok || addVectorLayersPrivate( QStringList( fileName ), QString(), QStringLiteral( "file" ), false );
     }
     else
     {

src/app/qgisappinterface.cpp

@@ -744,6 +744,7 @@ QgsAttributeDialog *QgisAppInterface::getFeatureForm( QgsVectorLayer *l, QgsFeat
   context.setDistanceArea( myDa );
   context.setVectorLayerTools( qgis->vectorLayerTools() );
   context.setMapCanvas( qgis->mapCanvas() );
+  context.setCadDockWidget( qgis->cadDockWidget() );
   QgsAttributeDialog *dialog = new QgsAttributeDialog( l, &feature, false, qgis, true, context );
   if ( !feature.isValid() )
   {