Merge remote-tracking branch 'origin/main' into optimized-prime-tower

cura/CuraApplication.py

@@ -104,7 +104,8 @@ from cura.Settings.SettingInheritanceManager import SettingInheritanceManager
 from cura.Settings.SidebarCustomMenuItemsModel import SidebarCustomMenuItemsModel
 from cura.Settings.SimpleModeSettingsManager import SimpleModeSettingsManager
 from cura.TaskManagement.OnExitCallbackManager import OnExitCallbackManager
-from cura.UI import CuraSplashScreen, MachineActionManager, PrintInformation
+from cura.UI import CuraSplashScreen, PrintInformation
+from cura.UI.MachineActionManager import MachineActionManager
 from cura.UI.AddPrinterPagesModel import AddPrinterPagesModel
 from cura.UI.MachineSettingsManager import MachineSettingsManager
 from cura.UI.ObjectsModel import ObjectsModel
@@ -125,6 +126,7 @@ from .Machines.Models.CompatibleMachineModel import CompatibleMachineModel
 from .Machines.Models.MachineListModel import MachineListModel
 from .Machines.Models.ActiveIntentQualitiesModel import ActiveIntentQualitiesModel
 from .Machines.Models.IntentSelectionModel import IntentSelectionModel
+from .PrintOrderManager import PrintOrderManager
 from .SingleInstance import SingleInstance
 
 if TYPE_CHECKING:
@@ -179,6 +181,7 @@ class CuraApplication(QtApplication):
 
         # Variables set from CLI
         self._files_to_open = []
+        self._urls_to_open = []
         self._use_single_instance = False
 
         self._single_instance = None
@@ -186,7 +189,7 @@ class CuraApplication(QtApplication):
 
         self._cura_formula_functions = None  # type: Optional[CuraFormulaFunctions]
 
-        self._machine_action_manager = None  # type: Optional[MachineActionManager.MachineActionManager]
+        self._machine_action_manager: Optional[MachineActionManager] = None
 
         self.empty_container = None  # type: EmptyInstanceContainer
         self.empty_definition_changes_container = None  # type: EmptyInstanceContainer
@@ -202,6 +205,7 @@ class CuraApplication(QtApplication):
         self._container_manager = None
 
         self._object_manager = None
+        self._print_order_manager = None
         self._extruders_model = None
         self._extruders_model_with_optional = None
         self._build_plate_model = None
@@ -333,7 +337,7 @@ class CuraApplication(QtApplication):
         for filename in self._cli_args.file:
             url = QUrl(filename)
             if url.scheme() in self._supported_url_schemes:
-                self._open_url_queue.append(url)
+                self._urls_to_open.append(url)
             else:
                 self._files_to_open.append(os.path.abspath(filename))
 
@@ -352,11 +356,11 @@ class CuraApplication(QtApplication):
         self.__addAllEmptyContainers()
         self.__setLatestResouceVersionsForVersionUpgrade()
 
-        self._machine_action_manager = MachineActionManager.MachineActionManager(self)
+        self._machine_action_manager = MachineActionManager(self)
         self._machine_action_manager.initialize()
 
     def __sendCommandToSingleInstance(self):
-        self._single_instance = SingleInstance(self, self._files_to_open)
+        self._single_instance = SingleInstance(self, self._files_to_open, self._urls_to_open)
 
         # If we use single instance, try to connect to the single instance server, send commands, and then exit.
         # If we cannot find an existing single instance server, this is the only instance, so just keep going.
@@ -373,9 +377,15 @@ class CuraApplication(QtApplication):
             Resources.addExpectedDirNameInData(dir_name)
 
         app_root = os.path.abspath(os.path.join(os.path.dirname(sys.executable)))
-        Resources.addSecureSearchPath(os.path.join(app_root, "share", "cura", "resources"))
 
-        Resources.addSecureSearchPath(os.path.join(self._app_install_dir, "share", "cura", "resources"))
+        if platform.system() == "Darwin":
+            Resources.addSecureSearchPath(os.path.join(app_root, "Resources", "share", "cura", "resources"))
+            Resources.addSecureSearchPath(
+                os.path.join(self._app_install_dir, "Resources", "share", "cura", "resources"))
+        else:
+            Resources.addSecureSearchPath(os.path.join(app_root, "share", "cura", "resources"))
+            Resources.addSecureSearchPath(os.path.join(self._app_install_dir, "share", "cura", "resources"))
+
         if not hasattr(sys, "frozen"):
             cura_data_root = os.environ.get('CURA_DATA_ROOT', None)
             if cura_data_root:
@@ -899,6 +909,7 @@ class CuraApplication(QtApplication):
         # initialize info objects
         self._print_information = PrintInformation.PrintInformation(self)
         self._cura_actions = CuraActions.CuraActions(self)
+        self._print_order_manager = PrintOrderManager(self.getObjectsModel().getNodes)
         self.processEvents()
         # Initialize setting visibility presets model.
         self._setting_visibility_presets_model = SettingVisibilityPresetsModel(self.getPreferences(), parent = self)
@@ -956,6 +967,8 @@ class CuraApplication(QtApplication):
             self.callLater(self._openFile, file_name)
         for file_name in self._open_file_queue:  # Open all the files that were queued up while plug-ins were loading.
             self.callLater(self._openFile, file_name)
+        for url in self._urls_to_open:
+            self.callLater(self._openUrl, url)
         for url in self._open_url_queue:
             self.callLater(self._openUrl, url)
 
@@ -979,6 +992,7 @@ class CuraApplication(QtApplication):
             t.setEnabledAxis([ToolHandle.XAxis, ToolHandle.YAxis, ToolHandle.ZAxis])
 
         Selection.selectionChanged.connect(self.onSelectionChanged)
