Merge branch 'main' into feat/load-vertices-from-layer

Author: koebi

CHANGELOG.md

@@ -39,6 +39,9 @@ RELEASING:
 13. Upload the package to https://plugins.qgis.org/plugins/ORStools/ (Manage > Add Version)
 14. Create new release in GitHub with tag version and release title of `vX.X.X`
  -->
+## Unreleased
+### Added
+- Add shortcut to apply route calculation with ctrl+return
 
 ## [2.1.0] - 2025-12-09
 

ORStools/gui/ORStoolsDialog.py

@@ -35,7 +35,8 @@
 from qgis.PyQt.QtWidgets import QCheckBox
 
 from ..utils.gui import LayerMessageBox
-from ..utils.router import route_as_layer
+from ..utils.router import route_as_layer, get_routing_parameters
+from ORStools.gui import directions_gui
 
 try:
     import processing
@@ -59,15 +60,25 @@
     QgsAnnotation,
     QgsCoordinateTransform,
     QgsWkbTypes,
+    QgsTask,
+    QgsApplication,
 )
 from qgis.gui import (
     QgsMapCanvasAnnotationItem,
     QgsCollapsibleGroupBox,
     QgisInterface,
 )
 from qgis.PyQt.QtCore import QSizeF, QPointF, QCoreApplication
