Merge pull request #8111 from elpaso/in-place-select-all

[processing][need-docs] In place editing triggers editing and select all

python/plugins/processing/ProcessingPlugin.py

@@ -233,13 +233,13 @@ def initGui(self):
 
         self.toolbox.processingToolbar.addSeparator()
 
-        self.editSelectedAction = QAction(
+        self.editInPlaceAction = QAction(
             QgsApplication.getThemeIcon("/mActionProcessSelected.svg"),
-            self.tr('Edit Selected Features'), self.iface.mainWindow())
-        self.editSelectedAction.setObjectName('editSelectedFeatures')
-        self.editSelectedAction.setCheckable(True)
-        self.editSelectedAction.toggled.connect(self.editSelected)
-        self.toolbox.processingToolbar.addAction(self.editSelectedAction)
+            self.tr('Edit Features In-Place'), self.iface.mainWindow())
+        self.editInPlaceAction.setObjectName('editInPlaceFeatures')
+        self.editInPlaceAction.setCheckable(True)
+        self.editInPlaceAction.toggled.connect(self.editSelected)
+        self.toolbox.processingToolbar.addAction(self.editInPlaceAction)
 
         self.toolbox.processingToolbar.addSeparator()
 
@@ -266,18 +266,18 @@ def initGui(self):
         self.sync_in_place_button_state()
 
     def sync_in_place_button_state(self, layer=None):
-        """Synchronise the button state with layer state and selection"""
+        """Synchronise the button state with layer state"""
 
         if layer is None:
             layer = self.iface.activeLayer()
 
-        old_enabled_state = self.editSelectedAction.isEnabled()
+        old_enabled_state = self.editInPlaceAction.isEnabled()
 
-        new_enabled_state = layer is not None and layer.type() == QgsMapLayer.VectorLayer and layer.isEditable() and layer.selectedFeatureCount()
-        self.editSelectedAction.setEnabled(new_enabled_state)
+        new_enabled_state = layer is not None and layer.type() == QgsMapLayer.VectorLayer
+        self.editInPlaceAction.setEnabled(new_enabled_state)
 
         if new_enabled_state != old_enabled_state:
-            self.toolbox.set_in_place_edit_mode(new_enabled_state and self.editSelectedAction.isChecked())
+            self.toolbox.set_in_place_edit_mode(new_enabled_state and self.editInPlaceAction.isChecked())
 
     def openProcessingOptions(self):
         self.iface.showOptionsDialog(self.iface.mainWindow(), currentPage='processingOptions')

python/plugins/processing/gui/AlgorithmDialog.py

@@ -71,6 +71,7 @@ def __init__(self, alg, in_place=False, parent=None):
 
         self.feedback_dialog = None
         self.in_place = in_place
+        self.active_layer = None
 
         self.setAlgorithm(alg)
         self.setMainWidget(self.getParametersPanel(alg, self))
@@ -80,9 +81,13 @@ def __init__(self, alg, in_place=False, parent=None):
             self.runAsBatchButton.clicked.connect(self.runAsBatch)
             self.buttonBox().addButton(self.runAsBatchButton, QDialogButtonBox.ResetRole) # reset role to ensure left alignment
         else:
+            self.active_layer = iface.activeLayer()
             self.runAsBatchButton = None
-            self.buttonBox().button(QDialogButtonBox.Ok).setText('Modify Selected Features')
-            self.buttonBox().button(QDialogButtonBox.Close).setText('Cancel')
+            has_selection = self.active_layer and (self.active_layer.selectedFeatureCount() > 0)
+            self.buttonBox().button(QDialogButtonBox.Ok).setText(QCoreApplication.translate("AlgorithmDialog", "Modify Selected Features")
+                                                                 if has_selection else QCoreApplication.translate("AlgorithmDialog", "Modify All Features"))
+            self.buttonBox().button(QDialogButtonBox.Close).setText(QCoreApplication.translate("AlgorithmDialog", "Cancel"))
+            self.setWindowTitle(self.windowTitle() + ' | ' + self.active_layer.name())
 
     def getParametersPanel(self, alg, parent):
         return ParametersPanel(parent, alg, self.in_place)
@@ -108,7 +113,7 @@ def getParameterValues(self):
             if not param.isDestination():
 
                 if self.in_place and param.name() == 'INPUT':
-                    parameters[param.name()] = iface.activeLayer()
+                    parameters[param.name()] = self.active_layer
                     continue
 
                 try:

python/plugins/processing/gui/AlgorithmExecutor.py

@@ -41,7 +41,8 @@
                        QgsExpression,
                        QgsWkbTypes,
                        QgsGeometry,