+        self._print_order_manager.printOrderChanged.connect(self._onPrintOrderChanged)
 
         # Set default background color for scene
         self.getRenderer().setBackgroundColor(QColor(245, 245, 245))
@@ -1068,6 +1082,10 @@ class CuraApplication(QtApplication):
     def getTextManager(self, *args) -> "TextManager":
         return self._text_manager
 
+    @pyqtSlot(bool)
+    def getWorkplaceDropToBuildplate(self, drop_to_build_plate: bool) ->None:
+        return self._physics.setAppPerModelDropDown(drop_to_build_plate)
+
     def getCuraFormulaFunctions(self, *args) -> "CuraFormulaFunctions":
         if self._cura_formula_functions is None:
             self._cura_formula_functions = CuraFormulaFunctions(self)
@@ -1094,6 +1112,10 @@ class CuraApplication(QtApplication):
             self._object_manager = ObjectsModel(self)
         return self._object_manager
 
+    @pyqtSlot(str, result = "QVariantList")
+    def getSupportedActionMachineList(self, definition_id: str) -> List["MachineAction"]:
+        return self._machine_action_manager.getSupportedActions(self._machine_manager.getDefinitionByMachineId(definition_id))
+
     @pyqtSlot(result = QObject)
     def getExtrudersModel(self, *args) -> "ExtrudersModel":
         if self._extruders_model is None:
@@ -1129,18 +1151,16 @@ class CuraApplication(QtApplication):
             self._setting_inheritance_manager = SettingInheritanceManager.createSettingInheritanceManager()
         return self._setting_inheritance_manager
 
-    def getMachineActionManager(self, *args: Any) -> MachineActionManager.MachineActionManager:
+    @pyqtSlot(result = QObject)
+    def getMachineActionManager(self, *args: Any) -> MachineActionManager:
         """Get the machine action manager
 
         We ignore any *args given to this, as we also register the machine manager as qml singleton.
         It wants to give this function an engine and script engine, but we don't care about that.
         """
 
-        return cast(MachineActionManager.MachineActionManager, self._machine_action_manager)
+        return  self._machine_action_manager
 
-    @pyqtSlot(result = QObject)
-    def getMachineActionManagerQml(self)-> MachineActionManager.MachineActionManager:
-        return cast(QObject, self._machine_action_manager)
 
     @pyqtSlot(result = QObject)
     def getMaterialManagementModel(self) -> MaterialManagementModel:
@@ -1250,6 +1270,7 @@ class CuraApplication(QtApplication):
         self.processEvents()
         engine.rootContext().setContextProperty("Printer", self)
         engine.rootContext().setContextProperty("CuraApplication", self)
+        engine.rootContext().setContextProperty("PrintOrderManager", self._print_order_manager)
         engine.rootContext().setContextProperty("PrintInformation", self._print_information)
         engine.rootContext().setContextProperty("CuraActions", self._cura_actions)
         engine.rootContext().setContextProperty("CuraSDKVersion", ApplicationMetadata.CuraSDKVersion)
@@ -1264,7 +1285,7 @@ class CuraApplication(QtApplication):
         qmlRegisterSingletonType(IntentManager, "Cura", 1, 6, self.getIntentManager, "IntentManager")
         qmlRegisterSingletonType(SettingInheritanceManager, "Cura", 1, 0, self.getSettingInheritanceManager, "SettingInheritanceManager")
         qmlRegisterSingletonType(SimpleModeSettingsManager, "Cura", 1, 0, self.getSimpleModeSettingsManagerWrapper, "SimpleModeSettingsManager")
-        qmlRegisterSingletonType(MachineActionManager.MachineActionManager, "Cura", 1, 0, self.getMachineActionManagerWrapper, "MachineActionManager")
+        qmlRegisterSingletonType(MachineActionManager, "Cura", 1, 0, self.getMachineActionManagerWrapper, "MachineActionManager")
 
         self.processEvents()
         qmlRegisterType(NetworkingUtil, "Cura", 1, 5, "NetworkingUtil")
@@ -1745,8 +1766,12 @@ class CuraApplication(QtApplication):
             Selection.remove(node)
         Selection.add(group_node)
 
+        all_nodes = self.getObjectsModel().getNodes()
+        PrintOrderManager.updatePrintOrdersAfterGroupOperation(all_nodes, group_node, selected_nodes)
+
     @pyqtSlot()
     def ungroupSelected(self) -> None:
+        all_nodes = self.getObjectsModel().getNodes()
         selected_objects = Selection.getAllSelectedObjects().copy()
         for node in selected_objects:
             if node.callDecoration("isGroup"):
@@ -1754,21 +1779,30 @@ class CuraApplication(QtApplication):
 
                 group_parent = node.getParent()
                 children = node.getChildren().copy()
-                for child in children:
-                    # Ungroup only 1 level deep
-                    if child.getParent() != node:
-                        continue
 
+                # Ungroup only 1 level deep
+                children_to_ungroup = list(filter(lambda child: child.getParent() == node, children))
+                for child in children_to_ungroup:
                     # Set the parent of the children to the parent of the group-node
                     op.addOperation(SetParentOperation(child, group_parent))
 
                     # Add all individual nodes to the selection
                     Selection.add(child)
 
+                PrintOrderManager.updatePrintOrdersAfterUngroupOperation(all_nodes, node, children_to_ungroup)
                 op.push()
                 # Note: The group removes itself from the scene once all its children have left it,
                 # see GroupDecorator._onChildrenChanged
 
+    def _onPrintOrderChanged(self) -> None:
+        # update object list
+        scene = self.getController().getScene()
+        scene.sceneChanged.emit(scene.getRoot())
+
+        # reset if already was sliced
+        Application.getInstance().getBackend().needsSlicing()
+        Application.getInstance().getBackend().tickle()
+
     def _createSplashScreen(self) -> Optional[CuraSplashScreen.CuraSplashScreen]:
         if self._is_headless:
             return None