-from qgis.PyQt.QtGui import QTextDocument
-from qgis.PyQt.QtWidgets import QAction, QDialog, QApplication, QMenu, QMessageBox, QDialogButtonBox
+from qgis.PyQt.QtGui import QTextDocument, QKeySequence
+from qgis.PyQt.QtWidgets import (
+    QAction,
+    QDialog,
+    QApplication,
+    QMenu,
+    QMessageBox,
+    QDialogButtonBox,
+    QShortcut,
+)
 from qgis.PyQt.QtGui import QColor
 from qgis.PyQt.QtWidgets import (
     QWidget,
@@ -256,55 +267,49 @@ def _init_gui_control(self) -> None:
 
         self.dlg.show()
 
-    def run_gui_control(self) -> None:
-        """Slot function for OK button of main dialog."""
-        if self.dlg.routing_fromline_list.count() == 0:
-            return
+    def handle_task_exception(self, exception: Exception) -> None:
+        """Handles exceptions thrown by routing task."""
+        if isinstance(exception, exceptions.InvalidInput):
+            QMessageBox.critical(
+                self.dlg,
+                self.tr("Wrong number of waypoints"),
+                self.tr("""At least 3 or 4 waypoints are needed to perform routing optimization. 
+                                Remember, the first and last location are not part of the optimization.
+                                """),
+            )
 
-        try:
-            basepath = os.path.dirname(__file__)
-
-            layer_out = route_as_layer(self.dlg)
-
-            # style output layer
-            qml_path = os.path.join(basepath, "linestyle.qml")
-            layer_out.loadNamedStyle(qml_path, True)
-            layer_out.triggerRepaint()
-
-            self.project.addMapLayer(layer_out)
-
-            # add ors svg path
-            my_new_path = os.path.join(basepath, "img/svg")
-            svg_paths = QgsSettings().value("svg/searchPathsForSVG") or []
-            if my_new_path not in svg_paths:
-                svg_paths.append(my_new_path)
-                QgsSettings().setValue("svg/searchPathsForSVG", svg_paths)
-
-            # Associate annotations with map layer, so they get deleted when layer is deleted
-            for annotation in self.dlg.annotations:
-                # Has the potential to be pretty cool: instead of deleting, associate with mapLayer
-                # , you can change order after optimization
-                # Then in theory, when the layer is remove, the annotation is removed as well
-                # Doesn't work though, the annotations are still there when project is re-opened
-                # annotation.setMapLayer(layer_out)
-                self.project.annotationManager().removeAnnotation(annotation)
+        elif isinstance(exception, exceptions.EmptyLayerError):
+            QMessageBox.warning(
+                self.dlg,
+                self.tr("Empty layer"),
+                self.tr("""
+                        The specified avoid polygon(s) layer does not contain any features.
+                        Please add polygons to the layer or uncheck avoid polygons.
+                                            """),
+            )
 
-            self.dlg.annotations = []
-            self.dlg.rubber_band.reset()
+        elif isinstance(exception, exceptions.InvalidKey):
+            QMessageBox.critical(
+                self.dlg,
+                self.tr("Missing API key"),
+                self.tr("""
+                Did you forget to set an <b>API key</b> for openrouteservice?<br><br>
 
-            self.dlg._clear_listwidget()
-            self.dlg.line_tool = maptools.LineTool(self.dlg)
+                If you don't have an API key, please visit https://openrouteservice.org/sign-up to get one. <br><br> 
+                Then enter the API key for openrouteservice provider in Web ► ORS Tools ► Provider Settings or the 
+                settings symbol in the main ORS Tools GUI, next to the provider dropdown."""),
+            )
 
-        except exceptions.ApiError as e:
+        elif isinstance(exception, exceptions.ApiError):
             # Error thrown by ORStools/common/client.py, line 243, in _check_status
             try:
-                parsed = json.loads(e.message)
+                parsed = json.loads(exception.message)
                 error_code = int(parsed["error"]["code"])
             except KeyError:
-                error_code = e.status
+                error_code = exception.status
 
             if error_code == 2010:
-                maptools.LineTool(self.dlg).radius_message_box(e)
+                maptools.LineTool(self.dlg).radius_message_box(exception)
                 return
             elif error_code == "404":
                 self.iface.messageBar().pushMessage(
@@ -313,7 +318,56 @@ def run_gui_control(self) -> None:
                     level=Qgis.MessageLevel.Warning,
                 )
             else:
-                raise e
+                raise exception
+
+    def on_finished(self, exception, layer_out=None) -> None:
+        """
+        Callback when task finishes.
+
+        :param exception: Exception if task failed, None otherwise
+        :param result: The layer_out returned from the task function
+        """
+        if exception is not None:
+            self.handle_task_exception(exception)
+            return
+
+        basepath = os.path.dirname(__file__)
+        qml_path = os.path.join(basepath, "linestyle.qml")
+        layer_out.loadNamedStyle(qml_path, True)
+        layer_out.triggerRepaint()
+
+        self.project.addMapLayer(layer_out)
+
+        my_new_path = os.path.join(basepath, "img/svg")
+        svg_paths = QgsSettings().value("svg/searchPathsForSVG") or []
+        if my_new_path not in svg_paths:
+            svg_paths.append(my_new_path)
+            QgsSettings().setValue("svg/searchPathsForSVG", svg_paths)
+
+    def run_gui_control(self) -> None:
+        """Slot function for OK button of main dialog."""
+        if self.dlg.routing_fromline_list.count() == 0:
+            return
+
+        provider, profile, optimize = get_routing_parameters(self.dlg)
+        directions = directions_gui.Directions(self.dlg)
+
+        self.task = QgsTask.fromFunction(
+            "ORStools Routing Task",
+            route_as_layer,
+            provider=provider,
+            profile=profile,
+            optimize=optimize,
+            directions=directions.get_directions(),
+            on_finished=self.on_finished,
+        )
+
+        self.dlg.setDisabled(True)
+
+        QgsApplication.taskManager().addTask(self.task)
+
+        self.task.taskCompleted.connect(lambda: self.dlg.setDisabled(False))
+        self.task.taskTerminated.connect(lambda: self.dlg.setDisabled(False))
 
     def tr(self, string: str) -> str:
         return QCoreApplication.translate(str(self.__class__.__name__), string)
@@ -396,6 +450,8 @@ def __init__(self, iface: QgisInterface, parent=None) -> None:
         self.pushButton_export.clicked.connect(
             lambda: processing.execAlgorithmDialog(f"{PLUGIN_NAME}:export_network_from_map")
         )
+        shortcut = QShortcut(QKeySequence("Ctrl+Return"), self)
+        shortcut.activated.connect(lambda: self.global_buttons.accepted.emit())
 
         # Reset index of list items every time something is moved or deleted
         self.routing_fromline_list.model().rowsMoved.connect(self._reindex_list_items)

ORStools/gui/ORStoolsDialogUI.ui

@@ -972,6 +972,9 @@ p, li { white-space: pre-wrap; }
       </item>
       <item>
        <widget class="QDialogButtonBox" name="global_buttons">
+        <property name="toolTip">
+         <string>Ctrl+Enter to calculate route, Esc to Close.</string>
+        </property>
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>

ORStools/gui/directions_gui.py

@@ -93,6 +93,26 @@ def __init__(self, dlg):
 
         self.options = dict()
 
+        request_line_feature = self.get_request_line_feature()
+        parameters = self.get_parameters()
+        optimize_parameters = self._get_optimize_parameters()
+
+        self.directions = {
+            "request_line_feature": request_line_feature,
+            "parameters": parameters,
+            "optimize_parameters": optimize_parameters,
+            "options": self.options,
+        }
+
+    def get_directions(self):
+        """
+        Returns the directions dict for use in router.
+
+        :returns: directions dict
+        :rtype: dict
+        """
+        return self.directions
+
     def get_request_line_feature(self):
         """
         Extracts all coordinates for the list in GUI.

ORStools/utils/exceptions.py

@@ -60,6 +60,18 @@ def __str__(self):
             return f"{self.status} ({self.message})"
 
 
+class InvalidInput(Exception):
+    """Signifies that the request failed because of invalid input data."""
+
+    pass
+
+
+class EmptyLayerError(Exception):
+    """Signifies that the request has been aborted due to an empty layer."""
+
+    pass
+
+
 class OverQueryLimit(Exception):
     """Signifies that the request failed because the client exceeded its query rate limit."""
 

ORStools/utils/maptools.py

@@ -30,6 +30,7 @@
 import json
 import math
 
+from ORStools.gui import directions_gui
 from qgis.gui import QgsMapToolEmitPoint, QgsRubberBand
 from qgis.core import (
     QgsProject,
@@ -283,7 +284,11 @@ def create_rubber_band(self) -> None:
         self.dlg.rubber_band.setStrokeColor(color)
         self.dlg.rubber_band.setWidth(5)
         if self.dlg.toggle_preview.isChecked() and self.dlg.routing_fromline_list.count() > 1:
-            route_layer = router.route_as_layer(self.dlg)
+            provider, profile, optimize = router.get_routing_parameters(self.dlg)
+            directions = directions_gui.Directions(self.dlg)
+            route_layer = router.route_as_layer(
+                None, provider, profile, optimize, directions.get_directions()
+            )
             if route_layer:
                 feature = next(route_layer.getFeatures())
                 self.dlg.rubber_band.addGeometry(feature.geometry(), route_layer)