-                       QgsVectorLayerUtils)
+                       QgsVectorLayerUtils,
+                       QgsVectorLayer)
 from processing.gui.Postprocessing import handleAlgorithmResults
 from processing.tools import dataobjects
 from qgis.utils import iface
@@ -70,22 +71,20 @@ def execute(alg, parameters, context=None, feedback=None):
         return False, {}
 
 
-def execute_in_place_run(alg, active_layer, parameters, context=None, feedback=None, raise_exceptions=False):
+def execute_in_place_run(alg, parameters, context=None, feedback=None, raise_exceptions=False):
     """Executes an algorithm modifying features in-place in the input layer.
 
-    The input layer must be editable or an exception is raised.
-
     :param alg: algorithm to run
     :type alg: QgsProcessingAlgorithm
-    :param active_layer: the editable layer
-    :type active_layer: QgsVectoLayer
     :param parameters: parameters of the algorithm
     :type parameters: dict
     :param context: context, defaults to None
-    :param context: QgsProcessingContext, optional
+    :type context: QgsProcessingContext, optional
     :param feedback: feedback, defaults to None
-    :param feedback: QgsProcessingFeedback, optional
-    :raises QgsProcessingException: raised when the layer is not editable or the layer cannot be found in the current project
+    :type feedback: QgsProcessingFeedback, optional
+    :param raise_exceptions: useful for testing, if True exceptions are raised, normally exceptions will be forwarded to the feedback
+    :type raise_exceptions: boo, default to False
+    :raises QgsProcessingException: raised when there is no active layer, or it cannot be made editable
     :return: a tuple with true if success and results
     :rtype: tuple
     """