cura/HitChecker.py

@@ -0,0 +1,88 @@
+from typing import List, Dict
+from cura.Scene.CuraSceneNode import CuraSceneNode
+
+
+class HitChecker:
+    """Checks if nodes can be printed without causing any collisions and interference"""
+
+    def __init__(self, nodes: List[CuraSceneNode]) -> None:
+        self._hit_map = self._buildHitMap(nodes)
+
+    def anyTwoNodesBlockEachOther(self, nodes: List[CuraSceneNode]) -> bool:
+        """Returns True if any 2 nodes block each other"""
+        for a in nodes:
+            for b in nodes:
+                if self._hit_map[a][b] and self._hit_map[b][a]:
+                    return True
+        return False
+
+    def canPrintBefore(self, node: CuraSceneNode, other_nodes: List[CuraSceneNode]) -> bool:
+        """Returns True if node doesn't block other_nodes and can be printed before them"""
+        no_hits = all(not self._hit_map[node][other_node] for other_node in other_nodes)
+        return no_hits
+
+    def canPrintAfter(self, node: CuraSceneNode, other_nodes: List[CuraSceneNode]) -> bool:
+        """Returns True if node doesn't hit other nodes and can be printed after them"""
+        no_hits = all(not self._hit_map[other_node][node] for other_node in other_nodes)
+        return no_hits
+
+    def calculateScore(self, a: CuraSceneNode, b: CuraSceneNode) -> int:
+        """Calculate score simply sums the number of other objects it 'blocks'
+
+        :param a: node
+        :param b: node
+        :return: sum of the number of other objects
+        """
+
+        score_a = sum(self._hit_map[a].values())
+        score_b = sum(self._hit_map[b].values())
+        return score_a - score_b
+
+    def canPrintNodesInProvidedOrder(self, ordered_nodes: List[CuraSceneNode]) -> bool:
+        """Returns True If nodes don't have any hits in provided order"""
+        for node_index, node in enumerate(ordered_nodes):
+            nodes_before = ordered_nodes[:node_index - 1] if node_index - 1 >= 0 else []
+            nodes_after = ordered_nodes[node_index + 1:] if node_index + 1 < len(ordered_nodes) else []
+            if not self.canPrintBefore(node, nodes_after) or not self.canPrintAfter(node, nodes_before):
+                return False
+        return True
+
+    @staticmethod
+    def _buildHitMap(nodes: List[CuraSceneNode]) -> Dict[CuraSceneNode, CuraSceneNode]:
+        """Pre-computes all hits between all objects
+
+        :nodes: nodes that need to be checked for collisions
+        :return: dictionary where hit_map[node1][node2] is False if there node1 can be printed before node2
+        """
+        hit_map = {j: {i: HitChecker._checkHit(j, i) for i in nodes} for j in nodes}
+        return hit_map
+
+    @staticmethod
+    def _checkHit(a: CuraSceneNode, b: CuraSceneNode) -> bool:
+        """Checks if a can be printed before b
+
+        :param a: node
+        :param b: node
+        :return: False if a can be printed before b
+        """
+
+        if a == b:
+            return False
+
+        a_hit_hull = a.callDecoration("getConvexHullBoundary")
+        b_hit_hull = b.callDecoration("getConvexHullHeadFull")
+        overlap = a_hit_hull.intersectsPolygon(b_hit_hull)
+
+        if overlap:
+            return True
+
+        # Adhesion areas must never overlap, regardless of printing order
+        # This would cause over-extrusion
+        a_hit_hull = a.callDecoration("getAdhesionArea")
+        b_hit_hull = b.callDecoration("getAdhesionArea")
+        overlap = a_hit_hull.intersectsPolygon(b_hit_hull)
+
+        if overlap:
+            return True
+        else:
+            return False

cura/OAuth2/AuthorizationHelpers.py

@@ -16,6 +16,7 @@ from UM.TaskManagement.HttpRequestManager import HttpRequestManager  # To downlo
 
 catalog = i18nCatalog("cura")
 TOKEN_TIMESTAMP_FORMAT = "%Y-%m-%d %H:%M:%S"
+REQUEST_TIMEOUT = 5 # Seconds
 
 
 class AuthorizationHelpers:
@@ -53,7 +54,8 @@ class AuthorizationHelpers:
             data = urllib.parse.urlencode(data).encode("UTF-8"),
             headers_dict = headers,
             callback = lambda response: self.parseTokenResponse(response, callback),
-            error_callback = lambda response, _: self.parseTokenResponse(response, callback)
+            error_callback = lambda response, _: self.parseTokenResponse(response, callback),
+            timeout = REQUEST_TIMEOUT
         )
 
     def getAccessTokenUsingRefreshToken(self, refresh_token: str, callback: Callable[[AuthenticationResponse], None]) -> None:
@@ -77,7 +79,9 @@ class AuthorizationHelpers:
             data = urllib.parse.urlencode(data).encode("UTF-8"),
             headers_dict = headers,
             callback = lambda response: self.parseTokenResponse(response, callback),
-            error_callback = lambda response, _: self.parseTokenResponse(response, callback)
+            error_callback = lambda response, _: self.parseTokenResponse(response, callback),
+            urgent = True,
+            timeout = REQUEST_TIMEOUT
         )
 
     def parseTokenResponse(self, token_response: QNetworkReply, callback: Callable[[AuthenticationResponse], None]) -> None:
@@ -122,7 +126,8 @@ class AuthorizationHelpers:
             check_token_url,
             headers_dict = headers,
             callback = lambda reply: self._parseUserProfile(reply, success_callback, failed_callback),
-            error_callback = lambda _, _2: failed_callback() if failed_callback is not None else None
+            error_callback = lambda _, _2: failed_callback() if failed_callback is not None else None,
+            timeout = REQUEST_TIMEOUT
         )
 
     def _parseUserProfile(self, reply: QNetworkReply, success_callback: Optional[Callable[[UserProfile], None]], failed_callback: Optional[Callable[[], None]] = None) -> None:

cura/OAuth2/AuthorizationService.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Ultimaker B.V.
+# Copyright (c) 2024 UltiMaker
 # Cura is released under the terms of the LGPLv3 or higher.
 
 import json
@@ -6,13 +6,14 @@ from datetime import datetime, timedelta
 from typing import Callable, Dict, Optional, TYPE_CHECKING, Union
 from urllib.parse import urlencode, quote_plus
 
-from PyQt6.QtCore import QUrl
+from PyQt6.QtCore import QUrl, QTimer
 from PyQt6.QtGui import QDesktopServices
 
 from UM.Logger import Logger
 from UM.Message import Message
 from UM.Signal import Signal
 from UM.i18n import i18nCatalog
+from UM.TaskManagement.HttpRequestManager import HttpRequestManager  # To download log-in tokens.
 from cura.OAuth2.AuthorizationHelpers import AuthorizationHelpers, TOKEN_TIMESTAMP_FORMAT
 from cura.OAuth2.LocalAuthorizationServer import LocalAuthorizationServer
 from cura.OAuth2.Models import AuthenticationResponse, BaseModel
@@ -25,6 +26,8 @@ if TYPE_CHECKING:
 
 MYCLOUD_LOGOFF_URL = "https://account.ultimaker.com/logoff?utm_source=cura&utm_medium=software&utm_campaign=change-account-before-adding-printers"
 
+REFRESH_TOKEN_MAX_RETRIES = 15
+REFRESH_TOKEN_RETRY_INTERVAL = 1000
 
 class AuthorizationService:
     """The authorization service is responsible for handling the login flow, storing user credentials and providing
@@ -57,6 +60,12 @@ class AuthorizationService:
 
         self.onAuthStateChanged.connect(self._authChanged)
 
+        self._refresh_token_retries = 0
+        self._refresh_token_retry_timer = QTimer()
+        self._refresh_token_retry_timer.setInterval(REFRESH_TOKEN_RETRY_INTERVAL)
+        self._refresh_token_retry_timer.setSingleShot(True)
+        self._refresh_token_retry_timer.timeout.connect(self.refreshAccessToken)
+
     def _authChanged(self, logged_in):
         if logged_in and self._unable_to_get_data_message is not None:
             self._unable_to_get_data_message.hide()
@@ -167,16 +176,29 @@ class AuthorizationService:
             return
 
         def process_auth_data(response: AuthenticationResponse) -> None:
+            self._currently_refreshing_token = False
+
             if response.success:
+                self._refresh_token_retries = 0
                 self._storeAuthData(response)
+                HttpRequestManager.getInstance().setDelayRequests(False)
                 self.onAuthStateChanged.emit(logged_in = True)
             else:
-                Logger.warning("Failed to get a new access token from the server.")
-                self.onAuthStateChanged.emit(logged_in = False)
+                if self._refresh_token_retries >= REFRESH_TOKEN_MAX_RETRIES:
+                    self._refresh_token_retries = 0
+                    Logger.warning("Failed to get a new access token from the server, giving up.")
+                    HttpRequestManager.getInstance().setDelayRequests(False)
+                    self.onAuthStateChanged.emit(logged_in = False)
+                else:
+                    # Retry a bit later, network may be offline right now and will hopefully be back soon
+                    Logger.warning("Failed to get a new access token from the server, retrying later.")
+                    self._refresh_token_retries += 1
+                    self._refresh_token_retry_timer.start()
 
         if self._currently_refreshing_token:
             Logger.debug("Was already busy refreshing token. Do not start a new request.")
             return
+        HttpRequestManager.getInstance().setDelayRequests(True)
         self._currently_refreshing_token = True
         self._auth_helpers.getAccessTokenUsingRefreshToken(self._auth_data.refresh_token, process_auth_data)
 

cura/OneAtATimeIterator.py

@@ -7,6 +7,11 @@ from UM.Scene.Iterator import Iterator
 from UM.Scene.SceneNode import SceneNode
 from functools import cmp_to_key
 
+from cura.HitChecker import HitChecker
+from cura.PrintOrderManager import PrintOrderManager
+from cura.Scene.CuraSceneNode import CuraSceneNode
+
+
 class OneAtATimeIterator(Iterator.Iterator):
     """Iterator that returns a list of nodes in the order that they need to be printed
 
@@ -16,8 +21,6 @@ class OneAtATimeIterator(Iterator.Iterator):
 
     def __init__(self, scene_node) -> None:
         super().__init__(scene_node) # Call super to make multiple inheritance work.
-        self._hit_map = [[]]  # type: List[List[bool]]  # For each node, which other nodes this hits. A grid of booleans on which nodes hit which.
-        self._original_node_list = []  # type: List[SceneNode]  # The nodes that need to be checked for collisions.
 
     def _fillStack(self) -> None:
         """Fills the ``_node_stack`` with a list of scene nodes that need to be printed in order. """
@@ -38,104 +41,50 @@ class OneAtATimeIterator(Iterator.Iterator):
             self._node_stack = node_list[:]
             return
 
-        # Copy the list
-        self._original_node_list = node_list[:]
+        hit_checker = HitChecker(node_list)
 
-        # Initialise the hit map (pre-compute all hits between all objects)
-        self._hit_map = [[self._checkHit(i, j) for i in node_list] for j in node_list]
+        if PrintOrderManager.isUserDefinedPrintOrderEnabled():
+            self._node_stack = self._getNodesOrderedByUser(hit_checker, node_list)
+        else:
+            self._node_stack = self._getNodesOrderedAutomatically(hit_checker, node_list)
 