@@ -95,14 +94,46 @@ def execute_in_place_run(alg, active_layer, parameters, context=None, feedback=N
     if context is None:
         context = dataobjects.createContext(feedback)
 
-    if active_layer is None or not active_layer.isEditable():
-        raise QgsProcessingException(tr("Layer is not editable or layer is None."))
+    active_layer = parameters['INPUT']
+
+    # Run some checks and prepare the layer for in-place execution by:
+    # - getting the active layer and checking that it is a vector
+    # - making the layer editable if it was not already
+    # - selecting all features if none was selected
+    # - checking in-place support for the active layer/alg/parameters
+    # If one of the check fails and raise_exceptions is True an exception
+    # is raised, else the execution is aborted and the error reported in
+    # the feedback
+    try:
+        if active_layer is None:
+            raise QgsProcessingException(tr("There is not active layer."))
+
+        if not isinstance(active_layer, QgsVectorLayer):
+            raise QgsProcessingException(tr("Active layer is not a vector layer."))
+
+        if not active_layer.isEditable():
+            if not active_layer.startEditing():
+                raise QgsProcessingException(tr("Active layer is not editable (and editing could not be turned on)."))
 
-    if not alg.supportInPlaceEdit(active_layer):
-        raise QgsProcessingException(tr("Selected algorithm and parameter configuration are not compatible with in-place modifications."))
+        if not alg.supportInPlaceEdit(active_layer):
+            raise QgsProcessingException(tr("Selected algorithm and parameter configuration are not compatible with in-place modifications."))
+    except QgsProcessingException as e:
+        if raise_exceptions:
+            raise e
+        QgsMessageLog.logMessage(str(sys.exc_info()[0]), 'Processing', Qgis.Critical)
+        if feedback is not None:
+            feedback.reportError(getattr(e, 'msg', str(e)), fatalError=True)
+        return False, {}
+
+    if not active_layer.selectedFeatureIds():
+        active_layer.selectAll()
 
     parameters['OUTPUT'] = 'memory:'
 
+    # Start the execution
+    # If anything goes wrong and raise_exceptions is True an exception
+    # is raised, else the execution is aborted and the error reported in
+    # the feedback
     try:
         new_feature_ids = []
 
@@ -123,7 +154,7 @@ def execute_in_place_run(alg, active_layer, parameters, context=None, feedback=N
             if not alg.supportInPlaceEdit(active_layer):
                 raise QgsProcessingException(tr("Selected algorithm and parameter configuration are not compatible with in-place modifications."))
             field_idxs = range(len(active_layer.fields()))
-            feature_iterator = active_layer.getFeatures(QgsFeatureRequest(active_layer.selectedFeatureIds())) if parameters['INPUT'].selectedFeaturesOnly else active_layer.getFeatures()
+            feature_iterator = active_layer.getFeatures(QgsFeatureRequest(active_layer.selectedFeatureIds()))
             step = 100 / len(active_layer.selectedFeatureIds()) if active_layer.selectedFeatureIds() else 1
             for current, f in enumerate(feature_iterator):
                 feedback.setProgress(current * step)
@@ -190,15 +221,15 @@ def execute_in_place_run(alg, active_layer, parameters, context=None, feedback=N
             raise e
         QgsMessageLog.logMessage(str(sys.exc_info()[0]), 'Processing', Qgis.Critical)
         if feedback is not None:
-            feedback.reportError(getattr(e, 'msg', str(e)))
+            feedback.reportError(getattr(e, 'msg', str(e)), fatalError=True)
 
     return False, {}
 
 
 def execute_in_place(alg, parameters, context=None, feedback=None):
-    """Executes an algorithm modifying features in-place in the active layer.
-
-    The input layer must be editable or an exception is raised.
+    """Executes an algorithm modifying features in-place, if the INPUT
+    parameter is not defined, the current active layer will be used as
+    INPUT.
 
     :param alg: algorithm to run
     :type alg: QgsProcessingAlgorithm
@@ -213,10 +244,11 @@ def execute_in_place(alg, parameters, context=None, feedback=None):
     :rtype: tuple
     """
 
-    parameters['INPUT'] = QgsProcessingFeatureSourceDefinition(iface.activeLayer().id(), True)
-    ok, results = execute_in_place_run(alg, iface.activeLayer(), parameters, context=context, feedback=feedback)
+    if not 'INPUT' in parameters or not parameters['INPUT']:
+        parameters['INPUT'] = iface.activeLayer()
+    ok, results = execute_in_place_run(alg, parameters, context=context, feedback=feedback)
     if ok:
-        iface.activeLayer().triggerRepaint()
+        parameters['INPUT'].triggerRepaint()
     return ok, results
 
 

python/plugins/processing/gui/AlgorithmLocatorFilter.py

@@ -137,7 +137,7 @@ def fetchResults(self, string, context, feedback):
         # collect results in main thread, since this method is inexpensive and
         # accessing the processing registry/current layer is not thread safe
 
-        if iface.activeLayer() is None or iface.activeLayer().type() != QgsMapLayer.VectorLayer or not iface.activeLayer().selectedFeatureCount() or not iface.activeLayer().isEditable():
+        if iface.activeLayer() is None or iface.activeLayer().type() != QgsMapLayer.VectorLayer:
             return
 
         for a in QgsApplication.processingRegistry().algorithms():

tests/src/python/test_qgsprocessinginplace.py

@@ -349,8 +349,7 @@ def _alg_tester(self, alg_name, input_layer, parameters):
         alg = self.registry.createAlgorithmById(alg_name)
 
         self.assertIsNotNone(alg)
-        parameters['INPUT'] = QgsProcessingFeatureSourceDefinition(
-            input_layer.id(), True)
+        parameters['INPUT'] = input_layer
         parameters['OUTPUT'] = 'memory:'
 
         old_features = [f for f in input_layer.getFeatures()]
@@ -363,14 +362,9 @@ def _alg_tester(self, alg_name, input_layer, parameters):
         feedback = ConsoleFeedBack()
 
         input_layer.rollBack()
-        with self.assertRaises(QgsProcessingException) as cm:
-            execute_in_place_run(
-                alg, input_layer, parameters, context=context, feedback=feedback, raise_exceptions=True)
-
         ok = False
-        input_layer.startEditing()
         ok, _ = execute_in_place_run(
-            alg, input_layer, parameters, context=context, feedback=feedback, raise_exceptions=True)
+            alg, parameters, context=context, feedback=feedback, raise_exceptions=True)
         new_features = [f for f in input_layer.getFeatures()]
 
         # Check ret values
@@ -439,6 +433,39 @@ def test_execute_in_place_run(self):
             }
         )
 
+    def test_select_all_features(self):
+        """Check that if there is no selection, the alg will run on all features"""
+
+        self.vl.rollBack()
+        self.vl.removeSelection()
+        old_count = self.vl.featureCount()
+
+        context = QgsProcessingContext()
+        context.setProject(QgsProject.instance())
+        feedback = ConsoleFeedBack()
+
+        alg = self.registry.createAlgorithmById('native:translategeometry')
+
+        self.assertIsNotNone(alg)
+
+        parameters = {
+            'DELTA_X': 1.1,
+            'DELTA_Y': 1.1,
+        }
+        parameters['INPUT'] = self.vl
+        parameters['OUTPUT'] = 'memory:'
+
+        old_features = [f for f in self.vl.getFeatures()]
+
+        ok, _ = execute_in_place_run(
+            alg, parameters, context=context, feedback=feedback, raise_exceptions=True)
+        new_features = [f for f in self.vl.getFeatures()]
+
+        self.assertEqual(len(new_features), old_count)
+
+        # Check all are selected
+        self.assertEqual(len(self.vl.selectedFeatureIds()), old_count)
+
     def test_multi_to_single(self):
         """Check that the geometry type is still multi after the alg is run"""