-        # Check if we have to files that block each other. If this is the case, there is no solution!
-        for a in range(0, len(node_list)):
-            for b in range(0, len(node_list)):
-                if a != b and self._hit_map[a][b] and self._hit_map[b][a]:
-                    return
+            # update print orders so that user can try to arrange the nodes automatically first
+            # and if result is not satisfactory he/she can switch to manual mode and change it
+            for index, node in enumerate(self._node_stack):
+                node.printOrder = index + 1
+
+    @staticmethod
+    def _getNodesOrderedByUser(hit_checker: HitChecker, node_list: List[CuraSceneNode]) -> List[CuraSceneNode]:
+        nodes_ordered_by_user = sorted(node_list, key=lambda n: n.printOrder)
+        if hit_checker.canPrintNodesInProvidedOrder(nodes_ordered_by_user):
+            return nodes_ordered_by_user
+        return []  # No solution
+
+    @staticmethod
+    def _getNodesOrderedAutomatically(hit_checker: HitChecker, node_list: List[CuraSceneNode]) -> List[CuraSceneNode]:
+        # Check if we have two files that block each other. If this is the case, there is no solution!
+        if hit_checker.anyTwoNodesBlockEachOther(node_list):
+            return []  # No solution
 
         # Sort the original list so that items that block the most other objects are at the beginning.
         # This does not decrease the worst case running time, but should improve it in most cases.
-        sorted(node_list, key = cmp_to_key(self._calculateScore))
+        node_list = sorted(node_list, key = cmp_to_key(hit_checker.calculateScore))
 
         todo_node_list = [_ObjectOrder([], node_list)]
         while len(todo_node_list) > 0:
             current = todo_node_list.pop()
             for node in current.todo:
                 # Check if the object can be placed with what we have and still allows for a solution in the future
-                if not self._checkHitMultiple(node, current.order) and not self._checkBlockMultiple(node, current.todo):
+                if hit_checker.canPrintAfter(node, current.order) and hit_checker.canPrintBefore(node, current.todo):
                     # We found a possible result. Create new todo & order list.
                     new_todo_list = current.todo[:]
                     new_todo_list.remove(node)
                     new_order = current.order[:] + [node]
                     if len(new_todo_list) == 0:
                         # We have no more nodes to check, so quit looking.
-                        self._node_stack = new_order
-                        return
+                        return new_order # Solution found!
                     todo_node_list.append(_ObjectOrder(new_order, new_todo_list))
-        self._node_stack = [] #No result found!
-
-
-    #  Check if first object can be printed before the provided list (using the hit map)
-    def _checkHitMultiple(self, node: SceneNode, other_nodes: List[SceneNode]) -> bool:
-        node_index = self._original_node_list.index(node)
-        for other_node in other_nodes:
-            other_node_index = self._original_node_list.index(other_node)
-            if self._hit_map[node_index][other_node_index]:
-                return True
-        return False
-
-    def _checkBlockMultiple(self, node: SceneNode, other_nodes: List[SceneNode]) -> bool:
-        """Check for a node whether it hits any of the other nodes.
-
-        :param node: The node to check whether it collides with the other nodes.
-        :param other_nodes: The nodes to check for collisions.
-        :return: returns collision between nodes
-        """
-
-        node_index = self._original_node_list.index(node)
-        for other_node in other_nodes:
-            other_node_index = self._original_node_list.index(other_node)
-            if self._hit_map[other_node_index][node_index] and node_index != other_node_index:
-                return True
-        return False
-
-    def _calculateScore(self, a: SceneNode, b: SceneNode) -> int:
-        """Calculate score simply sums the number of other objects it 'blocks'
-
-        :param a: node
-        :param b: node
-        :return: sum of the number of other objects
-        """
-
-        score_a = sum(self._hit_map[self._original_node_list.index(a)])
-        score_b = sum(self._hit_map[self._original_node_list.index(b)])
-        return score_a - score_b
-
-    def _checkHit(self, a: SceneNode, b: SceneNode) -> bool:
-        """Checks if a can be printed before b
-
-        :param a: node
-        :param b: node
-        :return: true if a can be printed before b
-        """
-
-        if a == b:
-            return False
-
-        a_hit_hull = a.callDecoration("getConvexHullBoundary")
-        b_hit_hull = b.callDecoration("getConvexHullHeadFull")
-        overlap = a_hit_hull.intersectsPolygon(b_hit_hull)
-
-        if overlap:
-            return True
-
-        # Adhesion areas must never overlap, regardless of printing order
-        # This would cause over-extrusion
-        a_hit_hull = a.callDecoration("getAdhesionArea")
-        b_hit_hull = b.callDecoration("getAdhesionArea")
-        overlap = a_hit_hull.intersectsPolygon(b_hit_hull)
-
-        if overlap:
-            return True
-        else:
-            return False
+        return []  # No result found!
 
 
 class _ObjectOrder:

cura/PlatformPhysics.py

@@ -38,7 +38,14 @@ class PlatformPhysics:
         self._minimum_gap = 2  # It is a minimum distance (in mm) between two models, applicable for small models
 
         Application.getInstance().getPreferences().addPreference("physics/automatic_push_free", False)
-        Application.getInstance().getPreferences().addPreference("physics/automatic_drop_down", True)
+        Application.getInstance().getPreferences().addPreference("physics/automatic_drop_down", False)
+        self._app_per_model_drop = Application.getInstance().getPreferences().getValue("physics/automatic_drop_down")
+
+    def getAppPerModelDropDown(self):
+        return self._app_per_model_drop
+
+    def setAppPerModelDropDown(self, drop_to_buildplate):
+        self._app_per_model_drop = drop_to_buildplate
 
     def _onSceneChanged(self, source):
         if not source.callDecoration("isSliceable"):
@@ -71,6 +78,7 @@ class PlatformPhysics:
         # We try to shuffle all the nodes to prevent "locked" situations, where iteration B inverts iteration A.
         # By shuffling the order of the nodes, this might happen a few times, but at some point it will resolve.
         random.shuffle(nodes)
+
         for node in nodes:
             if node is root or not isinstance(node, SceneNode) or node.getBoundingBox() is None:
                 continue
@@ -80,7 +88,10 @@ class PlatformPhysics:
             # Move it downwards if bottom is above platform
             move_vector = Vector()
 
-            if node.getSetting(SceneNodeSettings.AutoDropDown, app_automatic_drop_down) and not (node.getParent() and node.getParent().callDecoration("isGroup") or node.getParent() != root) and node.isEnabled(): #If an object is grouped, don't move it down
+            # if per model drop is different then app_automatic_drop, in case of 3mf loading when user changes this setting for that model
+            if (self._app_per_model_drop != app_automatic_drop_down):
+                node.setSetting(SceneNodeSettings.AutoDropDown, self._app_per_model_drop)
+            if node.getSetting(SceneNodeSettings.AutoDropDown, self._app_per_model_drop) and not (node.getParent() and node.getParent().callDecoration("isGroup") or node.getParent() != root) and node.isEnabled(): #If an object is grouped, don't move it down
                 z_offset = node.callDecoration("getZOffset") if node.getDecorator(ZOffsetDecorator.ZOffsetDecorator) else 0
                 move_vector = move_vector.set(y = -bbox.bottom + z_offset)
 
@@ -168,6 +179,8 @@ class PlatformPhysics:
                 op = PlatformPhysicsOperation.PlatformPhysicsOperation(node, move_vector)
                 op.push()
 
+        # setting this drop to model same as app_automatic_drop_down
+        self._app_per_model_drop = app_automatic_drop_down
         # After moving, we have to evaluate the boundary checks for nodes
         build_volume.updateNodeBoundaryCheck()
 

cura/PrintOrderManager.py

@@ -0,0 +1,171 @@
+from typing import List, Callable, Optional, Any
+
+from PyQt6.QtCore import pyqtProperty, pyqtSignal, QObject, pyqtSlot
+from UM.Application import Application
+from UM.Scene.Selection import Selection
+
+from cura.Scene.CuraSceneNode import CuraSceneNode
+
+
+class PrintOrderManager(QObject):
+    """Allows to order the object list to set the print sequence manually"""
+
+    def __init__(self, get_nodes: Callable[[], List[CuraSceneNode]]) -> None:
+        super().__init__()
+        self._get_nodes = get_nodes
+        self._configureEvents()
+
+    _settingsChanged = pyqtSignal()
+    _uiActionsOutdated = pyqtSignal()
+    printOrderChanged = pyqtSignal()
+
+    @pyqtSlot()
+    def swapSelectedAndPreviousNodes(self) -> None:
+        selected_node, previous_node, next_node = self._getSelectedAndNeighborNodes()
+        self._swapPrintOrders(selected_node, previous_node)
+
+    @pyqtSlot()
+    def swapSelectedAndNextNodes(self) -> None:
+        selected_node, previous_node, next_node = self._getSelectedAndNeighborNodes()
+        self._swapPrintOrders(selected_node, next_node)
+
+    @pyqtProperty(str, notify=_uiActionsOutdated)
+    def previousNodeName(self) -> str:
+        selected_node, previous_node, next_node = self._getSelectedAndNeighborNodes()
+        return self._getNodeName(previous_node)
+
+    @pyqtProperty(str, notify=_uiActionsOutdated)
+    def nextNodeName(self) -> str:
+        selected_node, previous_node, next_node = self._getSelectedAndNeighborNodes()
+        return self._getNodeName(next_node)
+
+    @pyqtProperty(bool, notify=_uiActionsOutdated)
+    def shouldEnablePrintBeforeAction(self) -> bool:
+        selected_node, previous_node, next_node = self._getSelectedAndNeighborNodes()
+        can_swap_with_previous_node = selected_node is not None and previous_node is not None
+        return can_swap_with_previous_node
+
+    @pyqtProperty(bool, notify=_uiActionsOutdated)
+    def shouldEnablePrintAfterAction(self) -> bool:
+        selected_node, previous_node, next_node = self._getSelectedAndNeighborNodes()
+        can_swap_with_next_node = selected_node is not None and next_node is not None
+        return can_swap_with_next_node
+
+    @pyqtProperty(bool, notify=_settingsChanged)
+    def shouldShowEditPrintOrderActions(self) -> bool:
+        return PrintOrderManager.isUserDefinedPrintOrderEnabled()
+
+    @staticmethod
+    def isUserDefinedPrintOrderEnabled() -> bool:
+        stack = Application.getInstance().getGlobalContainerStack()
+        is_enabled = stack and \
+                     stack.getProperty("print_sequence", "value") == "one_at_a_time" and \
+                     stack.getProperty("user_defined_print_order_enabled", "value")
+        return bool(is_enabled)
+
+    @staticmethod
+    def initializePrintOrders(nodes: List[CuraSceneNode]) -> None:
+        """Just created (loaded from file) nodes have print order 0.
+
+         This method initializes print orders with max value to put nodes at the end of object list"""
+        max_print_order = max(map(lambda n: n.printOrder, nodes), default=0)
+        for node in nodes:
+            if node.printOrder == 0:
+                max_print_order += 1
+                node.printOrder = max_print_order
+
+    @staticmethod
+    def updatePrintOrdersAfterGroupOperation(
+            all_nodes: List[CuraSceneNode],
+            group_node: CuraSceneNode,
+            grouped_nodes: List[CuraSceneNode]
+    ) -> None:
+        group_node.printOrder = min(map(lambda n: n.printOrder, grouped_nodes))
+
+        all_nodes.append(group_node)
+        for node in grouped_nodes:
+            all_nodes.remove(node)
+
+        # reassign print orders so there won't be gaps like 1 2 5 6 7
+        sorted_nodes = sorted(all_nodes, key=lambda n: n.printOrder)
+        for i, node in enumerate(sorted_nodes):
+            node.printOrder = i + 1
+
+    @staticmethod
+    def updatePrintOrdersAfterUngroupOperation(
+            all_nodes: List[CuraSceneNode],
+            group_node: CuraSceneNode,
+            ungrouped_nodes: List[CuraSceneNode]
+    ) -> None:
+        all_nodes.remove(group_node)
+        nodes_to_update_print_order = filter(lambda n: n.printOrder > group_node.printOrder, all_nodes)
+        for node in nodes_to_update_print_order:
+            node.printOrder += len(ungrouped_nodes) - 1
+
+        for i, child in enumerate(ungrouped_nodes):
+            child.printOrder = group_node.printOrder + i
+            all_nodes.append(child)
+
+    def _swapPrintOrders(self, node1: CuraSceneNode, node2: CuraSceneNode) -> None:
+        if node1 and node2:
+            node1.printOrder, node2.printOrder = node2.printOrder, node1.printOrder  # swap print orders
+            self.printOrderChanged.emit()  # update object list first
+            self._uiActionsOutdated.emit()  # then update UI actions
+
+    def _getSelectedAndNeighborNodes(self
+                                     ) -> (Optional[CuraSceneNode], Optional[CuraSceneNode], Optional[CuraSceneNode]):
+        nodes = self._get_nodes()
+        ordered_nodes = sorted(nodes, key=lambda n: n.printOrder)
+        selected_node = PrintOrderManager._getSingleSelectedNode()
+        if selected_node and selected_node in ordered_nodes:
+            selected_node_index = ordered_nodes.index(selected_node)
+        else:
+            selected_node_index = None
+
+        if selected_node_index is not None and selected_node_index - 1 >= 0:
+            previous_node = ordered_nodes[selected_node_index - 1]
+        else:
+            previous_node = None
+
+        if selected_node_index is not None and selected_node_index + 1 < len(ordered_nodes):
+            next_node = ordered_nodes[selected_node_index + 1]
+        else:
+            next_node = None
+
+        return selected_node, previous_node, next_node
+
+    @staticmethod
+    def _getNodeName(node: CuraSceneNode, max_length: int = 30) -> str:
+        node_name = node.getName() if node else ""
+        truncated_node_name = node_name[:max_length]
+        return truncated_node_name
+
+    @staticmethod
+    def _getSingleSelectedNode() -> Optional[CuraSceneNode]:
+        if len(Selection.getAllSelectedObjects()) == 1:
+            selected_node = Selection.getSelectedObject(0)
+            return selected_node
+        return None
+
+    def _configureEvents(self) -> None:
+        Selection.selectionChanged.connect(self._onSelectionChanged)
+        self._global_stack = None
+        Application.getInstance().globalContainerStackChanged.connect(self._onGlobalStackChanged)
+        self._onGlobalStackChanged()
+
+    def _onGlobalStackChanged(self) -> None:
+        if self._global_stack:
+            self._global_stack.propertyChanged.disconnect(self._onSettingsChanged)
+            self._global_stack.containersChanged.disconnect(self._onSettingsChanged)
+
+        self._global_stack = Application.getInstance().getGlobalContainerStack()
+
+        if self._global_stack:
+            self._global_stack.propertyChanged.connect(self._onSettingsChanged)
+            self._global_stack.containersChanged.connect(self._onSettingsChanged)
+
+    def _onSettingsChanged(self, *args: Any) -> None:
+        self._settingsChanged.emit()
+
+    def _onSelectionChanged(self) -> None:
+        self._uiActionsOutdated.emit()

cura/Scene/CuraSceneNode.py

@@ -25,10 +25,19 @@ class CuraSceneNode(SceneNode):
         if not no_setting_override:
             self.addDecorator(SettingOverrideDecorator())  # Now we always have a getActiveExtruderPosition, unless explicitly disabled
         self._outside_buildarea = False
+        self._print_order = 0
 
     def setOutsideBuildArea(self, new_value: bool) -> None:
         self._outside_buildarea = new_value
 
+    @property
+    def printOrder(self):
+        return self._print_order
+
+    @printOrder.setter
+    def printOrder(self, new_value):
+        self._print_order = new_value
+
     def isOutsideBuildArea(self) -> bool:
         return self._outside_buildarea or self.callDecoration("getBuildPlateNumber") < 0
 
@@ -157,3 +166,6 @@ class CuraSceneNode(SceneNode):
 
     def transformChanged(self) -> None:
         self._transformChanged()
+
+    def __repr__(self) -> str:
+        return "{print_order}. {name}".format(print_order = self._print_order, name = self.getName())

cura/Settings/ExtruderManager.py

@@ -316,7 +316,13 @@ class ExtruderManager(QObject):
         # Starts with the adhesion extruder.
         adhesion_type = global_stack.getProperty("adhesion_type", "value")
         if adhesion_type in {"skirt", "brim"}:
-            return max(0, int(global_stack.getProperty("skirt_brim_extruder_nr", "value")))  # optional skirt/brim extruder defaults to zero
+            skirt_brim_extruder_nr = global_stack.getProperty("skirt_brim_extruder_nr", "value")
+            # if the skirt_brim_extruder_nr is -1, then we use the first used extruder
+            if skirt_brim_extruder_nr == -1:
+                used_extruders = self.getUsedExtruderStacks()
+                return used_extruders[0].position
+            else:
+                return skirt_brim_extruder_nr
         if adhesion_type == "raft":
             return global_stack.getProperty("raft_base_extruder_nr", "value")
 

cura/SingleInstance.py

@@ -5,16 +5,18 @@ import json
 import os
 from typing import List, Optional
 
+from PyQt6.QtCore import QUrl
 from PyQt6.QtNetwork import QLocalServer, QLocalSocket
 
-from UM.Qt.QtApplication import QtApplication #For typing.
+from UM.Qt.QtApplication import QtApplication  # For typing.
 from UM.Logger import Logger
 
 
 class SingleInstance:
-    def __init__(self, application: QtApplication, files_to_open: Optional[List[str]]) -> None:
+    def __init__(self, application: QtApplication, files_to_open: Optional[List[str]], url_to_open: Optional[List[str]]) -> None:
         self._application = application
         self._files_to_open = files_to_open
+        self._url_to_open = url_to_open
 
         self._single_instance_server = None
 
@@ -33,7 +35,7 @@ class SingleInstance:
             return False
 
         # We only send the files that need to be opened.
-        if not self._files_to_open:
+        if not self._files_to_open and not self._url_to_open:
             Logger.log("i", "No file need to be opened, do nothing.")
             return True
 
@@ -55,8 +57,12 @@ class SingleInstance:
                 payload = {"command": "open", "filePath": os.path.abspath(filename)}
                 single_instance_socket.write(bytes(json.dumps(payload) + "\n", encoding = "ascii"))
 
+            for url in self._url_to_open:
+                payload = {"command": "open-url", "urlPath": url.toString()}
+                single_instance_socket.write(bytes(json.dumps(payload) + "\n", encoding="ascii"))
+
             payload = {"command": "close-connection"}
-            single_instance_socket.write(bytes(json.dumps(payload) + "\n", encoding = "ascii"))
+            single_instance_socket.write(bytes(json.dumps(payload) + "\n", encoding="ascii"))
 
             single_instance_socket.flush()
             single_instance_socket.waitForDisconnected()
@@ -72,7 +78,7 @@ class SingleInstance:
 
     def _onClientConnected(self) -> None:
         Logger.log("i", "New connection received on our single-instance server")
-        connection = None #type: Optional[QLocalSocket]
+        connection = None  # type: Optional[QLocalSocket]
         if self._single_instance_server:
             connection = self._single_instance_server.nextPendingConnection()
 
@@ -81,7 +87,7 @@ class SingleInstance:
 
     def __readCommands(self, connection: QLocalSocket) -> None:
         line = connection.readLine()
-        while len(line) != 0:    # There is also a .canReadLine()
+        while len(line) != 0:  # There is also a .canReadLine()
             try:
                 payload = json.loads(str(line, encoding = "ascii").strip())
                 command = payload["command"]
@@ -94,13 +100,19 @@ class SingleInstance:
                 elif command == "open":
                     self._application.callLater(lambda f = payload["filePath"]: self._application._openFile(f))
 
+                #command: Load a url link in Cura
+                elif command == "open-url":
+                    url = QUrl(payload["urlPath"])
+                    self._application.callLater(lambda: self._application._openUrl(url))
+
+
                 # Command: Activate the window and bring it to the top.
                 elif command == "focus":
                     # Operating systems these days prevent windows from moving around by themselves.
                     # 'alert' or flashing the icon in the taskbar is the best thing we do now.
                     main_window = self._application.getMainWindow()
                     if main_window is not None:
-                        self._application.callLater(lambda: main_window.alert(0)) # type: ignore # I don't know why MyPy complains here
+                        self._application.callLater(lambda: main_window.alert(0))  # type: ignore # I don't know why MyPy complains here
 
                 # Command: Close the socket connection. We're done.
                 elif command == "close-connection":

cura/UI/ObjectsModel.py

@@ -14,6 +14,9 @@ from UM.Scene.SceneNode import SceneNode
 from UM.Scene.Selection import Selection
 from UM.i18n import i18nCatalog
 
+from cura.PrintOrderManager import PrintOrderManager
+from cura.Scene.CuraSceneNode import CuraSceneNode
+
 catalog = i18nCatalog("cura")
 
 
@@ -76,6 +79,9 @@ class ObjectsModel(ListModel):
             self._build_plate_number = nr
             self._update()
 
+    def getNodes(self) -> List[CuraSceneNode]:
+        return list(map(lambda n: n["node"], self.items))
+
     def _updateSceneDelayed(self, source) -> None:
         if not isinstance(source, Camera):
             self._update_timer.start()
@@ -175,6 +181,10 @@ class ObjectsModel(ListModel):
 
         all_nodes = self._renameNodes(name_to_node_info_dict)
 
+        user_defined_print_order_enabled = PrintOrderManager.isUserDefinedPrintOrderEnabled()
+        if user_defined_print_order_enabled:
+            PrintOrderManager.initializePrintOrders(all_nodes)
+
         for node in all_nodes:
             if hasattr(node, "isOutsideBuildArea"):
                 is_outside_build_area = node.isOutsideBuildArea()  # type: ignore
@@ -223,8 +233,13 @@ class ObjectsModel(ListModel):
                 # for anti overhang meshes and groups the extruder nr is irrelevant
                 extruder_number = -1
 
+            if not user_defined_print_order_enabled:
+                name = node.getName()
+            else:
+                name = "{print_order}. {name}".format(print_order = node.printOrder, name = node.getName())
+
             nodes.append({
-                "name": node.getName(),
+                "name": name,
                 "selected": Selection.isSelected(node),
                 "outside_build_area": is_outside_build_area,
                 "buildplate_number": node_build_plate_number,
@@ -234,5 +249,5 @@ class ObjectsModel(ListModel):
                 "node": node
             })
 
-        nodes = sorted(nodes, key=lambda n: n["name"])
+        nodes = sorted(nodes, key=lambda n: n["name"] if not user_defined_print_order_enabled else n["node"].printOrder)
         self.setItems(nodes)