Merge branch 'Ultimaker-master'

.gitignore

@@ -56,6 +56,11 @@ plugins/SettingsGuide
 plugins/SettingsGuide2
 plugins/SVGToolpathReader
 plugins/X3GWriter
+plugins/CuraFlatPack
+plugins/CuraRemoteSupport
+plugins/ModelCutter
+plugins/PrintProfileCreator
+plugins/MultiPrintPlugin
 
 #Build stuff
 CMakeCache.txt

CITATION.cff

@@ -7,5 +7,5 @@ license: "LGPL-3.0"
 message: "If you use this software, please cite it using these metadata."
 repository-code: "https://github.com/ultimaker/cura/"
 title: "Ultimaker Cura"
-version: "4.10.0"
+version: "4.12.0"
-...
+...

README.md

@@ -2,7 +2,7 @@ Cura
 ====
 Ultimaker Cura is a state-of-the-art slicer application to prepare your 3D models for printing with a 3D printer. With hundreds of settings and hundreds of community-managed print profiles, Ultimaker Cura is sure to lead your next project to a success.
 
-![Screenshot](screenshot.png)
+![Screenshot](cura-logo.PNG)
 
 Logging Issues
 ------------

cura/API/Account.py

@@ -1,15 +1,15 @@
-# Copyright (c) 2018 Ultimaker B.V.
+# Copyright (c) 2021 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
-from datetime import datetime
-from typing import Any, Optional, Dict, TYPE_CHECKING, Callable
 
+from datetime import datetime
 from PyQt5.QtCore import QObject, pyqtSignal, pyqtSlot, pyqtProperty, QTimer, Q_ENUMS
+from typing import Any, Optional, Dict, TYPE_CHECKING, Callable
 
 from UM.Logger import Logger
 from UM.Message import Message
 from UM.i18n import i18nCatalog
 from cura.OAuth2.AuthorizationService import AuthorizationService
-from cura.OAuth2.Models import OAuth2Settings
+from cura.OAuth2.Models import OAuth2Settings, UserProfile
 from cura.UltimakerCloud import UltimakerCloudConstants
 
 if TYPE_CHECKING:
@@ -46,6 +46,9 @@ class Account(QObject):
     loginStateChanged = pyqtSignal(bool)
     """Signal emitted when user logged in or out"""
 
+    userProfileChanged = pyqtSignal()
+    """Signal emitted when new account information is available."""
+
     additionalRightsChanged = pyqtSignal("QVariantMap")
     """Signal emitted when a users additional rights change"""
 
@@ -62,7 +65,7 @@ class Account(QObject):
     updatePackagesEnabledChanged = pyqtSignal(bool)
 
     CLIENT_SCOPES = "account.user.read drive.backup.read drive.backup.write packages.download " \
-                    "packages.rating.read packages.rating.write connect.cluster.read connect.cluster.write " \
+                    "packages.rating.read packages.rating.write connect.cluster.read connect.cluster.write connect.material.write " \
                     "library.project.read library.project.write cura.printjob.read cura.printjob.write " \
                     "cura.mesh.read cura.mesh.write"
 
@@ -71,13 +74,14 @@ class Account(QObject):
         self._application = application
         self._new_cloud_printers_detected = False
 
-        self._error_message = None  # type: Optional[Message]
+        self._error_message: Optional[Message] = None
         self._logged_in = False
+        self._user_profile: Optional[UserProfile] = None
         self._additional_rights: Dict[str, Any] = {}
         self._sync_state = SyncState.IDLE
         self._manual_sync_enabled = False
         self._update_packages_enabled = False
-        self._update_packages_action = None  # type: Optional[Callable]
+        self._update_packages_action: Optional[Callable] = None
         self._last_sync_str = "-"
 
         self._callback_port = 32118
@@ -103,7 +107,7 @@ class Account(QObject):
         self._update_timer.setSingleShot(True)
         self._update_timer.timeout.connect(self.sync)
 
-        self._sync_services = {}  # type: Dict[str, int]
+        self._sync_services: Dict[str, int] = {}
         """contains entries "service_name" : SyncState"""
 
     def initialize(self) -> None:
@@ -196,12 +200,17 @@ class Account(QObject):
             self._logged_in = logged_in
             self.loginStateChanged.emit(logged_in)
             if logged_in:
+                self._authorization_service.getUserProfile(self._onProfileChanged)
                 self._setManualSyncEnabled(False)
                 self._sync()
             else:
                 if self._update_timer.isActive():
                     self._update_timer.stop()
 
+    def _onProfileChanged(self, profile: Optional[UserProfile]) -> None:
+        self._user_profile = profile
+        self.userProfileChanged.emit()
+
     def _sync(self) -> None:
         """Signals all sync services to start syncing
 
@@ -243,32 +252,28 @@ class Account(QObject):
                 return
         self._authorization_service.startAuthorizationFlow(force_logout_before_login)
 
-    @pyqtProperty(str, notify=loginStateChanged)
+    @pyqtProperty(str, notify = userProfileChanged)
     def userName(self):
-        user_profile = self._authorization_service.getUserProfile()
+        if not self._user_profile:
-        if not user_profile:
+            return ""
-            return None
+        return self._user_profile.username
-        return user_profile.username
 
-    @pyqtProperty(str, notify = loginStateChanged)
+    @pyqtProperty(str, notify = userProfileChanged)
     def profileImageUrl(self):
-        user_profile = self._authorization_service.getUserProfile()
+        if not self._user_profile:
-        if not user_profile:
+            return ""
-            return None
+        return self._user_profile.profile_image_url
-        return user_profile.profile_image_url
 
     @pyqtProperty(str, notify=accessTokenChanged)
     def accessToken(self) -> Optional[str]:
         return self._authorization_service.getAccessToken()
 
-    @pyqtProperty("QVariantMap", notify = loginStateChanged)
+    @pyqtProperty("QVariantMap", notify = userProfileChanged)
     def userProfile(self) -> Optional[Dict[str, Optional[str]]]:
         """None if no user is logged in otherwise the logged in  user as a dict containing containing user_id, username and profile_image_url """
-
+        if not self._user_profile:
-        user_profile = self._authorization_service.getUserProfile()
-        if not user_profile:
             return None
-        return user_profile.__dict__
+        return self._user_profile.__dict__
 
     @pyqtProperty(str, notify=lastSyncDateTimeChanged)
     def lastSyncDateTime(self) -> str:

cura/ApplicationMetadata.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2020 Ultimaker B.V.
+# Copyright (c) 2021 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
 # ---------
@@ -13,7 +13,7 @@ DEFAULT_CURA_DEBUG_MODE = False
 # Each release has a fixed SDK version coupled with it. It doesn't make sense to make it configurable because, for
 # example Cura 3.2 with SDK version 6.1 will not work. So the SDK version is hard-coded here and left out of the
 # CuraVersion.py.in template.
-CuraSDKVersion = "7.8.0"
+CuraSDKVersion = "7.9.0"
 
 try:
     from cura.CuraVersion import CuraAppName  # type: ignore
@@ -46,6 +46,10 @@ except ImportError:
 # Various convenience flags indicating what kind of Cura build it is.
 __ENTERPRISE_VERSION_TYPE = "enterprise"
 IsEnterpriseVersion = CuraBuildType.lower() == __ENTERPRISE_VERSION_TYPE
+IsAlternateVersion = CuraBuildType.lower() not in [DEFAULT_CURA_BUILD_TYPE, __ENTERPRISE_VERSION_TYPE]
+# NOTE: IsAlternateVersion is to make it possibile to have 'non-numbered' versions, at least as presented to the user.
+#       (Internally, it'll still have some sort of version-number, but the user is never meant to see it in the GUI).
+#       Warning: This will also change (some of) the icons/splash-screen to the 'work in progress' alternatives!
 
 try:
     from cura.CuraVersion import CuraAppDisplayName  # type: ignore

cura/Arranging/Nest2DArrange.py

@@ -91,7 +91,7 @@ def findNodePlacement(nodes_to_arrange: List["SceneNode"], build_volume: "BuildV
 
         if hull_polygon is not None and hull_polygon.getPoints() is not None and len(hull_polygon.getPoints()) > 2:  # numpy array has to be explicitly checked against None
             for point in hull_polygon.getPoints():
-                converted_points.append(Point(point[0] * factor, point[1] * factor))
+                converted_points.append(Point(int(point[0] * factor), int(point[1] * factor)))
             item = Item(converted_points)
             item.markAsFixedInBin(0)
             node_items.append(item)
@@ -159,4 +159,4 @@ def arrange(nodes_to_arrange: List["SceneNode"],
 
     grouped_operation, not_fit_count = createGroupOperationForArrange(nodes_to_arrange, build_volume, fixed_nodes, factor, add_new_nodes_in_scene)
     grouped_operation.push()
-    return not_fit_count != 0
+    return not_fit_count == 0

cura/Backups/Backup.py

@@ -181,8 +181,7 @@ class Backup:
 
         return extracted
 
-    @staticmethod
+    def _extractArchive(self, archive: "ZipFile", target_path: str) -> bool:
-    def _extractArchive(archive: "ZipFile", target_path: str) -> bool:
         """Extract the whole archive to the given target path.
 
         :param archive: The archive as ZipFile.
@@ -201,7 +200,11 @@ class Backup:
         Resources.factoryReset()
         Logger.log("d", "Extracting backup to location: %s", target_path)
         name_list = archive.namelist()
+        ignore_string = re.compile("|".join(self.IGNORED_FILES + self.IGNORED_FOLDERS))
         for archive_filename in name_list:
+            if ignore_string.search(archive_filename):
+                Logger.warning(f"File ({archive_filename}) in archive that doesn't fit current backup policy; ignored.")
+                continue
             try:
                 archive.extract(archive_filename, target_path)
             except (PermissionError, EnvironmentError):

cura/BuildVolume.py

@@ -6,6 +6,7 @@ import math
 
 from typing import List, Optional, TYPE_CHECKING, Any, Set, cast, Iterable, Dict
 
+from UM.Logger import Logger
 from UM.Mesh.MeshData import MeshData
 from UM.Mesh.MeshBuilder import MeshBuilder
 
@@ -65,6 +66,7 @@ class BuildVolume(SceneNode):
         self._height = 0  # type: float
         self._depth = 0  # type: float
         self._shape = ""  # type: str
+        self._scale_vector = Vector(1.0, 1.0, 1.0)
 
         self._shader = None
 
@@ -289,7 +291,7 @@ class BuildVolume(SceneNode):
                 # Mark the node as outside build volume if the set extruder is disabled
                 extruder_position = node.callDecoration("getActiveExtruderPosition")
                 try:
-                    if not self._global_container_stack.extruderList[int(extruder_position)].isEnabled:
+                    if not self._global_container_stack.extruderList[int(extruder_position)].isEnabled and not node.callDecoration("isGroup"):
                         node.setOutsideBuildArea(True)
                         continue
                 except IndexError:  # Happens when the extruder list is too short. We're not done building the printer in memory yet.
@@ -512,6 +514,13 @@ class BuildVolume(SceneNode):
             self._disallowed_area_size = max(size, self._disallowed_area_size)
         return mb.build()
 
+    def _updateScaleFactor(self) -> None:
+        if not self._global_container_stack:
+            return
+        scale_xy = 100.0 / max(100.0, self._global_container_stack.getProperty("material_shrinkage_percentage_xy", "value"))
+        scale_z  = 100.0 / max(100.0, self._global_container_stack.getProperty("material_shrinkage_percentage_z" , "value"))
+        self._scale_vector = Vector(scale_xy, scale_xy, scale_z)
+
     def rebuild(self) -> None:
         """Recalculates the build volume & disallowed areas."""
 
@@ -553,9 +562,12 @@ class BuildVolume(SceneNode):
 
         self._error_mesh = self._buildErrorMesh(min_w, max_w, min_h, max_h, min_d, max_d, disallowed_area_height)
 
+        self._updateScaleFactor()
+
         self._volume_aabb = AxisAlignedBox(
-            minimum = Vector(min_w, min_h - 1.0, min_d),
+            minimum = Vector(min_w, min_h - 1.0, min_d).scale(self._scale_vector),
-            maximum = Vector(max_w, max_h - self._raft_thickness - self._extra_z_clearance, max_d))
+            maximum = Vector(max_w, max_h - self._raft_thickness - self._extra_z_clearance, max_d).scale(self._scale_vector)
+        )
 
         bed_adhesion_size = self.getEdgeDisallowedSize()
 
@@ -563,15 +575,15 @@ class BuildVolume(SceneNode):
         # This is probably wrong in all other cases. TODO!
         # The +1 and -1 is added as there is always a bit of extra room required to work properly.
         scale_to_max_bounds = AxisAlignedBox(
-            minimum = Vector(min_w + bed_adhesion_size + 1, min_h, min_d + self._disallowed_area_size - bed_adhesion_size + 1),
+            minimum = Vector(min_w + bed_adhesion_size + 1, min_h, min_d + self._disallowed_area_size - bed_adhesion_size + 1).scale(self._scale_vector),
-            maximum = Vector(max_w - bed_adhesion_size - 1, max_h - self._raft_thickness - self._extra_z_clearance, max_d - self._disallowed_area_size + bed_adhesion_size - 1)
+            maximum = Vector(max_w - bed_adhesion_size - 1, max_h - self._raft_thickness - self._extra_z_clearance, max_d - self._disallowed_area_size + bed_adhesion_size - 1).scale(self._scale_vector)
         )
 
         self._application.getController().getScene()._maximum_bounds = scale_to_max_bounds  # type: ignore
 
         self.updateNodeBoundaryCheck()
 
-    def getBoundingBox(self):
+    def getBoundingBox(self) -> Optional[AxisAlignedBox]:
         return self._volume_aabb
 
     def getRaftThickness(self) -> float:
@@ -632,18 +644,18 @@ class BuildVolume(SceneNode):
             for extruder in extruders:
                 extruder.propertyChanged.connect(self._onSettingPropertyChanged)
 
-            self._width = self._global_container_stack.getProperty("machine_width", "value")
+            self._width = self._global_container_stack.getProperty("machine_width", "value") * self._scale_vector.x
             machine_height = self._global_container_stack.getProperty("machine_height", "value")
             if self._global_container_stack.getProperty("print_sequence", "value") == "one_at_a_time" and len(self._scene_objects) > 1:
-                self._height = min(self._global_container_stack.getProperty("gantry_height", "value"), machine_height)
+                self._height = min(self._global_container_stack.getProperty("gantry_height", "value") * self._scale_vector.z, machine_height)
-                if self._height < machine_height:
+                if self._height < (machine_height * self._scale_vector.z):
                     self._build_volume_message.show()
                 else:
                     self._build_volume_message.hide()
             else:
                 self._height = self._global_container_stack.getProperty("machine_height", "value")
                 self._build_volume_message.hide()
-            self._depth = self._global_container_stack.getProperty("machine_depth", "value")
+            self._depth = self._global_container_stack.getProperty("machine_depth", "value") * self._scale_vector.y
             self._shape = self._global_container_stack.getProperty("machine_shape", "value")
 
             self._updateDisallowedAreas()
@@ -677,18 +689,18 @@ class BuildVolume(SceneNode):
             if setting_key == "print_sequence":
                 machine_height = self._global_container_stack.getProperty("machine_height", "value")
                 if self._application.getGlobalContainerStack().getProperty("print_sequence", "value") == "one_at_a_time" and len(self._scene_objects) > 1:
-                    self._height = min(self._global_container_stack.getProperty("gantry_height", "value"), machine_height)
+                    self._height = min(self._global_container_stack.getProperty("gantry_height", "value") * self._scale_vector.z, machine_height)
-                    if self._height < machine_height:
+                    if self._height < (machine_height * self._scale_vector.z):
                         self._build_volume_message.show()
                     else:
                         self._build_volume_message.hide()
                 else:
-                    self._height = self._global_container_stack.getProperty("machine_height", "value")
+                    self._height = self._global_container_stack.getProperty("machine_height", "value") * self._scale_vector.z
                     self._build_volume_message.hide()
                 update_disallowed_areas = True
 
             # sometimes the machine size or shape settings are adjusted on the active machine, we should reflect this
-            if setting_key in self._machine_settings:
+            if setting_key in self._machine_settings or setting_key in self._material_size_settings:
                 self._updateMachineSizeProperties()
                 update_extra_z_clearance = True
                 update_disallowed_areas = True
@@ -737,9 +749,10 @@ class BuildVolume(SceneNode):
     def _updateMachineSizeProperties(self) -> None:
         if not self._global_container_stack:
             return
-        self._height = self._global_container_stack.getProperty("machine_height", "value")
+        self._updateScaleFactor()
-        self._width = self._global_container_stack.getProperty("machine_width", "value")
+        self._height = self._global_container_stack.getProperty("machine_height", "value") * self._scale_vector.z
-        self._depth = self._global_container_stack.getProperty("machine_depth", "value")
+        self._width = self._global_container_stack.getProperty("machine_width", "value") * self._scale_vector.x
+        self._depth = self._global_container_stack.getProperty("machine_depth", "value") * self._scale_vector.y
         self._shape = self._global_container_stack.getProperty("machine_shape", "value")
 
     def _updateDisallowedAreasAndRebuild(self):
@@ -756,6 +769,14 @@ class BuildVolume(SceneNode):
         self._extra_z_clearance = self._calculateExtraZClearance(ExtruderManager.getInstance().getUsedExtruderStacks())
         self.rebuild()
 
+    def _scaleAreas(self, result_areas: List[Polygon]) -> None:
+        if self._global_container_stack is None:
+            return
+        for i, polygon in enumerate(result_areas):
+            result_areas[i] = polygon.scale(
+                100.0 / max(100.0, self._global_container_stack.getProperty("material_shrinkage_percentage_xy", "value"))
+            )
+
     def _updateDisallowedAreas(self) -> None:
         if not self._global_container_stack:
             return
@@ -811,9 +832,11 @@ class BuildVolume(SceneNode):
 
         self._disallowed_areas = []
         for extruder_id in result_areas:
+            self._scaleAreas(result_areas[extruder_id])
             self._disallowed_areas.extend(result_areas[extruder_id])
         self._disallowed_areas_no_brim = []
         for extruder_id in result_areas_no_brim:
+            self._scaleAreas(result_areas_no_brim[extruder_id])
             self._disallowed_areas_no_brim.extend(result_areas_no_brim[extruder_id])
 
     def _computeDisallowedAreasPrinted(self, used_extruders):
@@ -1078,7 +1101,11 @@ class BuildVolume(SceneNode):
         # setting does *not* have a limit_to_extruder setting (which means that we can't ask the global extruder what
         # the value is.
         adhesion_extruder = self._global_container_stack.getProperty("adhesion_extruder_nr", "value")
-        adhesion_stack = self._global_container_stack.extruderList[int(adhesion_extruder)]
+        try:
+            adhesion_stack = self._global_container_stack.extruderList[int(adhesion_extruder)]
+        except IndexError:
+            Logger.warning(f"Couldn't find extruder with index '{adhesion_extruder}', defaulting to 0 instead.")
+            adhesion_stack = self._global_container_stack.extruderList[0]
         skirt_brim_line_width = adhesion_stack.getProperty("skirt_brim_line_width", "value")
 
         initial_layer_line_width_factor = adhesion_stack.getProperty("initial_layer_line_width_factor", "value")
@@ -1195,4 +1222,5 @@ class BuildVolume(SceneNode):
     _distance_settings = ["infill_wipe_dist", "travel_avoid_distance", "support_offset", "support_enable", "travel_avoid_other_parts", "travel_avoid_supports", "wall_line_count", "wall_line_width_0", "wall_line_width_x"]
     _extruder_settings = ["support_enable", "support_bottom_enable", "support_roof_enable", "support_infill_extruder_nr", "support_extruder_nr_layer_0", "support_bottom_extruder_nr", "support_roof_extruder_nr", "brim_line_count", "adhesion_extruder_nr", "adhesion_type"] #Settings that can affect which extruders are used.
     _limit_to_extruder_settings = ["wall_extruder_nr", "wall_0_extruder_nr", "wall_x_extruder_nr", "top_bottom_extruder_nr", "infill_extruder_nr", "support_infill_extruder_nr", "support_extruder_nr_layer_0", "support_bottom_extruder_nr", "support_roof_extruder_nr", "adhesion_extruder_nr"]
-    _disallowed_area_settings = _skirt_settings + _prime_settings + _tower_settings + _ooze_shield_settings + _distance_settings + _extruder_settings
+    _material_size_settings = ["material_shrinkage_percentage", "material_shrinkage_percentage_xy", "material_shrinkage_percentage_z"]
+    _disallowed_area_settings = _skirt_settings + _prime_settings + _tower_settings + _ooze_shield_settings + _distance_settings + _extruder_settings + _material_size_settings

cura/CrashHandler.py

@@ -12,10 +12,12 @@ import json
 import locale
 from typing import cast, Any
 
+import sentry_sdk
+
 try:
     from sentry_sdk.hub import Hub
     from sentry_sdk.utils import event_from_exception
-    from sentry_sdk import configure_scope
+    from sentry_sdk import configure_scope, add_breadcrumb
     with_sentry_sdk = True
 except ImportError:
     with_sentry_sdk = False
@@ -424,6 +426,13 @@ class CrashHandler:
         if with_sentry_sdk:
             try:
                 hub = Hub.current
+                if not Logger.getLoggers():
+                    # No loggers have been loaded yet, so we don't have any breadcrumbs :(
+                    # So add them manually so we at least have some info...
+                    add_breadcrumb(level = "info", message = "SentryLogging was not initialised yet")
+                    for log_type, line in Logger.getUnloggedLines():
+                        add_breadcrumb(message=line)
+
                 event, hint = event_from_exception((self.exception_type, self.value, self.traceback))
                 hub.capture_event(event, hint=hint)
                 hub.flush()

cura/CuraApplication.py

@@ -152,16 +152,17 @@ class CuraApplication(QtApplication):
     def __init__(self, *args, **kwargs):
         super().__init__(name = ApplicationMetadata.CuraAppName,
                          app_display_name = ApplicationMetadata.CuraAppDisplayName,
-                         version = ApplicationMetadata.CuraVersion,
+                         version = ApplicationMetadata.CuraVersion if not ApplicationMetadata.IsAlternateVersion else ApplicationMetadata.CuraBuildType,
                          api_version = ApplicationMetadata.CuraSDKVersion,
                          build_type = ApplicationMetadata.CuraBuildType,
                          is_debug_mode = ApplicationMetadata.CuraDebugMode,
-                         tray_icon_name = "cura-icon-32.png",
+                         tray_icon_name = "cura-icon-32.png" if not ApplicationMetadata.IsAlternateVersion else "cura-icon-32_wip.png",
                          **kwargs)
 
         self.default_theme = "cura-light"
 
         self.change_log_url = "https://ultimaker.com/ultimaker-cura-latest-features?utm_source=cura&utm_medium=software&utm_campaign=cura-update-features"
+        self.beta_change_log_url = "https://ultimaker.com/ultimaker-cura-beta-features?utm_source=cura&utm_medium=software&utm_campaign=cura-update-features"
 
         self._boot_loading_time = time.time()
 
@@ -483,7 +484,7 @@ class CuraApplication(QtApplication):
 
         if not self.getIsHeadLess():
             try:
-                self.setWindowIcon(QIcon(Resources.getPath(Resources.Images, "cura-icon.png")))
+                self.setWindowIcon(QIcon(Resources.getPath(Resources.Images, "cura-icon.png" if not ApplicationMetadata.IsAlternateVersion else "cura-icon_wip.png")))
             except FileNotFoundError:
                 Logger.log("w", "Unable to find the window icon.")
 
@@ -716,6 +717,7 @@ class CuraApplication(QtApplication):
             for extruder in global_stack.extruderList:
                 extruder.userChanges.clear()
             global_stack.userChanges.clear()
+            self.getMachineManager().correctExtruderSettings()
 
         # if the user decided to keep settings then the user settings should be re-calculated and validated for errors
         # before slicing. To ensure that slicer uses right settings values
@@ -775,10 +777,14 @@ class CuraApplication(QtApplication):
             lib_suffixes = {""}
         for suffix in lib_suffixes:
             self._plugin_registry.addPluginLocation(os.path.join(QtApplication.getInstallPrefix(), "lib" + suffix, "cura"))
+
         if not hasattr(sys, "frozen"):
             self._plugin_registry.addPluginLocation(os.path.join(os.path.abspath(os.path.dirname(__file__)), "..", "plugins"))
             self._plugin_registry.preloaded_plugins.append("ConsoleLogger")
 
+        # Since it's possible to get crashes in code before the sentrylogger is loaded, we want to start this plugin
+        # as quickly as possible, as we might get unsolvable crash reports without it.
+        self._plugin_registry.preloaded_plugins.append("SentryLogger")
         self._plugin_registry.loadPlugins()
 
         if self.getBackend() is None:

cura/Machines/Models/GlobalStacksModel.py

@@ -1,7 +1,8 @@
-# Copyright (c) 2018 Ultimaker B.V.
+# Copyright (c) 2021 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
-from PyQt5.QtCore import Qt, QTimer
+from PyQt5.QtCore import Qt, QTimer, pyqtProperty, pyqtSignal
+from typing import List, Optional
 
 from UM.Qt.ListModel import ListModel
 from UM.i18n import i18nCatalog
@@ -10,6 +11,7 @@ from UM.Util import parseBool
 from cura.PrinterOutput.PrinterOutputDevice import ConnectionType
 from cura.Settings.CuraContainerRegistry import CuraContainerRegistry
 from cura.Settings.GlobalStack import GlobalStack
+from cura.UltimakerCloud.UltimakerCloudConstants import META_CAPABILITIES  # To filter on the printer's capabilities.
 
 
 class GlobalStacksModel(ListModel):
@@ -20,6 +22,7 @@ class GlobalStacksModel(ListModel):
     MetaDataRole = Qt.UserRole + 5
     DiscoverySourceRole = Qt.UserRole + 6  # For separating local and remote printers in the machine management page
     RemovalWarningRole = Qt.UserRole + 7
+    IsOnlineRole = Qt.UserRole + 8
 
     def __init__(self, parent = None) -> None:
         super().__init__(parent)
@@ -31,18 +34,70 @@ class GlobalStacksModel(ListModel):
         self.addRoleName(self.HasRemoteConnectionRole, "hasRemoteConnection")
         self.addRoleName(self.MetaDataRole, "metadata")
         self.addRoleName(self.DiscoverySourceRole, "discoverySource")
+        self.addRoleName(self.IsOnlineRole, "isOnline")
 
         self._change_timer = QTimer()
         self._change_timer.setInterval(200)
         self._change_timer.setSingleShot(True)
         self._change_timer.timeout.connect(self._update)
 
+        self._filter_connection_type = None  # type: Optional[ConnectionType]
+        self._filter_online_only = False
+        self._filter_capabilities: List[str] = []  # Required capabilities that all listed printers must have.
+
         # Listen to changes
         CuraContainerRegistry.getInstance().containerAdded.connect(self._onContainerChanged)
         CuraContainerRegistry.getInstance().containerMetaDataChanged.connect(self._onContainerChanged)
         CuraContainerRegistry.getInstance().containerRemoved.connect(self._onContainerChanged)
         self._updateDelayed()
 
+    filterConnectionTypeChanged = pyqtSignal()
+    filterCapabilitiesChanged = pyqtSignal()
+    filterOnlineOnlyChanged = pyqtSignal()
+
+    def setFilterConnectionType(self, new_filter: Optional[ConnectionType]) -> None:
+        if self._filter_connection_type != new_filter:
+            self._filter_connection_type = new_filter
+            self.filterConnectionTypeChanged.emit()
+
+    @pyqtProperty(int, fset = setFilterConnectionType, notify = filterConnectionTypeChanged)
+    def filterConnectionType(self) -> int:
+        """
+        The connection type to filter the list of printers by.
+
+        Only printers that match this connection type will be listed in the
+        model.
+        """
+        if self._filter_connection_type is None:
+            return -1
+        return self._filter_connection_type.value
+
+    def setFilterOnlineOnly(self, new_filter: bool) -> None:
+        if self._filter_online_only != new_filter:
+            self._filter_online_only = new_filter
+            self.filterOnlineOnlyChanged.emit()
+
+    @pyqtProperty(bool, fset = setFilterOnlineOnly, notify = filterOnlineOnlyChanged)
+    def filterOnlineOnly(self) -> bool:
+        """
+        Whether to filter the global stacks to show only printers that are online.
+        """
+        return self._filter_online_only
+
+    def setFilterCapabilities(self, new_filter: List[str]) -> None:
+        if self._filter_capabilities != new_filter:
+            self._filter_capabilities = new_filter
+            self.filterCapabilitiesChanged.emit()
+
+    @pyqtProperty("QStringList", fset = setFilterCapabilities, notify = filterCapabilitiesChanged)
+    def filterCapabilities(self) -> List[str]:
+        """
+        Capabilities to require on the list of printers.
+
+        Only printers that have all of these capabilities will be shown in this model.
+        """
+        return self._filter_capabilities
+
     def _onContainerChanged(self, container) -> None:
         """Handler for container added/removed events from registry"""
 
@@ -58,6 +113,10 @@ class GlobalStacksModel(ListModel):
 
         container_stacks = CuraContainerRegistry.getInstance().findContainerStacks(type = "machine")
         for container_stack in container_stacks:
+            if self._filter_connection_type is not None:  # We want to filter on connection types.
+                if not any((connection_type == self._filter_connection_type for connection_type in container_stack.configuredConnectionTypes)):
+                    continue  # No connection type on this printer matches the filter.
+
             has_remote_connection = False
 
             for connection_type in container_stack.configuredConnectionTypes:
@@ -67,6 +126,14 @@ class GlobalStacksModel(ListModel):
             if parseBool(container_stack.getMetaDataEntry("hidden", False)):
                 continue
 
+            is_online = container_stack.getMetaDataEntry("is_online", False)
+            if self._filter_online_only and not is_online:
+                continue
+
+            capabilities = set(container_stack.getMetaDataEntry(META_CAPABILITIES, "").split(","))
+            if set(self._filter_capabilities) - capabilities:  # Not all required capabilities are met.
+                continue
+
             device_name = container_stack.getMetaDataEntry("group_name", container_stack.getName())
             section_name = "Connected printers" if has_remote_connection else "Preset printers"
             section_name = self._catalog.i18nc("@info:title", section_name)
@@ -82,6 +149,7 @@ class GlobalStacksModel(ListModel):
                           "hasRemoteConnection": has_remote_connection,
                           "metadata": container_stack.getMetaData().copy(),
                           "discoverySource": section_name,
-                          "removalWarning": removal_warning})
+                          "removalWarning": removal_warning,
+                          "isOnline": is_online})
         items.sort(key=lambda i: (not i["hasRemoteConnection"], i["name"]))
         self.setItems(items)

cura/Machines/Models/IntentCategoryModel.py

@@ -106,11 +106,15 @@ class IntentCategoryModel(ListModel):
         for category in available_categories:
             qualities = IntentModel()
             qualities.setIntentCategory(category)
+            try:
+                weight = list(IntentCategoryModel._get_translations().keys()).index(category)
+            except ValueError:
+                weight = 99
             result.append({
-                "name": IntentCategoryModel.translation(category, "name", catalog.i18nc("@label", "Unknown")),
+                "name": IntentCategoryModel.translation(category, "name", category),
                 "description": IntentCategoryModel.translation(category, "description", None),
                 "intent_category": category,
-                "weight": list(IntentCategoryModel._get_translations().keys()).index(category),
+                "weight": weight,
                 "qualities": qualities
             })
         result.sort(key = lambda k: k["weight"])

cura/Machines/Models/MaterialManagementModel.py

@@ -2,21 +2,21 @@
 # Cura is released under the terms of the LGPLv3 or higher.
 
 import copy  # To duplicate materials.
-from PyQt5.QtCore import pyqtProperty, pyqtSignal, pyqtSlot, QObject, QUrl
+from PyQt5.QtCore import pyqtSignal, pyqtSlot, QObject, QUrl
+from PyQt5.QtGui import QDesktopServices
 from typing import Any, Dict, Optional, TYPE_CHECKING
 import uuid  # To generate new GUIDs for new materials.
-import zipfile  # To export all materials in a .zip archive.
-
-from PyQt5.QtGui import QDesktopServices
 
+from UM.Message import Message
 from UM.i18n import i18nCatalog
 from UM.Logger import Logger
-from UM.Message import Message
+from UM.Resources import Resources  # To find QML files.
 from UM.Signal import postponeSignals, CompressTechnique
 
-import cura.CuraApplication  # Imported like this to prevent circular imports.
+import cura.CuraApplication  # Imported like this to prevent cirmanagecular imports.
 from cura.Machines.ContainerTree import ContainerTree
 from cura.Settings.CuraContainerRegistry import CuraContainerRegistry  # To find the sets of materials belonging to each other, and currently loaded extruder stacks.
+from cura.UltimakerCloud.CloudMaterialSync import CloudMaterialSync
 
 if TYPE_CHECKING:
     from cura.Machines.MaterialNode import MaterialNode
@@ -33,6 +33,7 @@ class MaterialManagementModel(QObject):
 
     def __init__(self, parent: Optional[QObject] = None) -> None:
         super().__init__(parent = parent)
+        self._material_sync = CloudMaterialSync(parent=self)
         self._checkIfNewMaterialsWereInstalled()
 
     def _checkIfNewMaterialsWereInstalled(self) -> None:
@@ -44,7 +45,8 @@ class MaterialManagementModel(QObject):
         for package_id, package_data in application.getPackageManager().getPackagesInstalledOnStartup().items():
             if package_data["package_info"]["package_type"] == "material":
                 # At least one new material was installed
-                self._showSyncNewMaterialsMessage()
+                # TODO: This should be enabled again once CURA-8609 is merged
+                #self._showSyncNewMaterialsMessage()
                 break
 
     def _showSyncNewMaterialsMessage(self) -> None:
@@ -88,6 +90,7 @@ class MaterialManagementModel(QObject):
         elif sync_message_action == "learn_more":
             QDesktopServices.openUrl(QUrl("https://support.ultimaker.com/hc/en-us/articles/360013137919?utm_source=cura&utm_medium=software&utm_campaign=sync-material-printer-message"))
 
+
     @pyqtSlot("QVariant", result = bool)
     def canMaterialBeRemoved(self, material_node: "MaterialNode") -> bool:
         """Can a certain material be deleted, or is it still in use in one of the container stacks anywhere?
@@ -322,52 +325,10 @@ class MaterialManagementModel(QObject):
         except ValueError:  # Material was not in the favorites list.
             Logger.log("w", "Material {material_base_file} was already not a favorite material.".format(material_base_file = material_base_file))
 
-    @pyqtSlot(result = QUrl)
+    @pyqtSlot()
-    def getPreferredExportAllPath(self) -> QUrl:
+    def openSyncAllWindow(self) -> None:
         """
-        Get the preferred path to export materials to.
+        Opens the window to sync all materials.
+        """
+        self._material_sync.openSyncAllWindow()
 
-        If there is a removable drive, that should be the preferred path. Otherwise it should be the most recent local
-        file path.
-        :return: The preferred path to export all materials to.
-        """
-        cura_application = cura.CuraApplication.CuraApplication.getInstance()
-        device_manager = cura_application.getOutputDeviceManager()
-        devices = device_manager.getOutputDevices()
-        for device in devices:
-            if device.__class__.__name__ == "RemovableDriveOutputDevice":
-                return QUrl.fromLocalFile(device.getId())
-        else:  # No removable drives? Use local path.
-            return cura_application.getDefaultPath("dialog_material_path")
-
-    @pyqtSlot(QUrl)
-    def exportAll(self, file_path: QUrl) -> None:
-        """
-        Export all materials to a certain file path.
-        :param file_path: The path to export the materials to.
-        """
-        registry = CuraContainerRegistry.getInstance()
-
-        try:
-            archive = zipfile.ZipFile(file_path.toLocalFile(), "w", compression = zipfile.ZIP_DEFLATED)
-        except OSError as e:
-            Logger.log("e", f"Can't write to destination {file_path.toLocalFile()}: {type(e)} - {str(e)}")
-            error_message = Message(
-                text = catalog.i18nc("@message:text", "Could not save material archive to {}:").format(file_path.toLocalFile()) + " " + str(e),
-                title = catalog.i18nc("@message:title", "Failed to save material archive"),
-                message_type = Message.MessageType.ERROR
-            )
-            error_message.show()
-            return
-        for metadata in registry.findInstanceContainersMetadata(type = "material"):
-            if metadata["base_file"] != metadata["id"]:  # Only process base files.
-                continue
-            if metadata["id"] == "empty_material":  # Don't export the empty material.
-                continue
-            material = registry.findContainers(id = metadata["id"])[0]
-            suffix = registry.getMimeTypeForContainer(type(material)).preferredSuffix
-            filename = metadata["id"] + "." + suffix
-            try:
-                archive.writestr(filename, material.serialize())
-            except OSError as e:
-                Logger.log("e", f"An error has occurred while writing the material \'{metadata['id']}\' in the file \'{filename}\': {e}.")

cura/Machines/Models/QualityManagementModel.py

@@ -361,8 +361,15 @@ class QualityManagementModel(ListModel):
                 "section_name": catalog.i18nc("@label", intent_translations.get(intent_category, {}).get("name", catalog.i18nc("@label", "Unknown"))),
             })
         # Sort by quality_type for each intent category
+        intent_translations_list = list(intent_translations)
 
-        result = sorted(result, key = lambda x: (list(intent_translations).index(x["intent_category"]), x["quality_type"]))
+        def getIntentWeight(intent_category):
+            try:
+                return intent_translations_list.index(intent_category)
+            except ValueError:
+                return 99
+
+        result = sorted(result, key = lambda x: (getIntentWeight(x["intent_category"]), x["quality_type"]))
         item_list += result
 
         # Create quality_changes group items

cura/OAuth2/AuthorizationHelpers.py

@@ -1,18 +1,19 @@
 # Copyright (c) 2021 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
-from datetime import datetime
-import json
-import secrets
-from hashlib import sha512
 from base64 import b64encode
-from typing import Optional
+from datetime import datetime
-import requests
+from hashlib import sha512
-
+from PyQt5.QtNetwork import QNetworkReply
-from UM.i18n import i18nCatalog
+import secrets
-from UM.Logger import Logger
+from typing import Callable, Optional
+import urllib.parse
 
 from cura.OAuth2.Models import AuthenticationResponse, UserProfile, OAuth2Settings
+from UM.i18n import i18nCatalog
+from UM.Logger import Logger
+from UM.TaskManagement.HttpRequestManager import HttpRequestManager  # To download log-in tokens.
+
 catalog = i18nCatalog("cura")
 TOKEN_TIMESTAMP_FORMAT = "%Y-%m-%d %H:%M:%S"
 
@@ -30,14 +31,13 @@ class AuthorizationHelpers:
 
         return self._settings
 
-    def getAccessTokenUsingAuthorizationCode(self, authorization_code: str, verification_code: str) -> "AuthenticationResponse":
+    def getAccessTokenUsingAuthorizationCode(self, authorization_code: str, verification_code: str, callback: Callable[[AuthenticationResponse], None]) -> None:
-        """Request the access token from the authorization server.
+        """
-
+        Request the access token from the authorization server.
         :param authorization_code: The authorization code from the 1st step.
         :param verification_code: The verification code needed for the PKCE extension.
-        :return: An AuthenticationResponse object.
+        :param callback: Once the token has been obtained, this function will be called with the response.
         """
-
         data = {
             "client_id": self._settings.CLIENT_ID if self._settings.CLIENT_ID is not None else "",
             "redirect_uri": self._settings.CALLBACK_URL if self._settings.CALLBACK_URL is not None else "",
@@ -46,18 +46,21 @@ class AuthorizationHelpers:
             "code_verifier": verification_code,
             "scope": self._settings.CLIENT_SCOPES if self._settings.CLIENT_SCOPES is not None else "",
             }
-        try:
+        headers = {"Content-type": "application/x-www-form-urlencoded"}
-            return self.parseTokenResponse(requests.post(self._token_url, data = data))  # type: ignore
+        HttpRequestManager.getInstance().post(
-        except requests.exceptions.ConnectionError as connection_error:
+            self._token_url,
-            return AuthenticationResponse(success = False, err_message = f"Unable to connect to remote server: {connection_error}")
+            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)
+        )
 
-    def getAccessTokenUsingRefreshToken(self, refresh_token: str) -> "AuthenticationResponse":
+    def getAccessTokenUsingRefreshToken(self, refresh_token: str, callback: Callable[[AuthenticationResponse], None]) -> None:
-        """Request the access token from the authorization server using a refresh token.
+        """
-
+        Request the access token from the authorization server using a refresh token.
-        :param refresh_token:
+        :param refresh_token: A long-lived token used to refresh the authentication token.
-        :return: An AuthenticationResponse object.
+        :param callback: Once the token has been obtained, this function will be called with the response.
         """
-
         Logger.log("d", "Refreshing the access token for [%s]", self._settings.OAUTH_SERVER_URL)
         data = {
             "client_id": self._settings.CLIENT_ID if self._settings.CLIENT_ID is not None else "",
@@ -66,75 +69,99 @@ class AuthorizationHelpers:
             "refresh_token": refresh_token,
             "scope": self._settings.CLIENT_SCOPES if self._settings.CLIENT_SCOPES is not None else "",
         }
-        try:
+        headers = {"Content-type": "application/x-www-form-urlencoded"}
-            return self.parseTokenResponse(requests.post(self._token_url, data = data))  # type: ignore
+        HttpRequestManager.getInstance().post(
-        except requests.exceptions.ConnectionError:
+            self._token_url,
-            return AuthenticationResponse(success = False, err_message = "Unable to connect to remote server")
+            data = urllib.parse.urlencode(data).encode("UTF-8"),
-        except OSError as e:
+            headers_dict = headers,
-            return AuthenticationResponse(success = False, err_message = "Operating system is unable to set up a secure connection: {err}".format(err = str(e)))
+            callback = lambda response: self.parseTokenResponse(response, callback),
+            error_callback = lambda response, _: self.parseTokenResponse(response, callback)
+        )
 
-    @staticmethod
+    def parseTokenResponse(self, token_response: QNetworkReply, callback: Callable[[AuthenticationResponse], None]) -> None:
-    def parseTokenResponse(token_response: requests.models.Response) -> "AuthenticationResponse":
         """Parse the token response from the authorization server into an AuthenticationResponse object.
 
         :param token_response: The JSON string data response from the authorization server.
         :return: An AuthenticationResponse object.
         """
-
+        token_data = HttpRequestManager.readJSON(token_response)
-        token_data = None
-
-        try:
-            token_data = json.loads(token_response.text)
-        except ValueError:
-            Logger.log("w", "Could not parse token response data: %s", token_response.text)
-
         if not token_data:
-            return AuthenticationResponse(success = False, err_message = catalog.i18nc("@message", "Could not read response."))
+            callback(AuthenticationResponse(success = False, err_message = catalog.i18nc("@message", "Could not read response.")))
+            return
 
-        if token_response.status_code not in (200, 201):
+        if token_response.error() != QNetworkReply.NetworkError.NoError:
-            return AuthenticationResponse(success = False, err_message = token_data["error_description"])
+            callback(AuthenticationResponse(success = False, err_message = token_data["error_description"]))
+            return
 
-        return AuthenticationResponse(success=True,
+        callback(AuthenticationResponse(success = True,
-                                      token_type=token_data["token_type"],
+                                        token_type = token_data["token_type"],
-                                      access_token=token_data["access_token"],
+                                        access_token = token_data["access_token"],
-                                      refresh_token=token_data["refresh_token"],
+                                        refresh_token = token_data["refresh_token"],
-                                      expires_in=token_data["expires_in"],
+                                        expires_in = token_data["expires_in"],
-                                      scope=token_data["scope"],
+                                        scope = token_data["scope"],
-                                      received_at=datetime.now().strftime(TOKEN_TIMESTAMP_FORMAT))
+                                        received_at = datetime.now().strftime(TOKEN_TIMESTAMP_FORMAT)))
+        return
 
-    def parseJWT(self, access_token: str) -> Optional["UserProfile"]:
+    def checkToken(self, access_token: str, success_callback: Optional[Callable[[UserProfile], None]] = None, failed_callback: Optional[Callable[[], None]] = None) -> None:
         """Calls the authentication API endpoint to get the token data.
 
+        The API is called asynchronously. When a response is given, the callback is called with the user's profile.
         :param access_token: The encoded JWT token.
-        :return: Dict containing some profile data.
+        :param success_callback: When a response is given, this function will be called with a user profile. If None,
+        there will not be a callback.
+        :param failed_callback: When the request failed or the response didn't parse, this function will be called.
         """
-
+        check_token_url = "{}/check-token".format(self._settings.OAUTH_SERVER_URL)
-        try:
+        Logger.log("d", "Checking the access token for [%s]", check_token_url)
-            check_token_url = "{}/check-token".format(self._settings.OAUTH_SERVER_URL)
+        headers = {
-            Logger.log("d", "Checking the access token for [%s]", check_token_url)
+            "Authorization": f"Bearer {access_token}"
-            token_request = requests.get(check_token_url, headers = {
+        }
-                "Authorization": "Bearer {}".format(access_token)
+        HttpRequestManager.getInstance().get(
-            })
+            check_token_url,
-        except (requests.exceptions.ConnectionError, requests.exceptions.Timeout):
+            headers_dict = headers,
-            # Connection was suddenly dropped. Nothing we can do about that.
+            callback = lambda reply: self._parseUserProfile(reply, success_callback, failed_callback),
-            Logger.logException("w", "Something failed while attempting to parse the JWT token")
+            error_callback = lambda _, _2: failed_callback() if failed_callback is not None else None
-            return None
-        if token_request.status_code not in (200, 201):
-            Logger.log("w", "Could not retrieve token data from auth server: %s", token_request.text)
-            return None
-        user_data = token_request.json().get("data")
-        if not user_data or not isinstance(user_data, dict):
-            Logger.log("w", "Could not parse user data from token: %s", user_data)
-            return None
-
-        return UserProfile(
-            user_id = user_data["user_id"],
-            username = user_data["username"],
-            profile_image_url = user_data.get("profile_image_url", ""),
-            organization_id = user_data.get("organization", {}).get("organization_id"),
-            subscriptions = user_data.get("subscriptions", [])
         )
 
+    def _parseUserProfile(self, reply: QNetworkReply, success_callback: Optional[Callable[[UserProfile], None]], failed_callback: Optional[Callable[[], None]] = None) -> None:
+        """
+        Parses the user profile from a reply to /check-token.
+
+        If the response is valid, the callback will be called to return the user profile to the caller.
+        :param reply: A network reply to a request to the /check-token URL.
+        :param success_callback: A function to call once a user profile was successfully obtained.
+        :param failed_callback: A function to call if parsing the profile failed.
+        """
+        if reply.error() != QNetworkReply.NetworkError.NoError:
+            Logger.warning(f"Could not access account information. QNetworkError {reply.errorString()}")
+            if failed_callback is not None:
+                failed_callback()
+            return
+
+        profile_data = HttpRequestManager.getInstance().readJSON(reply)
+        if profile_data is None or "data" not in profile_data:
+            Logger.warning("Could not parse user data from token.")
+            if failed_callback is not None:
+                failed_callback()
+            return
+        profile_data = profile_data["data"]
+
+        required_fields = {"user_id", "username"}
+        if "user_id" not in profile_data or "username" not in profile_data:
+            Logger.warning(f"User data missing required field(s): {required_fields - set(profile_data.keys())}")
+            if failed_callback is not None:
+                failed_callback()
+            return
+
+        if success_callback is not None:
+            success_callback(UserProfile(
+                user_id = profile_data["user_id"],
+                username = profile_data["username"],
+                profile_image_url = profile_data.get("profile_image_url", ""),
+                organization_id = profile_data.get("organization", {}).get("organization_id"),
+                subscriptions = profile_data.get("subscriptions", [])
+            ))
+
     @staticmethod
     def generateVerificationCode(code_length: int = 32) -> str:
         """Generate a verification code of arbitrary length.

cura/OAuth2/AuthorizationRequestHandler.py

@@ -2,6 +2,7 @@
 # Cura is released under the terms of the LGPLv3 or higher.
 
 from http.server import BaseHTTPRequestHandler
+from threading import Lock  # To turn an asynchronous call synchronous.
 from typing import Optional, Callable, Tuple, Dict, Any, List, TYPE_CHECKING
 from urllib.parse import parse_qs, urlparse
 
@@ -14,6 +15,7 @@ if TYPE_CHECKING:
 
 catalog = i18nCatalog("cura")
 
+
 class AuthorizationRequestHandler(BaseHTTPRequestHandler):
     """This handler handles all HTTP requests on the local web server.
 
@@ -24,11 +26,11 @@ class AuthorizationRequestHandler(BaseHTTPRequestHandler):
         super().__init__(request, client_address, server)
 
         # These values will be injected by the HTTPServer that this handler belongs to.
-        self.authorization_helpers = None  # type: Optional[AuthorizationHelpers]
+        self.authorization_helpers: Optional[AuthorizationHelpers] = None
-        self.authorization_callback = None  # type: Optional[Callable[[AuthenticationResponse], None]]
+        self.authorization_callback: Optional[Callable[[AuthenticationResponse], None]] = None
-        self.verification_code = None  # type: Optional[str]
+        self.verification_code: Optional[str] = None
 
-        self.state = None  # type: Optional[str]
+        self.state: Optional[str] = None
 
     # CURA-6609: Some browser seems to issue a HEAD instead of GET request as the callback.
     def do_HEAD(self) -> None:
@@ -70,13 +72,23 @@ class AuthorizationRequestHandler(BaseHTTPRequestHandler):
         if state != self.state:
             token_response = AuthenticationResponse(
                 success = False,
-                err_message=catalog.i18nc("@message",
+                err_message = catalog.i18nc("@message", "The provided state is not correct.")
-                                          "The provided state is not correct.")
             )
         elif code and self.authorization_helpers is not None and self.verification_code is not None:
+            token_response = AuthenticationResponse(
+                success = False,
+                err_message = catalog.i18nc("@message", "Timeout when authenticating with the account server.")
+            )
             # If the code was returned we get the access token.
-            token_response = self.authorization_helpers.getAccessTokenUsingAuthorizationCode(
+            lock = Lock()
-                code, self.verification_code)
+            lock.acquire()
+
+            def callback(response: AuthenticationResponse) -> None:
+                nonlocal token_response
+                token_response = response
+                lock.release()
+            self.authorization_helpers.getAccessTokenUsingAuthorizationCode(code, self.verification_code, callback)
+            lock.acquire(timeout = 60)  # Block thread until request is completed (which releases the lock). If not acquired, the timeout message stays.
 
         elif self._queryGet(query, "error_code") == "user_denied":
             # Otherwise we show an error message (probably the user clicked "Deny" in the auth dialog).

cura/OAuth2/AuthorizationService.py

@@ -3,10 +3,9 @@
 
 import json
 from datetime import datetime, timedelta
-from typing import Optional, TYPE_CHECKING, Dict
+from typing import Callable, Dict, Optional, TYPE_CHECKING, Union
 from urllib.parse import urlencode, quote_plus
 
-import requests.exceptions
 from PyQt5.QtCore import QUrl
 from PyQt5.QtGui import QDesktopServices
 
@@ -16,7 +15,7 @@ from UM.Signal import Signal
 from UM.i18n import i18nCatalog
 from cura.OAuth2.AuthorizationHelpers import AuthorizationHelpers, TOKEN_TIMESTAMP_FORMAT
 from cura.OAuth2.LocalAuthorizationServer import LocalAuthorizationServer
-from cura.OAuth2.Models import AuthenticationResponse
+from cura.OAuth2.Models import AuthenticationResponse, BaseModel
 
 i18n_catalog = i18nCatalog("cura")
 
@@ -26,6 +25,7 @@ if TYPE_CHECKING:
 
 MYCLOUD_LOGOFF_URL = "https://account.ultimaker.com/logoff?utm_source=cura&utm_medium=software&utm_campaign=change-account-before-adding-printers"
 
+
 class AuthorizationService:
     """The authorization service is responsible for handling the login flow, storing user credentials and providing
     account information.
@@ -43,12 +43,13 @@ class AuthorizationService:
         self._settings = settings
         self._auth_helpers = AuthorizationHelpers(settings)
         self._auth_url = "{}/authorize".format(self._settings.OAUTH_SERVER_URL)
-        self._auth_data = None  # type: Optional[AuthenticationResponse]
+        self._auth_data: Optional[AuthenticationResponse] = None
-        self._user_profile = None  # type: Optional["UserProfile"]
+        self._user_profile: Optional["UserProfile"] = None
         self._preferences = preferences
         self._server = LocalAuthorizationServer(self._auth_helpers, self._onAuthStateChanged, daemon=True)
+        self._currently_refreshing_token = False  # Whether we are currently in the process of refreshing auth. Don't make new requests while busy.
 
-        self._unable_to_get_data_message = None  # type: Optional[Message]
+        self._unable_to_get_data_message: Optional[Message] = None
 
         self.onAuthStateChanged.connect(self._authChanged)
 
@@ -62,69 +63,80 @@ class AuthorizationService:
         if self._preferences:
             self._preferences.addPreference(self._settings.AUTH_DATA_PREFERENCE_KEY, "{}")
 
-    def getUserProfile(self) -> Optional["UserProfile"]:
+    def getUserProfile(self, callback: Optional[Callable[[Optional["UserProfile"]], None]] = None) -> None:
-        """Get the user profile as obtained from the JWT (JSON Web Token).
+        """
+        Get the user profile as obtained from the JWT (JSON Web Token).
 
-        If the JWT is not yet parsed, calling this will take care of that.
+        If the JWT is not yet checked and parsed, calling this will take care of that.
-
+        :param callback: Once the user profile is obtained, this function will be called with the given user profile. If
-        :return: UserProfile if a user is logged in, None otherwise.
+        the profile fails to be obtained, this function will be called with None.
 
         See also: :py:method:`cura.OAuth2.AuthorizationService.AuthorizationService._parseJWT`
         """
+        if self._user_profile:
+            # We already obtained the profile. No need to make another request for it.
+            if callback is not None:
+                callback(self._user_profile)
+            return
 
-        if not self._user_profile:
+        # If no user profile was stored locally, we try to get it from JWT.
-            # If no user profile was stored locally, we try to get it from JWT.
+        def store_profile(profile: Optional["UserProfile"]) -> None:
-            try:
+            if profile is not None:
-                self._user_profile = self._parseJWT()
+                self._user_profile = profile
-            except requests.exceptions.ConnectionError:
+                if callback is not None:
-                # Unable to get connection, can't login.
+                    callback(profile)
-                Logger.logException("w", "Unable to validate user data with the remote server.")
+            elif self._auth_data:
-                return None
+                # If there is no user profile from the JWT, we have to log in again.
+                Logger.warning("The user profile could not be loaded. The user must log in again!")
+                self.deleteAuthData()
+                if callback is not None:
+                    callback(None)
+            else:
+                if callback is not None:
+                    callback(None)
 
-        if not self._user_profile and self._auth_data:
+        self._parseJWT(callback = store_profile)
-            # If there is still no user profile from the JWT, we have to log in again.
-            Logger.log("w", "The user profile could not be loaded. The user must log in again!")
-            self.deleteAuthData()
-            return None
 
-        return self._user_profile
+    def _parseJWT(self, callback: Callable[[Optional["UserProfile"]], None]) -> None:
-
+        """
-    def _parseJWT(self) -> Optional["UserProfile"]:
+        Tries to parse the JWT (JSON Web Token) data, which it does if all the needed data is there.
-        """Tries to parse the JWT (JSON Web Token) data, which it does if all the needed data is there.
+        :param callback: A function to call asynchronously once the user profile has been obtained. It will be called
-
+        with `None` if it failed to obtain a user profile.
-        :return: UserProfile if it was able to parse, None otherwise.
         """
 
         if not self._auth_data or self._auth_data.access_token is None:
             # If no auth data exists, we should always log in again.
-            Logger.log("d", "There was no auth data or access token")
+            Logger.debug("There was no auth data or access token")
-            return None
+            callback(None)
+            return
 
-        try:
+        # When we checked the token we may get a user profile. This callback checks if that is a valid one and tries to refresh the token if it's not.
-            user_data = self._auth_helpers.parseJWT(self._auth_data.access_token)
+        def check_user_profile(user_profile: Optional["UserProfile"]) -> None:
-        except AttributeError:
+            if user_profile:
-            # THis might seem a bit double, but we get crash reports about this (CURA-2N2 in sentry)
+                # If the profile was found, we call it back immediately.
-            Logger.log("d", "There was no auth data or access token")
+                callback(user_profile)
-            return None
+                return
+            # The JWT was expired or invalid and we should request a new one.
+            if self._auth_data is None or self._auth_data.refresh_token is None:
+                Logger.warning("There was no refresh token in the auth data.")
+                callback(None)
+                return
 
-        if user_data:
+            def process_auth_data(auth_data: AuthenticationResponse) -> None:
-            # If the profile was found, we return it immediately.
+                if auth_data.access_token is None:
-            return user_data
+                    Logger.warning("Unable to use the refresh token to get a new access token.")
-        # The JWT was expired or invalid and we should request a new one.
+                    callback(None)
-        if self._auth_data.refresh_token is None:
+                    return
-            Logger.log("w", "There was no refresh token in the auth data.")
+                # Ensure it gets stored as otherwise we only have it in memory. The stored refresh token has been
-            return None
+                # deleted from the server already. Do not store the auth_data if we could not get new auth_data (e.g.
-        self._auth_data = self._auth_helpers.getAccessTokenUsingRefreshToken(self._auth_data.refresh_token)
+                # due to a network error), since this would cause an infinite loop trying to get new auth-data.
-        if not self._auth_data or self._auth_data.access_token is None:
+                if auth_data.success:
-            Logger.log("w", "Unable to use the refresh token to get a new access token.")
+                    self._storeAuthData(auth_data)
-            # The token could not be refreshed using the refresh token. We should login again.
+                self._auth_helpers.checkToken(auth_data.access_token, callback, lambda: callback(None))
-            return None
+
-        # Ensure it gets stored as otherwise we only have it in memory. The stored refresh token has been deleted
+            self._auth_helpers.getAccessTokenUsingRefreshToken(self._auth_data.refresh_token, process_auth_data)
-        # from the server already. Do not store the auth_data if we could not get new auth_data (eg due to a
+
-        # network error), since this would cause an infinite loop trying to get new auth-data
+        self._auth_helpers.checkToken(self._auth_data.access_token, check_user_profile, lambda: check_user_profile(None))
-        if self._auth_data.success:
-            self._storeAuthData(self._auth_data)
-        return self._auth_helpers.parseJWT(self._auth_data.access_token)
 
     def getAccessToken(self) -> Optional[str]:
         """Get the access token as provided by the response data."""
@@ -149,13 +161,20 @@ class AuthorizationService:
         if self._auth_data is None or self._auth_data.refresh_token is None:
             Logger.log("w", "Unable to refresh access token, since there is no refresh token.")
             return
-        response = self._auth_helpers.getAccessTokenUsingRefreshToken(self._auth_data.refresh_token)
+
-        if response.success:
+        def process_auth_data(response: AuthenticationResponse) -> None:
-            self._storeAuthData(response)
+            if response.success:
-            self.onAuthStateChanged.emit(logged_in = True)
+                self._storeAuthData(response)
-        else:
+                self.onAuthStateChanged.emit(logged_in = True)
-            Logger.log("w", "Failed to get a new access token from the server.")
+            else:
-            self.onAuthStateChanged.emit(logged_in = False)
+                Logger.warning("Failed to get a new access token from the server.")
+                self.onAuthStateChanged.emit(logged_in = False)
+
+        if self._currently_refreshing_token:
+            Logger.debug("Was already busy refreshing token. Do not start a new request.")
+            return
+        self._currently_refreshing_token = True
+        self._auth_helpers.getAccessTokenUsingRefreshToken(self._auth_data.refresh_token, process_auth_data)
 
     def deleteAuthData(self) -> None:
         """Delete the authentication data that we have stored locally (eg; logout)"""
@@ -244,21 +263,23 @@ class AuthorizationService:
             preferences_data = json.loads(self._preferences.getValue(self._settings.AUTH_DATA_PREFERENCE_KEY))
             if preferences_data:
                 self._auth_data = AuthenticationResponse(**preferences_data)
-                # Also check if we can actually get the user profile information.
-                user_profile = self.getUserProfile()
-                if user_profile is not None:
-                    self.onAuthStateChanged.emit(logged_in = True)
-                    Logger.log("d", "Auth data was successfully loaded")
-                else:
-                    if self._unable_to_get_data_message is not None:
-                        self._unable_to_get_data_message.hide()
 
-                    self._unable_to_get_data_message = Message(i18n_catalog.i18nc("@info",
+                # Also check if we can actually get the user profile information.
-                                                                                  "Unable to reach the Ultimaker account server."),
+                def callback(profile: Optional["UserProfile"]) -> None:
-                                                               title = i18n_catalog.i18nc("@info:title", "Warning"),
+                    if profile is not None:
-                                                               message_type = Message.MessageType.ERROR)
+                        self.onAuthStateChanged.emit(logged_in = True)
-                    Logger.log("w", "Unable to load auth data from preferences")
+                        Logger.debug("Auth data was successfully loaded")
-                    self._unable_to_get_data_message.show()
+                    else:
+                        if self._unable_to_get_data_message is not None:
+                            self._unable_to_get_data_message.show()
+                        else:
+                            self._unable_to_get_data_message = Message(i18n_catalog.i18nc("@info",
+                                                                                          "Unable to reach the Ultimaker account server."),
+                                                                       title = i18n_catalog.i18nc("@info:title", "Log-in failed"),
+                                                                       message_type = Message.MessageType.ERROR)
+                            Logger.warning("Unable to get user profile using auth data from preferences.")
+                            self._unable_to_get_data_message.show()
+                self.getUserProfile(callback)
         except (ValueError, TypeError):
             Logger.logException("w", "Could not load auth data from preferences")
 
@@ -271,8 +292,9 @@ class AuthorizationService:
             return
 
         self._auth_data = auth_data
+        self._currently_refreshing_token = False
         if auth_data:
-            self._user_profile = self.getUserProfile()
+            self.getUserProfile()
             self._preferences.setValue(self._settings.AUTH_DATA_PREFERENCE_KEY, json.dumps(auth_data.dump()))
         else:
             Logger.log("d", "Clearing the user profile")

cura/OAuth2/KeyringAttribute.py

@@ -2,9 +2,10 @@
 # Cura is released under the terms of the LGPLv3 or higher.
 from typing import Type, TYPE_CHECKING, Optional, List
 
+from io import BlockingIOError
 import keyring
 from keyring.backend import KeyringBackend
-from keyring.errors import NoKeyringError, PasswordSetError, KeyringLocked
+from keyring.errors import NoKeyringError, PasswordSetError, KeyringLocked, KeyringError
 
 from UM.Logger import Logger
 
@@ -44,7 +45,7 @@ class KeyringAttribute:
                 self._store_secure = False
                 Logger.logException("w", "No keyring backend present")
                 return getattr(instance, self._name)
-            except KeyringLocked:
+            except (KeyringLocked, BlockingIOError):
                 self._store_secure = False
                 Logger.log("i", "Access to the keyring was denied.")
                 return getattr(instance, self._name)
@@ -52,6 +53,10 @@ class KeyringAttribute:
                 self._store_secure = False
                 Logger.log("w", "The password retrieved from the keyring cannot be used because it contains characters that cannot be decoded.")
                 return getattr(instance, self._name)
+            except KeyringError:
+                self._store_secure = False
+                Logger.logException("w", "Unknown keyring error.")
+                return getattr(instance, self._name)
         else:
             return getattr(instance, self._name)
 

cura/PickingPass.py

@@ -72,8 +72,8 @@ class PickingPass(RenderPass):
 
         window_size = self._renderer.getWindowSize()
 
-        px = (0.5 + x / 2.0) * window_size[0]
+        px = int((0.5 + x / 2.0) * window_size[0])
-        py = (0.5 + y / 2.0) * window_size[1]
+        py = int((0.5 + y / 2.0) * window_size[1])
 
         if px < 0 or px > (output.width() - 1) or py < 0 or py > (output.height() - 1):
             return -1

cura/PrinterOutput/Models/PrintJobOutputModel.py

@@ -42,7 +42,7 @@ class PrintJobOutputModel(QObject):
         self._preview_image = None  # type: Optional[QImage]
 
     @pyqtProperty("QStringList", notify=compatibleMachineFamiliesChanged)
-    def compatibleMachineFamilies(self):
+    def compatibleMachineFamilies(self) -> List[str]:
         # Hack; Some versions of cluster will return a family more than once...
         return list(set(self._compatible_machine_families))
 
@@ -77,11 +77,11 @@ class PrintJobOutputModel(QObject):
             self._configuration = configuration
             self.configurationChanged.emit()
 
-    @pyqtProperty(str, notify=ownerChanged)
+    @pyqtProperty(str, notify = ownerChanged)
-    def owner(self):
+    def owner(self) -> str:
         return self._owner
 
-    def updateOwner(self, owner):
+    def updateOwner(self, owner: str) -> None:
         if self._owner != owner:
             self._owner = owner
             self.ownerChanged.emit()
@@ -132,7 +132,7 @@ class PrintJobOutputModel(QObject):
 
     @pyqtProperty(float, notify = timeElapsedChanged)
     def progress(self) -> float:
-        result = float(self.timeElapsed) / max(self.timeTotal, 1.0) # Prevent a division by zero exception.
+        result = float(self.timeElapsed) / max(self.timeTotal, 1.0)  # Prevent a division by zero exception.
         return min(result, 1.0)  # Never get a progress past 1.0
 
     @pyqtProperty(str, notify=stateChanged)
@@ -151,12 +151,12 @@ class PrintJobOutputModel(QObject):
             return False
         return True
 
-    def updateTimeTotal(self, new_time_total):
+    def updateTimeTotal(self, new_time_total: int) -> None:
         if self._time_total != new_time_total:
             self._time_total = new_time_total
             self.timeTotalChanged.emit()
 
-    def updateTimeElapsed(self, new_time_elapsed):
+    def updateTimeElapsed(self, new_time_elapsed: int) -> None:
         if self._time_elapsed != new_time_elapsed:
             self._time_elapsed = new_time_elapsed
             self.timeElapsedChanged.emit()

cura/PrinterOutput/NetworkedPrinterOutputDevice.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2018 Ultimaker B.V.
+# Copyright (c) 2021 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
 from UM.FileHandler.FileHandler import FileHandler #For typing.
@@ -114,6 +114,11 @@ class NetworkedPrinterOutputDevice(PrinterOutputDevice):
         return b"".join(file_data_bytes_list)
 
     def _update(self) -> None:
+        """
+        Update the connection state of this device.
+
+        This is called on regular intervals.
+        """
         if self._last_response_time:
             time_since_last_response = time() - self._last_response_time
         else:
@@ -127,11 +132,11 @@ class NetworkedPrinterOutputDevice(PrinterOutputDevice):
         if time_since_last_response > self._timeout_time >= time_since_last_request:
             # Go (or stay) into timeout.
             if self._connection_state_before_timeout is None:
-                self._connection_state_before_timeout = self._connection_state
+                self._connection_state_before_timeout = self.connectionState
 
             self.setConnectionState(ConnectionState.Closed)
 
-        elif self._connection_state == ConnectionState.Closed:
+        elif self.connectionState == ConnectionState.Closed:
             # Go out of timeout.
             if self._connection_state_before_timeout is not None:   # sanity check, but it should never be None here
                 self.setConnectionState(self._connection_state_before_timeout)
@@ -361,7 +366,7 @@ class NetworkedPrinterOutputDevice(PrinterOutputDevice):
 
         self._last_response_time = time()
 
-        if self._connection_state == ConnectionState.Connecting:
+        if self.connectionState == ConnectionState.Connecting:
             self.setConnectionState(ConnectionState.Connected)
 
         callback_key = reply.url().toString() + str(reply.operation())

cura/PrinterOutput/PrinterOutputDevice.py

@@ -1,11 +1,13 @@
-# Copyright (c) 2018 Ultimaker B.V.
+# Copyright (c) 2021 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
+
 from enum import IntEnum
 from typing import Callable, List, Optional, Union
 
 from PyQt5.QtCore import pyqtProperty, pyqtSignal, QObject, QTimer, QUrl
 from PyQt5.QtWidgets import QMessageBox
 
+import cura.CuraApplication  # Imported like this to prevent circular imports.
 from UM.Logger import Logger
 from UM.Signal import signalemitter
 from UM.Qt.QtApplication import QtApplication
@@ -120,11 +122,22 @@ class PrinterOutputDevice(QObject, OutputDevice):
         callback(QMessageBox.Yes)
 
     def isConnected(self) -> bool:
-        return self._connection_state != ConnectionState.Closed and self._connection_state != ConnectionState.Error
+        """
+        Returns whether we could theoretically send commands to this printer.
+        :return: `True` if we are connected, or `False` if not.
+        """
+        return self.connectionState != ConnectionState.Closed and self.connectionState != ConnectionState.Error
 
     def setConnectionState(self, connection_state: "ConnectionState") -> None:
-        if self._connection_state != connection_state:
+        """
+        Store the connection state of the printer.
+
+        Causes everything that displays the connection state to update its QML models.
+        :param connection_state: The new connection state to store.
+        """
+        if self.connectionState != connection_state:
             self._connection_state = connection_state
+            cura.CuraApplication.CuraApplication.getInstance().getGlobalContainerStack().setMetaDataEntry("is_online", self.isConnected())
             self.connectionStateChanged.emit(self._id)
 
     @pyqtProperty(int, constant = True)
@@ -133,6 +146,10 @@ class PrinterOutputDevice(QObject, OutputDevice):
 
     @pyqtProperty(int, notify = connectionStateChanged)
     def connectionState(self) -> "ConnectionState":
+        """
+        Get the connection state of the printer, e.g. whether it is connected, still connecting, error state, etc.
+        :return: The current connection state of this output device.
+        """
         return self._connection_state
 
     def _update(self) -> None:

cura/PrinterOutput/UploadMaterialsJob.py

@@ -0,0 +1,264 @@
+# Copyright (c) 2021 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+
+import enum
+import functools  # For partial methods to use as callbacks with information pre-filled.
+import json  # To serialise metadata for API calls.
+import os  # To delete the archive when we're done.
+from PyQt5.QtCore import QUrl
+import tempfile  # To create an archive before we upload it.
+
+import cura.CuraApplication  # Imported like this to prevent circular imports.
+from cura.Settings.CuraContainerRegistry import CuraContainerRegistry  # To find all printers to upload to.
+from cura.UltimakerCloud import UltimakerCloudConstants  # To know where the API is.
+from cura.UltimakerCloud.UltimakerCloudScope import UltimakerCloudScope  # To know how to communicate with this server.
+from UM.i18n import i18nCatalog
+from UM.Job import Job
+from UM.Logger import Logger
+from UM.Signal import Signal
+from UM.TaskManagement.HttpRequestManager import HttpRequestManager  # To call the API.
+from UM.TaskManagement.HttpRequestScope import JsonDecoratorScope
+
+from typing import Any, cast, Dict, List, Optional, TYPE_CHECKING
+if TYPE_CHECKING:
+    from PyQt5.QtNetwork import QNetworkReply
+    from cura.UltimakerCloud.CloudMaterialSync import CloudMaterialSync
+
+catalog = i18nCatalog("cura")
+
+
+class UploadMaterialsError(Exception):
+    """
+    Class to indicate something went wrong while uploading.
+    """
+    pass
+
+
+class UploadMaterialsJob(Job):
+    """
+    Job that uploads a set of materials to the Digital Factory.
+
+    The job has a number of stages:
+    - First, it generates an archive of all materials. This typically takes a lot of processing power during which the
+      GIL remains locked.
+    - Then it requests the API to upload an archive.
+    - Then it uploads the archive to the URL given by the first request.
+    - Then it tells the API that the archive can be distributed to the printers.
+    """
+
+    UPLOAD_REQUEST_URL = f"{UltimakerCloudConstants.CuraCloudAPIRoot}/connect/v1/materials/upload"
+    UPLOAD_CONFIRM_URL = UltimakerCloudConstants.CuraCloudAPIRoot + "/connect/v1/clusters/{cluster_id}/printers/{cluster_printer_id}/action/import_material"
+
+    class Result(enum.IntEnum):
+        SUCCESS = 0
+        FAILED = 1
+
+    class PrinterStatus(enum.Enum):
+        UPLOADING = "uploading"
+        SUCCESS = "success"
+        FAILED = "failed"
+
+    def __init__(self, material_sync: "CloudMaterialSync"):
+        super().__init__()
+        self._material_sync = material_sync
+        self._scope = JsonDecoratorScope(UltimakerCloudScope(cura.CuraApplication.CuraApplication.getInstance()))  # type: JsonDecoratorScope
+        self._archive_filename = None  # type: Optional[str]
+        self._archive_remote_id = None  # type: Optional[str]  # ID that the server gives to this archive. Used to communicate about the archive to the server.
+        self._printer_sync_status = {}  # type: Dict[str, str]
+        self._printer_metadata = []  # type: List[Dict[str, Any]]
+        self.processProgressChanged.connect(self._onProcessProgressChanged)
+
+    uploadCompleted = Signal()  # Triggered when the job is really complete, including uploading to the cloud.
+    processProgressChanged = Signal()  # Triggered when we've made progress creating the archive.
+    uploadProgressChanged = Signal()  # Triggered when we've made progress with the complete job. This signal emits a progress fraction (0-1) as well as the status of every printer.
+
+    def run(self) -> None:
+        """
+        Generates an archive of materials and starts uploading that archive to the cloud.
+        """
+        self._printer_metadata = CuraContainerRegistry.getInstance().findContainerStacksMetadata(
+            type = "machine",
+            connection_type = "3",  # Only cloud printers.
+            is_online = "True",  # Only online printers. Otherwise the server gives an error.
+            host_guid = "*",  # Required metadata field. Otherwise we get a KeyError.
+            um_cloud_cluster_id = "*"  # Required metadata field. Otherwise we get a KeyError.
+        )
+
+        # Filter out any printer not capable of the 'import_material' capability. Needs FW 7.0.1-RC at the least!
+        self._printer_metadata = [ printer_data for printer_data in self._printer_metadata if (
+                UltimakerCloudConstants.META_CAPABILITIES in printer_data and
+                "import_material" in printer_data[UltimakerCloudConstants.META_CAPABILITIES]
+            )
+        ]
+
+        for printer in self._printer_metadata:
+            self._printer_sync_status[printer["host_guid"]] = self.PrinterStatus.UPLOADING.value
+
+        try:
+            archive_file = tempfile.NamedTemporaryFile("wb", delete = False)
+            archive_file.close()
+            self._archive_filename = archive_file.name
+            self._material_sync.exportAll(QUrl.fromLocalFile(self._archive_filename), notify_progress = self.processProgressChanged)
+        except OSError as e:
+            Logger.error(f"Failed to create archive of materials to sync with printers: {type(e)} - {e}")
+            self.failed(UploadMaterialsError(catalog.i18nc("@text:error", "Failed to create archive of materials to sync with printers.")))
+            return
+
+        try:
+            file_size = os.path.getsize(self._archive_filename)
+        except OSError as e:
+            Logger.error(f"Failed to load the archive of materials to sync it with printers: {type(e)} - {e}")
+            self.failed(UploadMaterialsError(catalog.i18nc("@text:error", "Failed to load the archive of materials to sync it with printers.")))
+            return
+
+        request_metadata = {
+            "data": {
+                "file_size": file_size,
+                "material_profile_name": "cura.umm",  # File name can be anything as long as it's .umm. It's not used by anyone.
+                "content_type": "application/zip",  # This endpoint won't receive files of different MIME types.
+                "origin": "cura"  # Some identifier against hackers intercepting this upload request, apparently.
+            }
+        }
+        request_payload = json.dumps(request_metadata).encode("UTF-8")
+
+        http = HttpRequestManager.getInstance()
+        http.put(
+            url = self.UPLOAD_REQUEST_URL,
+            data = request_payload,
+            callback = self.onUploadRequestCompleted,
+            error_callback = self.onError,
+            scope = self._scope
+        )
+
+    def onUploadRequestCompleted(self, reply: "QNetworkReply") -> None:
+        """
+        Triggered when we successfully requested to upload a material archive.
+
+        We then need to start uploading the material archive to the URL that the request answered with.
+        :param reply: The reply from the server to our request to upload an archive.
+        """
+        response_data = HttpRequestManager.readJSON(reply)
+        if response_data is None:
+            Logger.error(f"Invalid response to material upload request. Could not parse JSON data.")
+            self.failed(UploadMaterialsError(catalog.i18nc("@text:error", "The response from Digital Factory appears to be corrupted.")))
+            return
+        if "data" not in response_data:
+            Logger.error(f"Invalid response to material upload request: Missing 'data' field that contains the entire response.")
+            self.failed(UploadMaterialsError(catalog.i18nc("@text:error", "The response from Digital Factory is missing important information.")))
+            return
+        if "upload_url" not in response_data["data"]:
+            Logger.error(f"Invalid response to material upload request: Missing 'upload_url' field to upload archive to.")
+            self.failed(UploadMaterialsError(catalog.i18nc("@text:error", "The response from Digital Factory is missing important information.")))
+            return
+        if "material_profile_id" not in response_data["data"]:
+            Logger.error(f"Invalid response to material upload request: Missing 'material_profile_id' to communicate about the materials with the server.")
+            self.failed(UploadMaterialsError(catalog.i18nc("@text:error", "The response from Digital Factory is missing important information.")))
+            return
+
+        upload_url = response_data["data"]["upload_url"]
+        self._archive_remote_id = response_data["data"]["material_profile_id"]
+        try:
+            with open(cast(str, self._archive_filename), "rb") as f:
+                file_data = f.read()
+        except OSError as e:
+            Logger.error(f"Failed to load archive back in for sending to cloud: {type(e)} - {e}")
+            self.failed(UploadMaterialsError(catalog.i18nc("@text:error", "Failed to load the archive of materials to sync it with printers.")))
+            return
+        http = HttpRequestManager.getInstance()
+        http.put(
+            url = upload_url,
+            data = file_data,
+            callback = self.onUploadCompleted,
+            error_callback = self.onError,
+            scope = self._scope
+        )
+
+    def onUploadCompleted(self, reply: "QNetworkReply") -> None:
+        """
+        When we've successfully uploaded the archive to the cloud, we need to notify the API to start syncing that
+        archive to every printer.
+        :param reply: The reply from the cloud storage when the upload succeeded.
+        """
+        for container_stack in self._printer_metadata:
+            cluster_id = container_stack["um_cloud_cluster_id"]
+            printer_id = container_stack["host_guid"]
+
+            http = HttpRequestManager.getInstance()
+            http.post(
+                url = self.UPLOAD_CONFIRM_URL.format(cluster_id = cluster_id, cluster_printer_id = printer_id),
+                callback = functools.partial(self.onUploadConfirmed, printer_id),
+                error_callback = functools.partial(self.onUploadConfirmed, printer_id),  # Let this same function handle the error too.
+                scope = self._scope,
+                data = json.dumps({"data": {"material_profile_id": self._archive_remote_id}}).encode("UTF-8")
+            )
+
+    def onUploadConfirmed(self, printer_id: str, reply: "QNetworkReply", error: Optional["QNetworkReply.NetworkError"] = None) -> None:
+        """
+        Triggered when we've got a confirmation that the material is synced with the printer, or that syncing failed.
+
+        If syncing succeeded we mark this printer as having the status "success". If it failed we mark the printer as
+        "failed". If this is the last upload that needed to be completed, we complete the job with either a success
+        state (every printer successfully synced) or a failed state (any printer failed).
+        :param printer_id: The printer host_guid that we completed syncing with.
+        :param reply: The reply that the server gave to confirm.
+        :param error: If the request failed, this error gives an indication what happened.
+        """
+        if error is not None:
+            Logger.error(f"Failed to confirm uploading material archive to printer {printer_id}: {error}")
+            self._printer_sync_status[printer_id] = self.PrinterStatus.FAILED.value
+        else:
+            self._printer_sync_status[printer_id] = self.PrinterStatus.SUCCESS.value
+
+        still_uploading = len([val for val in self._printer_sync_status.values() if val == self.PrinterStatus.UPLOADING.value])
+        self.uploadProgressChanged.emit(0.8 + (len(self._printer_sync_status) - still_uploading) / len(self._printer_sync_status), self.getPrinterSyncStatus())
+
+        if still_uploading == 0:  # This is the last response to be processed.
+            if self.PrinterStatus.FAILED.value in self._printer_sync_status.values():
+                self.setResult(self.Result.FAILED)
+                self.setError(UploadMaterialsError(catalog.i18nc("@text:error", "Failed to connect to Digital Factory to sync materials with some of the printers.")))
+            else:
+                self.setResult(self.Result.SUCCESS)
+            self.uploadCompleted.emit(self.getResult(), self.getError())
+
+    def onError(self, reply: "QNetworkReply", error: Optional["QNetworkReply.NetworkError"]) -> None:
+        """
+        Used as callback from HTTP requests when the request failed.
+
+        The given network error from the `HttpRequestManager` is logged, and the job is marked as failed.
+        :param reply: The main reply of the server. This reply will most likely not be valid.
+        :param error: The network error (Qt's enum) that occurred.
+        """
+        Logger.error(f"Failed to upload material archive: {error}")
+        self.failed(UploadMaterialsError(catalog.i18nc("@text:error", "Failed to connect to Digital Factory.")))
+
+    def getPrinterSyncStatus(self) -> Dict[str, str]:
+        """
+        For each printer, identified by host_guid, this gives the current status of uploading the material archive.
+
+        The possible states are given in the PrinterStatus enum.
+        :return: A dictionary with printer host_guids as keys, and their status as values.
+        """
+        return self._printer_sync_status
+
+    def failed(self, error: UploadMaterialsError) -> None:
+        """
+        Helper function for when we have a general failure.
+
+        This sets the sync status for all printers to failed, sets the error on
+        the job and the result of the job to FAILED.
+        :param error: An error to show to the user.
+        """
+        self.setResult(self.Result.FAILED)
+        self.setError(error)
+        for printer_id in self._printer_sync_status:
+            self._printer_sync_status[printer_id] = self.PrinterStatus.FAILED.value
+        self.uploadProgressChanged.emit(1.0, self.getPrinterSyncStatus())
+        self.uploadCompleted.emit(self.getResult(), self.getError())
+
+    def _onProcessProgressChanged(self, progress: float) -> None:
+        """
+        When we progress in the process of uploading materials, we not only signal the new progress (float from 0 to 1)
+        but we also signal the current status of every printer. These are emitted as the two parameters of the signal.
+        :param progress: The progress of this job, between 0 and 1.
+        """
+        self.uploadProgressChanged.emit(progress * 0.8, self.getPrinterSyncStatus())  # The processing is 80% of the progress bar.

cura/Settings/ExtruderManager.py

@@ -12,6 +12,7 @@ from UM.Scene.SceneNode import SceneNode
 from UM.Scene.Selection import Selection
 from UM.Scene.Iterator.BreadthFirstIterator import BreadthFirstIterator
 from UM.Settings.ContainerRegistry import ContainerRegistry  # Finding containers by ID.
+from cura.Machines.ContainerTree import ContainerTree
 
 from typing import Any, cast, Dict, List, Optional, TYPE_CHECKING, Union
 
@@ -403,6 +404,35 @@ class ExtruderManager(QObject):
                 raise IndexError(msg)
             extruder_stack_0.definition = extruder_definition
 
+    @pyqtSlot("QVariant", result = bool)
+    def getExtruderHasQualityForMaterial(self, extruder_stack: "ExtruderStack") -> bool:
+        """Checks if quality nodes exist for the variant/material combination."""
+        application = cura.CuraApplication.CuraApplication.getInstance()
+        global_stack = application.getGlobalContainerStack()
+        if not global_stack or not extruder_stack:
+            return False
+
+        if not global_stack.getMetaDataEntry("has_materials"):
+            return True
+
+        machine_node = ContainerTree.getInstance().machines[global_stack.definition.getId()]
+
+        active_variant_name = extruder_stack.variant.getMetaDataEntry("name")
+        if active_variant_name not in machine_node.variants:
+            Logger.log("w", "Could not find the variant %s", active_variant_name)
+            return True
+        active_variant_node = machine_node.variants[active_variant_name]
+        try:
+            active_material_node = active_variant_node.materials[extruder_stack.material.getMetaDataEntry("base_file")]
+        except KeyError:  # The material in this stack is not a supported material (e.g. wrong filament diameter, as loaded from a project file).
+            return False
+
+        active_material_node_qualities = active_material_node.qualities
+        if not active_material_node_qualities:
+            return False
+        return list(active_material_node_qualities.keys())[0] != "empty_quality"
+
+
     @pyqtSlot(str, result="QVariant")
     def getInstanceExtruderValues(self, key: str) -> List:
         """Get all extruder values for a certain setting.

cura/Settings/MachineManager.py

@@ -855,7 +855,6 @@ class MachineManager(QObject):
             caution_message = Message(
                 catalog.i18nc("@info:message Followed by a list of settings.",
                               "Settings have been changed to match the current availability of extruders:") + " [{settings_list}]".format(settings_list = ", ".join(add_user_changes)),
-                lifetime = 0,
                 title = catalog.i18nc("@info:title", "Settings updated"))
             caution_message.show()
 
@@ -1191,7 +1190,7 @@ class MachineManager(QObject):
 
         self.setIntentByCategory(quality_changes_group.intent_category)
         self._reCalculateNumUserSettings()
-
+        self.correctExtruderSettings()
         self.activeQualityGroupChanged.emit()
         self.activeQualityChangesGroupChanged.emit()
 
@@ -1536,7 +1535,7 @@ class MachineManager(QObject):
         machine_node = ContainerTree.getInstance().machines.get(machine_definition_id)
         variant_node = machine_node.variants.get(variant_name)
         if variant_node is None:
-            Logger.error("There is no variant with the name {variant_name}.")
+            Logger.error(f"There is no variant with the name {variant_name}.")
             return
         self.setVariant(position, variant_node)
 

cura/Settings/SettingInheritanceManager.py

@@ -61,6 +61,10 @@ class SettingInheritanceManager(QObject):
                 result.append(key)
         return result
 
+    @pyqtSlot(str, str, result = bool)
+    def hasOverrides(self, key: str, extruder_index: str):
+        return key in self.getOverridesForExtruder(key, extruder_index)
+
     @pyqtSlot(str, str, result = "QStringList")
     def getOverridesForExtruder(self, key: str, extruder_index: str) -> List[str]:
         if self._global_container_stack is None:

cura/Snapshot.py

@@ -3,6 +3,7 @@
 import numpy
 
 from PyQt5 import QtCore
+from PyQt5.QtCore import QCoreApplication
 from PyQt5.QtGui import QImage
 
 from cura.PreviewPass import PreviewPass
@@ -46,6 +47,7 @@ class Snapshot:
         render_width, render_height = (width, height) if active_camera is None else active_camera.getWindowSize()
         render_width = int(render_width)
         render_height = int(render_height)
+        QCoreApplication.processEvents()  # This ensures that the opengl context is correctly available
         preview_pass = PreviewPass(render_width, render_height)
 
         root = scene.getRoot()

cura/UI/CuraSplashScreen.py

@@ -17,7 +17,9 @@ class CuraSplashScreen(QSplashScreen):
         self._scale = 0.7
         self._version_y_offset = 0  # when extra visual elements are in the background image, move version text down
 
-        if ApplicationMetadata.IsEnterpriseVersion:
+        if ApplicationMetadata.IsAlternateVersion:
+            splash_image = QPixmap(Resources.getPath(Resources.Images, "cura_wip.png"))
+        elif ApplicationMetadata.IsEnterpriseVersion:
             splash_image = QPixmap(Resources.getPath(Resources.Images, "cura_enterprise.png"))
             self._version_y_offset = 26
         else:
@@ -70,7 +72,7 @@ class CuraSplashScreen(QSplashScreen):
         font = QFont()  # Using system-default font here
         font.setPixelSize(18)
         painter.setFont(font)
-        painter.drawText(60, 70 + self._version_y_offset, round(330 * self._scale), round(230 * self._scale), Qt.AlignLeft | Qt.AlignTop, version[0])
+        painter.drawText(60, 70 + self._version_y_offset, round(330 * self._scale), round(230 * self._scale), Qt.AlignLeft | Qt.AlignTop, version[0] if not ApplicationMetadata.IsAlternateVersion else ApplicationMetadata.CuraBuildType)
         if len(version) > 1:
             font.setPixelSize(16)
             painter.setFont(font)

cura/UI/TextManager.py

@@ -46,7 +46,9 @@ class TextManager(QObject):
                         line = line.replace("[", "")
                         line = line.replace("]", "")
                         open_version = Version(line)
-                        if open_version > Version([14, 99, 99]):  # Bit of a hack: We released the 15.x.x versions before 2.x
+                        if open_version < Version([0, 0, 1]):  # Something went wrong with parsing, assume non-numerical alternate version that should be on top.
+                            open_version = Version([99, 99, 99])
+                        if Version([14, 99, 99]) < open_version < Version([16, 0, 0]):  # Bit of a hack: We released the 15.x.x versions before 2.x
                             open_version = Version([0, open_version.getMinor(), open_version.getRevision(), open_version.getPostfixVersion()])
                         open_header = ""
                         change_logs_dict[open_version] = collections.OrderedDict()
@@ -66,7 +68,9 @@ class TextManager(QObject):
             text_version = version
             if version < Version([1, 0, 0]):  # Bit of a hack: We released the 15.x.x versions before 2.x
                 text_version = Version([15, version.getMinor(), version.getRevision(), version.getPostfixVersion()])
-            content += "<h1>" + str(text_version) + "</h1><br>"
+            if version > Version([99, 0, 0]):  # Leave it out altogether if it was originally a non-numbered version.
+                text_version = ""
+            content += ("<h1>" + str(text_version) + "</h1><br>") if text_version else ""
             content += ""
             for change in change_logs_dict[version]:
                 if str(change) != "":

cura/UI/WelcomePagesModel.py

@@ -1,7 +1,9 @@
-# Copyright (c) 2019 Ultimaker B.V.
+# Copyright (c) 2021 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
-from collections import deque
+
 import os
+
+from collections import deque
 from typing import TYPE_CHECKING, Optional, List, Dict, Any
 
 from PyQt5.QtCore import QUrl, Qt, pyqtSlot, pyqtProperty, pyqtSignal
@@ -16,24 +18,23 @@ if TYPE_CHECKING:
     from cura.CuraApplication import CuraApplication
 
 
-#
-# This is the Qt ListModel that contains all welcome pages data. Each page is a page that can be shown as a step in the
-# welcome wizard dialog. Each item in this ListModel represents a page, which contains the following fields:
-#
-#  - id           : A unique page_id which can be used in function goToPage(page_id)
-#  - page_url     : The QUrl to the QML file that contains the content of this page
-#  - next_page_id : (OPTIONAL) The next page ID to go to when this page finished. This is optional. If this is not
-#                   provided, it will go to the page with the current index + 1
-#  - next_page_button_text: (OPTIONAL) The text to show for the "next" button, by default it's the translated text of
-#                           "Next". Note that each step QML can decide whether to use this text or not, so it's not
-#                           mandatory.
-#  - should_show_function : (OPTIONAL) An optional function that returns True/False indicating if this page should be
-#                           shown. By default all pages should be shown. If a function returns False, that page will
-#                           be skipped and its next page will be shown.
-#
-# Note that in any case, a page that has its "should_show_function" == False will ALWAYS be skipped.
-#
 class WelcomePagesModel(ListModel):
+    """
+    This is the Qt ListModel that contains all welcome pages data. Each page is a page that can be shown as a step in
+    the welcome wizard dialog. Each item in this ListModel represents a page, which contains the following fields:
+    - id                    : A unique page_id which can be used in function goToPage(page_id)
+    - page_url              : The QUrl to the QML file that contains the content of this page
+    - next_page_id          : (OPTIONAL) The next page ID to go to when this page finished. This is optional. If this is
+                                not provided, it will go to the page with the current index + 1
+    - next_page_button_text : (OPTIONAL) The text to show for the "next" button, by default it's the translated text of
+                                "Next". Note that each step QML can decide whether to use this text or not, so it's not
+                                mandatory.
+    - should_show_function : (OPTIONAL) An optional function that returns True/False indicating if this page should be
+                                shown. By default all pages should be shown. If a function returns False, that page will
+                                be skipped and its next page will be shown.
+
+    Note that in any case, a page that has its "should_show_function" == False will ALWAYS be skipped.
+    """
 
     IdRole = Qt.UserRole + 1  # Page ID
     PageUrlRole = Qt.UserRole + 2  # URL to the page's QML file
@@ -55,11 +56,11 @@ class WelcomePagesModel(ListModel):
 
         self._default_next_button_text = self._catalog.i18nc("@action:button", "Next")
 
-        self._pages = []  # type: List[Dict[str, Any]]
+        self._pages: List[Dict[str, Any]] = []
 
         self._current_page_index = 0
         # Store all the previous page indices so it can go back.
-        self._previous_page_indices_stack = deque()  # type: deque
+        self._previous_page_indices_stack: deque = deque()
 
         # If the welcome flow should be shown. It can show the complete flow or just the changelog depending on the
         # specific case. See initialize() for how this variable is set.
@@ -72,17 +73,21 @@ class WelcomePagesModel(ListModel):
     def currentPageIndex(self) -> int:
         return self._current_page_index
 
-    # Returns a float number in [0, 1] which indicates the current progress.
     @pyqtProperty(float, notify = currentPageIndexChanged)
     def currentProgress(self) -> float:
+        """
+        Returns a float number in [0, 1] which indicates the current progress.
+        """
         if len(self._items) == 0:
             return 0
         else:
             return self._current_page_index / len(self._items)
 
-    # Indicates if the current page is the last page.
     @pyqtProperty(bool, notify = currentPageIndexChanged)
     def isCurrentPageLast(self) -> bool:
+        """
+        Indicates if the current page is the last page.
+        """
         return self._current_page_index == len(self._items) - 1
 
     def _setCurrentPageIndex(self, page_index: int) -> None:
@@ -91,17 +96,22 @@ class WelcomePagesModel(ListModel):
             self._current_page_index = page_index
             self.currentPageIndexChanged.emit()
 
-    # Ends the Welcome-Pages. Put as a separate function for cases like the 'decline' in the User-Agreement.
     @pyqtSlot()
     def atEnd(self) -> None:
+        """
+        Ends the Welcome-Pages. Put as a separate function for cases like the 'decline' in the User-Agreement.
+        """
         self.allFinished.emit()
         self.resetState()
 
-    # Goes to the next page.
-    # If "from_index" is given, it will look for the next page to show starting from the "from_index" page instead of
-    # the "self._current_page_index".
     @pyqtSlot()
     def goToNextPage(self, from_index: Optional[int] = None) -> None:
+        """
+        Goes to the next page.
+        If "from_index" is given, it will look for the next page to show starting from the "from_index" page instead of
+        the "self._current_page_index".
+        """
+
         # Look for the next page that should be shown
         current_index = self._current_page_index if from_index is None else from_index
         while True:
@@ -137,9 +147,11 @@ class WelcomePagesModel(ListModel):
         # Move to the next page
         self._setCurrentPageIndex(next_page_index)
 
-    # Goes to the previous page. If there's no previous page, do nothing.
     @pyqtSlot()
     def goToPreviousPage(self) -> None:
+        """
+        Goes to the previous page. If there's no previous page, do nothing.
+        """
         if len(self._previous_page_indices_stack) == 0:
             Logger.log("i", "No previous page, do nothing")
             return
@@ -148,9 +160,9 @@ class WelcomePagesModel(ListModel):
         self._current_page_index = previous_page_index
         self.currentPageIndexChanged.emit()
 
-    # Sets the current page to the given page ID. If the page ID is not found, do nothing.
     @pyqtSlot(str)
     def goToPage(self, page_id: str) -> None:
+        """Sets the current page to the given page ID. If the page ID is not found, do nothing."""
         page_index = self.getPageIndexById(page_id)
         if page_index is None:
             # FIXME: If we cannot find the next page, we cannot do anything here.
@@ -165,18 +177,22 @@ class WelcomePagesModel(ListModel):
             # Find the next page to show starting from the "page_index"
             self.goToNextPage(from_index = page_index)
 
-    # Checks if the page with the given index should be shown by calling the "should_show_function" associated with it.
-    # If the function is not present, returns True (show page by default).
     def _shouldPageBeShown(self, page_index: int) -> bool:
+        """
+        Checks if the page with the given index should be shown by calling the "should_show_function" associated with
+        it. If the function is not present, returns True (show page by default).
+        """
         next_page_item = self.getItem(page_index)
         should_show_function = next_page_item.get("should_show_function", lambda: True)
         return should_show_function()
 
-    # Resets the state of the WelcomePagesModel. This functions does the following:
-    #  - Resets current_page_index to 0
-    #  - Clears the previous page indices stack
     @pyqtSlot()
     def resetState(self) -> None:
+        """
+        Resets the state of the WelcomePagesModel. This functions does the following:
+            - Resets current_page_index to 0
+            - Clears the previous page indices stack
+        """
         self._current_page_index = 0
         self._previous_page_indices_stack.clear()
 
@@ -188,8 +204,8 @@ class WelcomePagesModel(ListModel):
     def shouldShowWelcomeFlow(self) -> bool:
         return self._should_show_welcome_flow
 
-    # Gets the page index with the given page ID. If the page ID doesn't exist, returns None.
     def getPageIndexById(self, page_id: str) -> Optional[int]:
+        """Gets the page index with the given page ID. If the page ID doesn't exist, returns None."""
         page_idx = None
         for idx, page_item in enumerate(self._items):
             if page_item["id"] == page_id:
@@ -197,8 +213,9 @@ class WelcomePagesModel(ListModel):
                 break
         return page_idx
 
-    # Convenience function to get QUrl path to pages that's located in "resources/qml/WelcomePages".
+    @staticmethod
-    def _getBuiltinWelcomePagePath(self, page_filename: str) -> "QUrl":
+    def _getBuiltinWelcomePagePath(page_filename: str) -> QUrl:
+        """Convenience function to get QUrl path to pages that's located in "resources/qml/WelcomePages"."""
         from cura.CuraApplication import CuraApplication
         return QUrl.fromLocalFile(Resources.getPath(CuraApplication.ResourceTypes.QmlFiles,
                                                     os.path.join("WelcomePages", page_filename)))
@@ -213,21 +230,22 @@ class WelcomePagesModel(ListModel):
         self._initialize()
 
     def _initialize(self, update_should_show_flag: bool = True) -> None:
-        show_whatsnew_only = False
+        show_whats_new_only = False
         if update_should_show_flag:
             has_active_machine = self._application.getMachineManager().activeMachine is not None
             has_app_just_upgraded = self._application.hasJustUpdatedFromOldVersion()
 
             # Only show the what's new dialog if there's no machine and we have just upgraded
             show_complete_flow = not has_active_machine
-            show_whatsnew_only = has_active_machine and has_app_just_upgraded
+            show_whats_new_only = has_active_machine and has_app_just_upgraded
 
             # FIXME: This is a hack. Because of the circular dependency between MachineManager, ExtruderManager, and
-            # possibly some others, setting the initial active machine is not done when the MachineManager gets initialized.
+            # possibly some others, setting the initial active machine is not done when the MachineManager gets
-            # So at this point, we don't know if there will be an active machine or not. It could be that the active machine
+            # initialized. So at this point, we don't know if there will be an active machine or not. It could be that
-            # files are corrupted so we cannot rely on Preferences either. This makes sure that once the active machine
+            # the active machine files are corrupted so we cannot rely on Preferences either. This makes sure that once
-            # gets changed, this model updates the flags, so it can decide whether to show the welcome flow or not.
+            # the active machine gets changed, this model updates the flags, so it can decide whether to show the
-            should_show_welcome_flow = show_complete_flow or show_whatsnew_only
+            # welcome flow or not.
+            should_show_welcome_flow = show_complete_flow or show_whats_new_only
             if should_show_welcome_flow != self._should_show_welcome_flow:
                 self._should_show_welcome_flow = should_show_welcome_flow
                 self.shouldShowWelcomeFlowChanged.emit()
@@ -274,23 +292,25 @@ class WelcomePagesModel(ListModel):
                           ]
 
         pages_to_show = all_pages_list
-        if show_whatsnew_only:
+        if show_whats_new_only:
             pages_to_show = list(filter(lambda x: x["id"] == "whats_new", all_pages_list))
 
         self._pages = pages_to_show
         self.setItems(self._pages)
 
-    # For convenience, inject the default "next" button text to each item if it's not present.
     def setItems(self, items: List[Dict[str, Any]]) -> None:
+        # For convenience, inject the default "next" button text to each item if it's not present.
         for item in items:
             if "next_page_button_text" not in item:
                 item["next_page_button_text"] = self._default_next_button_text
 
         super().setItems(items)
 
-    # Indicates if the machine action panel should be shown by checking if there's any first start machine actions
-    # available.
     def shouldShowMachineActions(self) -> bool:
+        """
+        Indicates if the machine action panel should be shown by checking if there's any first start machine actions
+        available.
+        """
         global_stack = self._application.getMachineManager().activeMachine
         if global_stack is None:
             return False
@@ -312,6 +332,3 @@ class WelcomePagesModel(ListModel):
 
     def addPage(self) -> None:
         pass
-
-
-__all__ = ["WelcomePagesModel"]

cura/UI/WhatsNewPagesModel.py

@@ -1,27 +1,39 @@
 # Copyright (c) 2021 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
-from .WelcomePagesModel import WelcomePagesModel
 
 import os
-from typing import Optional, Dict, List, Tuple
+from typing import Optional, Dict, List, Tuple, TYPE_CHECKING
+
 from PyQt5.QtCore import pyqtProperty, pyqtSlot
+
 from UM.Logger import Logger
 from UM.Resources import Resources
 
-#
+from cura.UI.WelcomePagesModel import WelcomePagesModel
-# This Qt ListModel is more or less the same the WelcomePagesModel, except that this model is only for showing the
+
-# "what's new" page. This is also used in the "Help" menu to show the changes log.
+if TYPE_CHECKING:
-#
+    from PyQt5.QtCore import QObject
+    from cura.CuraApplication import CuraApplication
+
+
 class WhatsNewPagesModel(WelcomePagesModel):
+    """
+    This Qt ListModel is more or less the same the WelcomePagesModel, except that this model is only for showing the
+    "what's new" page. This is also used in the "Help" menu to show the changes log.
+    """
 
     image_formats = [".png", ".jpg", ".jpeg", ".gif", ".svg"]
     text_formats = [".txt", ".htm", ".html"]
     image_key = "image"
     text_key = "text"
 
+    def __init__(self, application: "CuraApplication", parent: Optional["QObject"] = None) -> None:
+        super().__init__(application, parent)
+        self._subpages: List[Dict[str, Optional[str]]] = []
+
     @staticmethod
     def _collectOrdinalFiles(resource_type: int, include: List[str]) -> Tuple[Dict[int, str], int]:
-        result = {}  #type: Dict[int, str]
+        result = {}  # type: Dict[int, str]
         highest = -1
         try:
             folder_path = Resources.getPath(resource_type, "whats_new")
@@ -65,7 +77,7 @@ class WhatsNewPagesModel(WelcomePagesModel):
         texts, max_text = WhatsNewPagesModel._collectOrdinalFiles(Resources.Texts, WhatsNewPagesModel.text_formats)
         highest = max(max_image, max_text)
 
-        self._subpages = []  #type: List[Dict[str, Optional[str]]]
+        self._subpages = []
         for n in range(0, highest + 1):
             self._subpages.append({
                 WhatsNewPagesModel.image_key: None if n not in images else images[n],
@@ -93,5 +105,3 @@ class WhatsNewPagesModel(WelcomePagesModel):
     def getSubpageText(self, page: int) -> str:
         result = self._getSubpageItem(page, WhatsNewPagesModel.text_key)
         return result if result else "* * *"
-
-__all__ = ["WhatsNewPagesModel"]

cura/UltimakerCloud/CloudMaterialSync.py

@@ -0,0 +1,218 @@
+# Copyright (c) 2021 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+
+from PyQt5.QtCore import pyqtProperty, pyqtSignal, pyqtSlot, QObject, QUrl
+from PyQt5.QtGui import QDesktopServices
+from typing import Dict, Optional, TYPE_CHECKING
+import zipfile  # To export all materials in a .zip archive.
+
+import cura.CuraApplication  # Imported like this to prevent circular imports.
+from UM.Resources import Resources
+from cura.PrinterOutput.UploadMaterialsJob import UploadMaterialsJob, UploadMaterialsError  # To export materials to the output printer.
+from cura.Settings.CuraContainerRegistry import CuraContainerRegistry
+from UM.i18n import i18nCatalog
+from UM.Logger import Logger
+from UM.Message import Message
+
+if TYPE_CHECKING:
+    from UM.Signal import Signal
+catalog = i18nCatalog("cura")
+
+class CloudMaterialSync(QObject):
+    """
+    Handles the synchronisation of material profiles with cloud accounts.
+    """
+
+    def __init__(self, parent: QObject = None):
+        super().__init__(parent)
+        self.sync_all_dialog = None  # type: Optional[QObject]
+        self._export_upload_status = "idle"
+        self._checkIfNewMaterialsWereInstalled()
+        self._export_progress = 0.0
+        self._printer_status = {}  # type: Dict[str, str]
+
+    def _checkIfNewMaterialsWereInstalled(self) -> None:
+        """
+        Checks whether new material packages were installed in the latest startup. If there were, then it shows
+        a message prompting the user to sync the materials with their printers.
+        """
+        application = cura.CuraApplication.CuraApplication.getInstance()
+        for package_id, package_data in application.getPackageManager().getPackagesInstalledOnStartup().items():
+            if package_data["package_info"]["package_type"] == "material":
+                # At least one new material was installed
+                self._showSyncNewMaterialsMessage()
+                break
+
+    def openSyncAllWindow(self):
+
+        self.reset()
+
+        if self.sync_all_dialog is None:
+            qml_path = Resources.getPath(cura.CuraApplication.CuraApplication.ResourceTypes.QmlFiles, "Preferences",
+                                         "Materials", "MaterialsSyncDialog.qml")
+            self.sync_all_dialog = cura.CuraApplication.CuraApplication.getInstance().createQmlComponent(
+                qml_path, {})
+        if self.sync_all_dialog is None:  # Failed to load QML file.
+            return
+        self.sync_all_dialog.setProperty("syncModel", self)
+        self.sync_all_dialog.setProperty("pageIndex", 0)  # Return to first page.
+        self.sync_all_dialog.setProperty("hasExportedUsb", False)  # If the user exported USB before, reset that page.
+        self.sync_all_dialog.setProperty("syncStatusText", "")  # Reset any previous error messages.
+        self.sync_all_dialog.show()
+
+    def _showSyncNewMaterialsMessage(self) -> None:
+        sync_materials_message = Message(
+                text = catalog.i18nc("@action:button",
+                                     "Please sync the material profiles with your printers before starting to print."),
+                title = catalog.i18nc("@action:button", "New materials installed"),
+                message_type = Message.MessageType.WARNING,
+                lifetime = 0
+        )
+
+        sync_materials_message.addAction(
+                "sync",
+                name = catalog.i18nc("@action:button", "Sync materials with printers"),
+                icon = "",
+                description = "Sync your newly installed materials with your printers.",
+                button_align = Message.ActionButtonAlignment.ALIGN_RIGHT
+        )
+
+        sync_materials_message.addAction(
+                "learn_more",
+                name = catalog.i18nc("@action:button", "Learn more"),
+                icon = "",
+                description = "Learn more about syncing your newly installed materials with your printers.",
+                button_align = Message.ActionButtonAlignment.ALIGN_LEFT,
+                button_style = Message.ActionButtonStyle.LINK
+        )
+        sync_materials_message.actionTriggered.connect(self._onSyncMaterialsMessageActionTriggered)
+
+        # Show the message only if there are printers that support material export
+        container_registry = cura.CuraApplication.CuraApplication.getInstance().getContainerRegistry()
+        global_stacks = container_registry.findContainerStacks(type = "machine")
+        if any([stack.supportsMaterialExport for stack in global_stacks]):
+            sync_materials_message.show()
+
+    def _onSyncMaterialsMessageActionTriggered(self, sync_message: Message, sync_message_action: str):
+        if sync_message_action == "sync":
+            self.openSyncAllWindow()
+            sync_message.hide()
+        elif sync_message_action == "learn_more":
+            QDesktopServices.openUrl(QUrl("https://support.ultimaker.com/hc/en-us/articles/360013137919?utm_source=cura&utm_medium=software&utm_campaign=sync-material-printer-message"))
+
+    @pyqtSlot(result = QUrl)
+    def getPreferredExportAllPath(self) -> QUrl:
+        """
+        Get the preferred path to export materials to.
+
+        If there is a removable drive, that should be the preferred path. Otherwise it should be the most recent local
+        file path.
+        :return: The preferred path to export all materials to.
+        """
+        cura_application = cura.CuraApplication.CuraApplication.getInstance()
+        device_manager = cura_application.getOutputDeviceManager()
+        devices = device_manager.getOutputDevices()
+        for device in devices:
+            if device.__class__.__name__ == "RemovableDriveOutputDevice":
+                return QUrl.fromLocalFile(device.getId())
+        else:  # No removable drives? Use local path.
+            return cura_application.getDefaultPath("dialog_material_path")
+
+    @pyqtSlot(QUrl)
+    def exportAll(self, file_path: QUrl, notify_progress: Optional["Signal"] = None) -> None:
+        """
+        Export all materials to a certain file path.
+        :param file_path: The path to export the materials to.
+        """
+        registry = CuraContainerRegistry.getInstance()
+
+        # Create empty archive.
+        try:
+            archive = zipfile.ZipFile(file_path.toLocalFile(), "w", compression = zipfile.ZIP_DEFLATED)
+        except OSError as e:
+            Logger.log("e", f"Can't write to destination {file_path.toLocalFile()}: {type(e)} - {str(e)}")
+            error_message = Message(
+                text = catalog.i18nc("@message:text", "Could not save material archive to {}:").format(file_path.toLocalFile()) + " " + str(e),
+                title = catalog.i18nc("@message:title", "Failed to save material archive"),
+                message_type = Message.MessageType.ERROR
+            )
+            error_message.show()
+            return
+
+        materials_metadata = registry.findInstanceContainersMetadata(type = "material")
+        for index, metadata in enumerate(materials_metadata):
+            if notify_progress is not None:
+                progress = index / len(materials_metadata)
+                notify_progress.emit(progress)
+            if metadata["base_file"] != metadata["id"]:  # Only process base files.
+                continue
+            if metadata["id"] == "empty_material":  # Don't export the empty material.
+                continue
+            material = registry.findContainers(id = metadata["id"])[0]
+            suffix = registry.getMimeTypeForContainer(type(material)).preferredSuffix
+            filename = metadata["id"] + "." + suffix
+            try:
+                archive.writestr(filename, material.serialize())
+            except OSError as e:
+                Logger.log("e", f"An error has occurred while writing the material \'{metadata['id']}\' in the file \'{filename}\': {e}.")
+
+    exportUploadStatusChanged = pyqtSignal()
+
+    @pyqtProperty(str, notify = exportUploadStatusChanged)
+    def exportUploadStatus(self) -> str:
+        return self._export_upload_status
+
+    @pyqtSlot()
+    def exportUpload(self) -> None:
+        """
+        Export all materials and upload them to the user's account.
+        """
+        self._export_upload_status = "uploading"
+        self.exportUploadStatusChanged.emit()
+        job = UploadMaterialsJob(self)
+        job.uploadProgressChanged.connect(self._onUploadProgressChanged)
+        job.uploadCompleted.connect(self.exportUploadCompleted)
+        job.start()
+
+    def _onUploadProgressChanged(self, progress: float, printers_status: Dict[str, str]):
+        self.setExportProgress(progress)
+        self.setPrinterStatus(printers_status)
+
+    def exportUploadCompleted(self, job_result: UploadMaterialsJob.Result, job_error: Optional[Exception]):
+        if not self.sync_all_dialog:  # Shouldn't get triggered before the dialog is open, but better to check anyway.
+            return
+        if job_result == UploadMaterialsJob.Result.FAILED:
+            if isinstance(job_error, UploadMaterialsError):
+                self.sync_all_dialog.setProperty("syncStatusText", str(job_error))
+            else:  # Could be "None"
+                self.sync_all_dialog.setProperty("syncStatusText", catalog.i18nc("@text", "Unknown error."))
+            self._export_upload_status = "error"
+        else:
+            self._export_upload_status = "success"
+        self.exportUploadStatusChanged.emit()
+
+    exportProgressChanged = pyqtSignal(float)
+
+    def setExportProgress(self, progress: float) -> None:
+        self._export_progress = progress
+        self.exportProgressChanged.emit(self._export_progress)
+
+    @pyqtProperty(float, fset = setExportProgress, notify = exportProgressChanged)
+    def exportProgress(self) -> float:
+        return self._export_progress
+
+    printerStatusChanged = pyqtSignal()
+
+    def setPrinterStatus(self, new_status: Dict[str, str]) -> None:
+        self._printer_status = new_status
+        self.printerStatusChanged.emit()
+
+    @pyqtProperty("QVariantMap", fset = setPrinterStatus, notify = printerStatusChanged)
+    def printerStatus(self) -> Dict[str, str]:
+        return self._printer_status
+
+    def reset(self) -> None:
+        self.setPrinterStatus({})
+        self.setExportProgress(0.0)
+        self._export_upload_status = "idle"
+        self.exportUploadStatusChanged.emit()

cura/UltimakerCloud/UltimakerCloudConstants.py

@@ -13,6 +13,9 @@ DEFAULT_DIGITAL_FACTORY_URL = "https://digitalfactory.ultimaker.com"  # type: st
 META_UM_LINKED_TO_ACCOUNT = "um_linked_to_account"
 """(bool) Whether a cloud printer is linked to an Ultimaker account"""
 
+META_CAPABILITIES = "capabilities"
+"""(list[str]) a list of capabilities this printer supports"""
+
 try:
     from cura.CuraVersion import CuraCloudAPIRoot  # type: ignore
     if CuraCloudAPIRoot == "":

cura/UltimakerCloud/UltimakerCloudScope.py

@@ -1,9 +1,15 @@
+# Copyright (c) 2021 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+
 from PyQt5.QtNetwork import QNetworkRequest
 
 from UM.Logger import Logger
 from UM.TaskManagement.HttpRequestScope import DefaultUserAgentScope
-from cura.API import Account
+
-from cura.CuraApplication import CuraApplication
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from cura.CuraApplication import CuraApplication
+    from cura.API.Account import Account
 
 
 class UltimakerCloudScope(DefaultUserAgentScope):
@@ -12,7 +18,7 @@ class UltimakerCloudScope(DefaultUserAgentScope):
     Also add the user agent headers (see DefaultUserAgentScope).
     """
 
-    def __init__(self, application: CuraApplication):
+    def __init__(self, application: "CuraApplication"):
         super().__init__(application)
         api = application.getCuraAPI()
         self._account = api.account  # type: Account

cura_app.py

@@ -48,6 +48,8 @@ if with_sentry_sdk:
         sentry_env = "development"  # Master is always a development version.
     elif "beta" in ApplicationMetadata.CuraVersion or "BETA" in ApplicationMetadata.CuraVersion:
         sentry_env = "beta"
+    elif "alpha" in ApplicationMetadata.CuraVersion or "ALPHA" in ApplicationMetadata.CuraVersion:
+        sentry_env = "alpha"
     try:
         if ApplicationMetadata.CuraVersion.split(".")[2] == "99":
             sentry_env = "nightly"

plugins/3MFReader/ThreeMFWorkspaceReader.py

@@ -49,7 +49,9 @@ _ignored_machine_network_metadata = {
     "removal_warning",
     "group_name",
     "group_size",
-    "connection_type"
+    "connection_type",
+    "capabilities",
+    "octoprint_api_key",
 }  # type: Set[str]
 
 
@@ -377,7 +379,9 @@ class ThreeMFWorkspaceReader(WorkspaceReader):
         #  - the global stack DOESN'T exist but some/all of the extruder stacks exist
         # To simplify this, only check if the global stack exists or not
         global_stack_id = self._stripFileToId(global_stack_file)
+
         serialized = archive.open(global_stack_file).read().decode("utf-8")
+
         serialized = GlobalStack._updateSerialized(serialized, global_stack_file)
         machine_name = self._getMachineNameFromSerializedStack(serialized)
         self._machine_info.metadata_dict = self._getMetaDataDictFromSerializedStack(serialized)

plugins/3MFWriter/ThreeMFWorkspaceWriter.py

@@ -32,6 +32,12 @@ class ThreeMFWorkspaceWriter(WorkspaceWriter):
             Logger.error("3MF Writer class is unavailable. Can't write workspace.")
             return False
 
+        global_stack = machine_manager.activeMachine
+        if global_stack is None:
+            self.setInformation(catalog.i18nc("@error", "There is no workspace yet to write. Please add a printer first."))
+            Logger.error("Tried to write a 3MF workspace before there was a global stack.")
+            return False
+
         # Indicate that the 3mf mesh writer should not close the archive just yet (we still need to add stuff to it).
         mesh_writer.setStoreArchive(True)
         mesh_writer.write(stream, nodes, mode)
@@ -40,7 +46,6 @@ class ThreeMFWorkspaceWriter(WorkspaceWriter):
         if archive is None:  # This happens if there was no mesh data to write.
             archive = zipfile.ZipFile(stream, "w", compression = zipfile.ZIP_DEFLATED)
 
-        global_stack = machine_manager.activeMachine
 
         try:
             # Add global container stack data to the archive.
@@ -149,7 +154,8 @@ class ThreeMFWorkspaceWriter(WorkspaceWriter):
                 "group_name",
                 "group_size",
                 "connection_type",
-                "octoprint_api_key"
+                "capabilities",
+                "octoprint_api_key",
             }
             serialized_data = container.serialize(ignored_metadata_keys = ignore_keys)
 

plugins/3MFWriter/ThreeMFWriter.py

@@ -10,6 +10,10 @@ from UM.Application import Application
 from UM.Scene.SceneNode import SceneNode
 
 from cura.CuraApplication import CuraApplication
+from cura.Utils.Threading import call_on_qt_thread
+from cura.Snapshot import Snapshot
+
+from PyQt5.QtCore import QBuffer
 
 import Savitar
 
@@ -149,6 +153,22 @@ class ThreeMFWriter(MeshWriter):
             relations_element = ET.Element("Relationships", xmlns = self._namespaces["relationships"])
             model_relation_element = ET.SubElement(relations_element, "Relationship", Target = "/3D/3dmodel.model", Id = "rel0", Type = "http://schemas.microsoft.com/3dmanufacturing/2013/01/3dmodel")
 
+            # Attempt to add a thumbnail
+            snapshot = self._createSnapshot()
+            if snapshot:
+                thumbnail_buffer = QBuffer()
+                thumbnail_buffer.open(QBuffer.ReadWrite)
+                snapshot.save(thumbnail_buffer, "PNG")
+
+                thumbnail_file = zipfile.ZipInfo("Metadata/thumbnail.png")
+                # Don't try to compress snapshot file, because the PNG is pretty much as compact as it will get
+                archive.writestr(thumbnail_file, thumbnail_buffer.data())
+
+                # Add PNG to content types file
+                thumbnail_type = ET.SubElement(content_types, "Default", Extension = "png", ContentType = "image/png")
+                # Add thumbnail relation to _rels/.rels file
+                thumbnail_relation_element = ET.SubElement(relations_element, "Relationship", Target = "/Metadata/thumbnail.png", Id = "rel1", Type = "http://schemas.openxmlformats.org/package/2006/relationships/metadata/thumbnail")
+
             savitar_scene = Savitar.Scene()
 
             metadata_to_store = CuraApplication.getInstance().getController().getScene().getMetaData()
@@ -212,3 +232,17 @@ class ThreeMFWriter(MeshWriter):
                 self._archive = archive
 
         return True
+
+    @call_on_qt_thread  # must be called from the main thread because of OpenGL
+    def _createSnapshot(self):
+        Logger.log("d", "Creating thumbnail image...")
+        if not CuraApplication.getInstance().isVisible:
+            Logger.log("w", "Can't create snapshot when renderer not initialized.")
+            return None
+        try:
+            snapshot = Snapshot.snapshot(width = 300, height = 300)
+        except:
+            Logger.logException("w", "Failed to create snapshot image")
+            return None
+
+        return snapshot

plugins/CuraEngineBackend/StartSliceJob.py

@@ -123,6 +123,9 @@ class StartSliceJob(Job):
             Job.yieldThread()
 
         for changed_setting_key in changed_setting_keys:
+            if not stack.getProperty(changed_setting_key, "enabled"):
+                continue
+
             validation_state = stack.getProperty(changed_setting_key, "validationState")
 
             if validation_state is None:

plugins/DigitalLibrary/src/DigitalFactoryController.py

@@ -261,7 +261,10 @@ class DigitalFactoryController(QObject):
         """
         Error function, called whenever the retrieval of the files in a library project fails.
         """
-        Logger.log("w", "Failed to retrieve the list of files in project '{}' from the Digital Library".format(self._project_model._projects[self._selected_project_idx]))
+        try:
+            Logger.warning(f"Failed to retrieve the list of files in project '{self._project_model._projects[self._selected_project_idx]}' from the Digital Library")
+        except IndexError:
+            Logger.warning(f"Failed to retrieve the list of files in a project from the Digital Library. And failed to get the project too.")
         self.setRetrievingFilesStatus(RetrievalStatus.Failed)
 
     @pyqtSlot()

plugins/GCodeReader/FlavorParser.py

@@ -198,7 +198,7 @@ class FlavorParser:
 
             # Only when extruding we can determine the latest known "layer height" which is the difference in height between extrusions
             # Also, 1.5 is a heuristic for any priming or whatsoever, we skip those.
-            if z > self._previous_z and (z - self._previous_z < 1.5):
+            if z > self._previous_z and (z - self._previous_z < 1.5) and (params.x is not None or params.y is not None):
                 self._current_layer_thickness = z - self._previous_z # allow a tiny overlap
                 self._previous_z = z
         elif self._previous_extrusion_value > e[self._extruder_number]:

plugins/PostProcessingPlugin/scripts/ChangeAtZ.py

@@ -11,6 +11,8 @@
 # Modified by Jaime van Kessel (Ultimaker), j.vankessel@ultimaker.com to make it work for 15.10 / 2.x
 # Modified by Ghostkeeper (Ultimaker), rubend@tutanota.com, to debug.
 # Modified by Wes Hanney, https://github.com/novamxd, Retract Length + Speed, Clean up
+# Modified by Alex Jaxon, https://github.com/legend069, Added option to modify Build Volume Temperature
+
 
 # history / changelog:
 # V3.0.1:   TweakAtZ-state default 1 (i.e. the plugin works without any TweakAtZ comment)
@@ -33,13 +35,17 @@
 # V5.0:		Bugfix for fall back after one layer and doubled G0 commands when using print speed tweak, Initial version for Cura 2.x
 # V5.0.1:	Bugfix for calling unknown property 'bedTemp' of previous settings storage and unknown variable 'speed'
 # V5.1:		API Changes included for use with Cura 2.2
-# V5.2.0:	Wes Hanney. Added support for changing Retract Length and Speed. Removed layer spread option. Fixed issue of cumulative ChangeZ
+# V5.2.0:	Wes Hanney. Added support for changing Retract Length and Speed. Removed layer spread option. Fixed issue of cumulative ChangeAtZ
 # mods so they can now properly be stacked on top of each other. Applied code refactoring to clean up various coding styles. Added comments.
 # Broke up functions for clarity. Split up class so it can be debugged outside of Cura.
 # V5.2.1:	Wes Hanney. Added support for firmware based retractions. Fixed issue of properly restoring previous values in single layer option.
 # Added support for outputting changes to LCD (untested). Added type hints to most functions and variables. Added more comments. Created GCodeCommand
 # class for better detection of G1 vs G10 or G11 commands, and accessing arguments. Moved most GCode methods to GCodeCommand class. Improved wording
 # of Single Layer vs Keep Layer to better reflect what was happening.
+# V5.3.0    Alex Jaxon, Added option to modify Build Volume Temperature keeping current format
+#
+
+
 
 # Uses -
 # M220 S<factor in percent> - set speed factor override percentage
@@ -56,9 +62,9 @@ from ..Script import Script
 import re
 
 
-# this was broken up into a separate class so the main ChangeZ script could be debugged outside of Cura
+# this was broken up into a separate class so the main ChangeAtZ script could be debugged outside of Cura
 class ChangeAtZ(Script):
-    version = "5.2.1"
+    version = "5.3.0"
 
     def getSettingDataString(self):
         return """{
@@ -69,10 +75,10 @@ class ChangeAtZ(Script):
             "settings": {
                 "caz_enabled": {
                     "label": "Enabled",
-                    "description": "Allows adding multiple ChangeZ mods and disabling them as needed.",
+                    "description": "Allows adding multiple ChangeAtZ mods and disabling them as needed.",
                     "type": "bool",
                     "default_value": true
-                },             
+                },
                 "a_trigger": {
                     "label": "Trigger",
                     "description": "Trigger at height or at layer no.",
@@ -119,7 +125,7 @@ class ChangeAtZ(Script):
                     "description": "Displays the current changes to the LCD",
                     "type": "bool",
                     "default_value": false
-                },                                                         
+                },
                 "e1_Change_speed": {
                     "label": "Change Speed",
                     "description": "Select if total speed (print and travel) has to be changed",
@@ -222,6 +228,23 @@ class ChangeAtZ(Script):
                     "maximum_value_warning": "120",
                     "enabled": "h1_Change_bedTemp"
                 },
+                "h1_Change_buildVolumeTemperature": {
+                    "label": "Change Build Volume Temperature",
+                    "description": "Select if Build Volume Temperature has to be changed",
+                    "type": "bool",
+                    "default_value": false
+                },
+                "h2_buildVolumeTemperature": {
+                    "label": "Build Volume Temperature",
+                    "description": "New Build Volume Temperature",
+                    "unit": "C",
+                    "type": "float",
+                    "default_value": 20,
+                    "minimum_value": "0",
+                    "minimum_value_warning": "10",
+                    "maximum_value_warning": "50",
+                    "enabled": "h1_Change_buildVolumeTemperature"
+                },
                 "i1_Change_extruderOne": {
                     "label": "Change Extruder 1 Temp",
                     "description": "Select if First Extruder Temperature has to be changed",
@@ -278,25 +301,25 @@ class ChangeAtZ(Script):
                     "description": "Indicates you would like to modify retraction properties.",
                     "type": "bool",
                     "default_value": false
-                },                  
+                },
                 "caz_retractstyle": {
                     "label": "Retract Style",
                     "description": "Specify if you're using firmware retraction or linear move based retractions. Check your printer settings to see which you're using.",
                     "type": "enum",
                     "options": {
-                        "linear": "Linear Move",                       
+                        "linear": "Linear Move",
                         "firmware": "Firmware"
                     },
                     "default_value": "linear",
                     "enabled": "caz_change_retract"
-                },                  
+                },
                 "caz_change_retractfeedrate": {
                     "label": "Change Retract Feed Rate",
                     "description": "Changes the retraction feed rate during print",
                     "type": "bool",
                     "default_value": false,
                     "enabled": "caz_change_retract"
-                },                
+                },
                 "caz_retractfeedrate": {
                     "label": "Retract Feed Rate",
                     "description": "New Retract Feed Rate (mm/s)",
@@ -325,7 +348,7 @@ class ChangeAtZ(Script):
                     "minimum_value_warning": "0",
                     "maximum_value_warning": "20",
                     "enabled": "caz_change_retractlength"
-                }            
+                }      
             }
         }"""
 
@@ -345,6 +368,7 @@ class ChangeAtZ(Script):
         self.setIntSettingIfEnabled(caz_instance, "g3_Change_flowrateOne", "flowrateOne", "g4_flowrateOne")
         self.setIntSettingIfEnabled(caz_instance, "g5_Change_flowrateTwo", "flowrateTwo", "g6_flowrateTwo")
         self.setFloatSettingIfEnabled(caz_instance, "h1_Change_bedTemp", "bedTemp", "h2_bedTemp")
+        self.setFloatSettingIfEnabled(caz_instance, "h1_Change_buildVolumeTemperature", "buildVolumeTemperature", "h2_buildVolumeTemperature")
         self.setFloatSettingIfEnabled(caz_instance, "i1_Change_extruderOne", "extruderOne", "i2_extruderOne")
         self.setFloatSettingIfEnabled(caz_instance, "i3_Change_extruderTwo", "extruderTwo", "i4_extruderTwo")
         self.setIntSettingIfEnabled(caz_instance, "j1_Change_fanSpeed", "fanSpeed", "j2_fanSpeed")
@@ -776,6 +800,10 @@ class ChangeAtZProcessor:
         if "bedTemp" in values:
             codes.append("BedTemp: " + str(round(values["bedTemp"])))
 
+        # looking for wait for Build Volume Temperature
+        if "buildVolumeTemperature" in values:
+            codes.append("buildVolumeTemperature: " + str(round(values["buildVolumeTemperature"])))
+
         # set our extruder one temp (if specified)
         if "extruderOne" in values:
             codes.append("Extruder 1 Temp: " + str(round(values["extruderOne"])))
@@ -858,6 +886,10 @@ class ChangeAtZProcessor:
         if "bedTemp" in values:
             codes.append("M140 S" + str(values["bedTemp"]))
 
+        # looking for wait for Build Volume Temperature
+        if "buildVolumeTemperature" in values:
+            codes.append("M141 S" + str(values["buildVolumeTemperature"]))
+
         # set our extruder one temp (if specified)
         if "extruderOne" in values:
             codes.append("M104 S" + str(values["extruderOne"]) + " T0")
@@ -943,7 +975,7 @@ class ChangeAtZProcessor:
         # nothing to do
         return ""
 
-    # Returns the unmodified GCODE line from previous ChangeZ edits
+    # Returns the unmodified GCODE line from previous ChangeAtZ edits
     @staticmethod
     def getOriginalLine(line: str) -> str:
 
@@ -990,7 +1022,7 @@ class ChangeAtZProcessor:
             else:
                 return self.currentZ >= self.targetZ
 
-    # Marks any current ChangeZ layer defaults in the layer for deletion
+    # Marks any current ChangeAtZ layer defaults in the layer for deletion
     @staticmethod
     def markChangesForDeletion(layer: str):
         return re.sub(r";\[CAZD:", ";[CAZD:DELETE:", layer)
@@ -1288,7 +1320,7 @@ class ChangeAtZProcessor:
         # flag that we're inside our target layer
         self.insideTargetLayer = True
 
-    # Removes all the ChangeZ layer defaults from the given layer
+    # Removes all the ChangeAtZ layer defaults from the given layer
     @staticmethod
     def removeMarkedChanges(layer: str) -> str:
         return re.sub(r";\[CAZD:DELETE:[\s\S]+?:CAZD\](\n|$)", "", layer)
@@ -1364,6 +1396,16 @@ class ChangeAtZProcessor:
             # move to the next command
             return
 
+        # handle Build Volume Temperature changes, really shouldn't want to wait for enclousure temp mid print though.
+        if command.command == "M141" or command.command == "M191":
+
+            # get our bed temp if provided
+            if "S" in command.arguments:
+                self.lastValues["buildVolumeTemperature"] = command.getArgumentAsFloat("S")
+
+            # move to the next command
+            return
+
         # handle extruder temp changes
         if command.command == "M104" or command.command == "M109":
 

plugins/PostProcessingPlugin/scripts/PauseAtHeight.py

@@ -458,7 +458,7 @@ class PauseAtHeight(Script):
 
                     # Optionally extrude material
                     if extrude_amount != 0:
-                        prepend_gcode += self.putValue(G = 1, E = extrude_amount, F = 200) + "\n"
+                        prepend_gcode += self.putValue(G = 1, E = extrude_amount, F = 200) + "; Extra extrude after the unpause\n"
                         prepend_gcode += self.putValue("@info wait for cleaning nozzle from previous filament") + "\n"
                         prepend_gcode += self.putValue("@pause remove the waste filament from parking area and press continue printing") + "\n"
 
@@ -479,7 +479,15 @@ class PauseAtHeight(Script):
                     else:
                         Logger.log("w", "No previous feedrate found in gcode, feedrate for next layer(s) might be incorrect")
 
-                    prepend_gcode += self.putValue(M = 82) + "\n"
+                    extrusion_mode_string = "absolute"
+                    extrusion_mode_numeric = 82
+
+                    relative_extrusion = Application.getInstance().getGlobalContainerStack().getProperty("relative_extrusion", "value")
+                    if relative_extrusion:
+                        extrusion_mode_string = "relative"
+                        extrusion_mode_numeric = 83
+
+                    prepend_gcode += self.putValue(M = extrusion_mode_numeric) + " ; switch back to " + extrusion_mode_string + " E values\n"
 
                     # reset extrude value to pre pause value
                     prepend_gcode += self.putValue(G = 92, E = current_e) + "\n"
@@ -489,18 +497,17 @@ class PauseAtHeight(Script):
                         # Set extruder resume temperature
                         prepend_gcode += self.putValue(M = 109, S = int(target_temperature.get(current_t, 0))) + " ; resume temperature\n"
 
-                    # Push the filament back,
+                    if extrude_amount != 0:  # Need to prime after the pause.
-                    if retraction_amount != 0:
+                        # Push the filament back.
-                        prepend_gcode += self.putValue(G = 1, E = retraction_amount, F = retraction_speed * 60) + "\n"
+                        if retraction_amount != 0:
+                            prepend_gcode += self.putValue(G = 1, E = retraction_amount, F = retraction_speed * 60) + "\n"
 
-                    # Optionally extrude material
+                        # Prime the material.
-                    if extrude_amount != 0:
+                        prepend_gcode += self.putValue(G = 1, E = extrude_amount, F = extrude_speed * 60) + "; Extra extrude after the unpause\n"
-                        prepend_gcode += self.putValue(G = 1, E = extrude_amount, F = extrude_speed * 60) + "\n"
 
-                    # and retract again, the properly primes the nozzle
+                        # And retract again to make the movements back to the starting position.
-                    # when changing filament.
+                        if retraction_amount != 0:
-                    if retraction_amount != 0:
+                            prepend_gcode += self.putValue(G = 1, E = -retraction_amount, F = retraction_speed * 60) + "\n"
-                        prepend_gcode += self.putValue(G = 1, E = -retraction_amount, F = retraction_speed * 60) + "\n"
 
                     # Move the head back
                     if park_enabled:

plugins/SentryLogger/SentryLogger.py

@@ -11,7 +11,6 @@ try:
 except ImportError:
     pass
 from typing import Optional
-import os
 
 
 class SentryLogger(LogOutput):

plugins/SimulationView/SimulationPass.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2020 Ultimaker B.V.
+# Copyright (c) 2021 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
 from UM.Math.Color import Color

plugins/SimulationView/layers3d.shader

@@ -56,12 +56,12 @@ vertex41core =
             value = (abs_value - min_value) / (max_value - min_value);
         }
         float red = value;
-        float green = 1-abs(1-4*value);
+        float green = 1.0 - abs(1.0 - 4.0 * value);
         if (value > 0.375)
         {
             green = 0.5;
         }
-        float blue = max(1-4*value, 0);
+        float blue = max(1.0 - 4.0 * value, 0.0);
         return vec4(red, green, blue, 1.0);
     }
 
@@ -76,7 +76,7 @@ vertex41core =
         {
             value = (abs_value - min_value) / (max_value - min_value);
         }
-        float red = min(max(4*value-2, 0), 1);
+        float red = min(max(4.0 * value - 2.0, 0.0), 1.0);
         float green = min(1.5*value, 0.75);
         if (value > 0.75)
         {
@@ -98,18 +98,18 @@ vertex41core =
             value = (abs_value - min_value) / (max_value - min_value);
         }
         float red = value;
-        float green = 1 - abs(1 - 4 * value);
+        float green = 1.0 - abs(1.0 - 4.0 * value);
         if(value > 0.375)
         {
             green = 0.5;
         }
-        float blue = max(1 - 4 * value, 0);
+        float blue = max(1.0 - 4.0 * value, 0.0);
         return vec4(red, green, blue, 1.0);
     }
 
     float clamp(float v)
     {
-        float t = v < 0 ? 0 : v;
+        float t = v < 0.0 ? 0.0 : v;
         return t > 1.0 ? 1.0 : t;
     }
 

plugins/SimulationView/plugin.json

@@ -2,7 +2,7 @@
     "name": "Simulation View",
     "author": "Ultimaker B.V.",
     "version": "1.0.1",
-    "description": "Provides the Simulation view.",
+    "description": "Provides the preview of sliced layerdata.",
     "api": 7,
     "i18n-catalog": "cura"
 }

plugins/SupportEraser/SupportEraser.py

@@ -6,6 +6,7 @@ from PyQt5.QtWidgets import QApplication
 
 from UM.Application import Application
 from UM.Math.Vector import Vector
+from UM.Operations.TranslateOperation import TranslateOperation
 from UM.Tool import Tool
 from UM.Event import Event, MouseEvent
 from UM.Mesh.MeshBuilder import MeshBuilder
@@ -120,8 +121,8 @@ class SupportEraser(Tool):
         # First add node to the scene at the correct position/scale, before parenting, so the eraser mesh does not get scaled with the parent
         op.addOperation(AddSceneNodeOperation(node, self._controller.getScene().getRoot()))
         op.addOperation(SetParentOperation(node, parent))
+        op.addOperation(TranslateOperation(node, position, set_position = True))
         op.push()
-        node.setPosition(position, CuraSceneNode.TransformSpace.World)
 
         CuraApplication.getInstance().getController().getScene().sceneChanged.emit(node)
 

plugins/Toolbox/src/CloudSync/CloudPackageChecker.py

@@ -66,7 +66,7 @@ class CloudPackageChecker(QObject):
         self._application.getHttpRequestManager().get(url,
                                                       callback = self._onUserPackagesRequestFinished,
                                                       error_callback = self._onUserPackagesRequestFinished,
-                                                      timeout=10,
+                                                      timeout = 10,
                                                       scope = self._scope)
 
     def _onUserPackagesRequestFinished(self, reply: "QNetworkReply", error: Optional["QNetworkReply.NetworkError"] = None) -> None:

plugins/UFPReader/plugin.json

@@ -3,6 +3,6 @@
     "author": "Ultimaker B.V.",
     "version": "1.0.0",
     "description": "Provides support for reading Ultimaker Format Packages.",
-    "supported_sdk_versions": ["7.8.0"],
+    "supported_sdk_versions": ["7.9.0"],
     "i18n-catalog": "cura"
 }

plugins/UM3NetworkPrinting/resources/qml/MonitorPrintJobProgressBar.qml

@@ -73,6 +73,8 @@ Item
             switch (printJob.state)
             {
                 case "wait_cleanup":
+                    // This hack was removed previously. Then we found out that we don't get back 'aborted_wait_cleanup'
+                    // for the UM2+C it seems. Will communicate this to other teams, in the mean time, put this back.
                     if (printJob.timeTotal > printJob.timeElapsed)
                     {
                         return catalog.i18nc("@label:status", "Aborted");
@@ -88,6 +90,20 @@ Item
                     return catalog.i18nc("@label:status", "Aborting...");
                 case "aborted": // NOTE: Unused, see above
                     return catalog.i18nc("@label:status", "Aborted");
+                case "aborted_post_print":
+                    return catalog.i18nc("@label:status", "Aborted");
+                case "aborted_wait_user_action":
+                    return catalog.i18nc("@label:status", "Aborted");
+                case "aborted_wait_cleanup":
+                    return catalog.i18nc("@label:status", "Aborted");
+                case "failed":
+                    return catalog.i18nc("@label:status", "Failed");
+                case "failed_post_print":
+                    return catalog.i18nc("@label:status", "Failed");
+                case "failed_wait_user_action":
+                    return catalog.i18nc("@label:status", "Failed");
+                case "failed_wait_cleanup":
+                    return catalog.i18nc("@label:status", "Failed");
                 case "pausing":
                     return catalog.i18nc("@label:status", "Pausing...");
                 case "paused":
@@ -97,7 +113,7 @@ Item
                 case "queued":
                     return catalog.i18nc("@label:status", "Action required");
                 default:
-                    return catalog.i18nc("@label:status", "Finishes %1 at %2".arg(OutputDevice.getDateCompleted(printJob.timeRemaining)).arg(OutputDevice.getTimeCompleted(printJob.timeRemaining)));
+                    return catalog.i18nc("@label:status", "Finishes %1 at %2").arg(OutputDevice.getDateCompleted(printJob.timeRemaining)).arg(OutputDevice.getTimeCompleted(printJob.timeRemaining));
             }
         }
         width: contentWidth

plugins/UM3NetworkPrinting/src/Cloud/CloudOutputDeviceManager.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2020 Ultimaker B.V.
+# Copyright (c) 2021 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
 import os
@@ -16,9 +16,10 @@ from UM.Util import parseBool
 from cura.API import Account
 from cura.API.Account import SyncState
 from cura.CuraApplication import CuraApplication
+from cura.Settings.CuraContainerRegistry import CuraContainerRegistry  # To update printer metadata with information received about cloud printers.
 from cura.Settings.CuraStackBuilder import CuraStackBuilder
 from cura.Settings.GlobalStack import GlobalStack
-from cura.UltimakerCloud.UltimakerCloudConstants import META_UM_LINKED_TO_ACCOUNT
+from cura.UltimakerCloud.UltimakerCloudConstants import META_CAPABILITIES, META_UM_LINKED_TO_ACCOUNT
 from .CloudApiClient import CloudApiClient
 from .CloudOutputDevice import CloudOutputDevice
 from ..Models.Http.CloudClusterResponse import CloudClusterResponse
@@ -127,8 +128,12 @@ class CloudOutputDeviceManager:
                 # to the current account
                 if not parseBool(self._um_cloud_printers[device_id].getMetaDataEntry(META_UM_LINKED_TO_ACCOUNT, "true")):
                     self._um_cloud_printers[device_id].setMetaDataEntry(META_UM_LINKED_TO_ACCOUNT, True)
+                if not self._um_cloud_printers[device_id].getMetaDataEntry(META_CAPABILITIES, None):
+                    self._um_cloud_printers[device_id].setMetaDataEntry(META_CAPABILITIES, ",".join(cluster_data.capabilities))
         self._onDevicesDiscovered(new_clusters)
 
+        self._updateOnlinePrinters(all_clusters)
+
         # Hide the current removed_printers_message, if there is any
         if self._removed_printers_message:
             self._removed_printers_message.actionTriggered.disconnect(self._onRemovedPrintersMessageActionTriggered)
@@ -154,6 +159,8 @@ class CloudOutputDeviceManager:
         self._syncing = False
         self._account.setSyncState(self.SYNC_SERVICE_NAME, SyncState.SUCCESS)
 
+        Logger.debug("Synced cloud printers with account.")
+
     def _onGetRemoteClusterFailed(self, reply: QNetworkReply, error: QNetworkReply.NetworkError) -> None:
         self._syncing = False
         self._account.setSyncState(self.SYNC_SERVICE_NAME, SyncState.ERROR)
@@ -255,6 +262,16 @@ class CloudOutputDeviceManager:
         message_text = self.i18n_catalog.i18nc("info:status", "Printers added from Digital Factory:") + "<ul>" + device_names + "</ul>"
         message.setText(message_text)
 
+    def _updateOnlinePrinters(self, printer_responses: Dict[str, CloudClusterResponse]) -> None:
+        """
+        Update the metadata of the printers to store whether they are online or not.
+        :param printer_responses: The responses received from the API about the printer statuses.
+        """
+        for container_stack in CuraContainerRegistry.getInstance().findContainerStacks(type = "machine"):
+            cluster_id = container_stack.getMetaDataEntry("um_cloud_cluster_id", "")
+            if cluster_id in printer_responses:
+                container_stack.setMetaDataEntry("is_online", printer_responses[cluster_id].is_online)
+
     def _updateOutdatedMachine(self, outdated_machine: GlobalStack, new_cloud_output_device: CloudOutputDevice) -> None:
         """
          Update the cloud metadata of a pre-existing machine that is rediscovered (e.g. if the printer was removed and

plugins/UM3NetworkPrinting/src/Models/Http/CloudClusterResponse.py

@@ -37,7 +37,7 @@ class CloudClusterResponse(BaseModel):
         self.friendly_name = friendly_name
         self.printer_type = printer_type
         self.printer_count = printer_count
-        self.capabilities = capabilities
+        self.capabilities = capabilities if capabilities is not None else []
         super().__init__(**kwargs)
 
     # Validates the model, raising an exception if the model is invalid.
@@ -45,3 +45,10 @@ class CloudClusterResponse(BaseModel):
         super().validate()
         if not self.cluster_id:
             raise ValueError("cluster_id is required on CloudCluster")
+
+    def __repr__(self) -> str:
+        """
+        Convenience function for printing when debugging.
+        :return: A human-readable representation of the data in this object.
+        """
+        return str({k: v for k, v in self.__dict__.items() if k in {"cluster_id", "host_guid", "host_name", "status", "is_online", "host_version", "host_internal_ip", "friendly_name", "printer_type", "printer_count", "capabilities"}})

plugins/UM3NetworkPrinting/src/Models/Http/ClusterPrintJobStatus.py

@@ -40,7 +40,7 @@ class ClusterPrintJobStatus(BaseModel):
                  configuration_changes_required: List[
                      Union[Dict[str, Any], ClusterPrintJobConfigurationChange]] = None,
                  build_plate: Union[Dict[str, Any], ClusterBuildPlate] = None,
-                 compatible_machine_families: List[str] = None,
+                 compatible_machine_families: Optional[List[str]] = None,
                  impediments_to_printing: List[Union[Dict[str, Any], ClusterPrintJobImpediment]] = None,
                  preview_url: Optional[str] = None,
                  **kwargs) -> None:
@@ -97,7 +97,7 @@ class ClusterPrintJobStatus(BaseModel):
                                                                configuration_changes_required) \
             if configuration_changes_required else []
         self.build_plate = self.parseModel(ClusterBuildPlate, build_plate) if build_plate else None
-        self.compatible_machine_families = compatible_machine_families if compatible_machine_families else []
+        self.compatible_machine_families = compatible_machine_families if compatible_machine_families is not None else []
         self.impediments_to_printing = self.parseModels(ClusterPrintJobImpediment, impediments_to_printing) \
             if impediments_to_printing else []
 
@@ -130,8 +130,10 @@ class ClusterPrintJobStatus(BaseModel):
 
         model.updateConfiguration(self._createConfigurationModel())
         model.updateTimeTotal(self.time_total)
-        model.updateTimeElapsed(self.time_elapsed)
+        if self.time_elapsed is not None:
-        model.updateOwner(self.owner)
+            model.updateTimeElapsed(self.time_elapsed)
+        if self.owner is not None:
+            model.updateOwner(self.owner)
         model.updateState(self.status)
         model.setCompatibleMachineFamilies(self.compatible_machine_families)
 

plugins/VersionUpgrade/VersionUpgrade411to412/VersionUpgrade411to412.py

@@ -3,6 +3,7 @@
 
 import configparser
 import io
+import json
 import os.path
 from typing import List, Tuple
 
@@ -49,6 +50,28 @@ class VersionUpgrade411to412(VersionUpgrade):
         # Update version number.
         parser["metadata"]["setting_version"] = "19"
 
+        # If the account scope in 4.11 is outdated, delete it so that the user is enforced to log in again and get the
+        # correct permissions.
+        new_scopes = {"account.user.read",
+                      "drive.backup.read",
+                      "drive.backup.write",
+                      "packages.download",
+                      "packages.rating.read",
+                      "packages.rating.write",
+                      "connect.cluster.read",
+                      "connect.cluster.write",
+                      "library.project.read",
+                      "library.project.write",
+                      "cura.printjob.read",
+                      "cura.printjob.write",
+                      "cura.mesh.read",
+                      "cura.mesh.write",
+                      "cura.material.write"}
+        if "ultimaker_auth_data" in parser["general"]:
+            ultimaker_auth_data = json.loads(parser["general"]["ultimaker_auth_data"])
+            if new_scopes - set(ultimaker_auth_data["scope"].split(" ")):
+                parser["general"]["ultimaker_auth_data"] = "{}"
+
         result = io.StringIO()
         parser.write(result)
         return [filename], [result.getvalue()]

plugins/VersionUpgrade/VersionUpgrade49to50/VersionUpgrade49to50.py

@@ -0,0 +1,118 @@
+# Copyright (c) 2021 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+
+import configparser
+from typing import Tuple, List
+import io
+from UM.VersionUpgrade import VersionUpgrade
+
+_removed_settings = {
+    "travel_compensate_overlapping_walls_enabled",
+    "travel_compensate_overlapping_walls_0_enabled",
+    "travel_compensate_overlapping_walls_x_enabled",
+    "fill_perimeter_gaps",
+    "wall_min_flow",
+    "wall_min_flow_retract",
+    "speed_equalize_flow_enabled",
+    "speed_equalize_flow_min"
+}
+
+
+class VersionUpgrade49to50(VersionUpgrade):
+    def upgradePreferences(self, serialized: str, filename: str) -> Tuple[List[str], List[str]]:
+        """
+        Upgrades preferences to remove from the visibility list the settings that were removed in this version.
+        It also changes the preferences to have the new version number.
+
+        This removes any settings that were removed in the new Cura version.
+        :param serialized: The original contents of the preferences file.
+        :param filename: The file name of the preferences file.
+        :return: A list of new file names, and a list of the new contents for
+        those files.
+        """
+        parser = configparser.ConfigParser(interpolation = None)
+        parser.read_string(serialized)
+
+        # Update version number.
+        parser["metadata"]["setting_version"] = "18"
+
+        # Remove deleted settings from the visible settings list.
+        if "general" in parser and "visible_settings" in parser["general"]:
+            visible_settings = set(parser["general"]["visible_settings"].split(";"))
+            for removed in _removed_settings:
+                if removed in visible_settings:
+                    visible_settings.remove(removed)
+
+            # Replace Outer Before Inner Walls with equivalent.
+            if "outer_inset_first" in visible_settings:
+                visible_settings.remove("outer_inset_first")
+                visible_settings.add("inset_direction")
+
+            parser["general"]["visible_settings"] = ";".join(visible_settings)
+
+        result = io.StringIO()
+        parser.write(result)
+        return [filename], [result.getvalue()]
+
+    def upgradeInstanceContainer(self, serialized: str, filename: str) -> Tuple[List[str], List[str]]:
+        """
+        Upgrades instance containers to remove the settings that were removed in this version.
+        It also changes the instance containers to have the new version number.
+
+        This removes any settings that were removed in the new Cura version and updates settings that need to be updated
+        with a new value.
+
+        :param serialized: The original contents of the instance container.
+        :param filename: The original file name of the instance container.
+        :return: A list of new file names, and a list of the new contents for
+        those files.
+        """
+        parser = configparser.ConfigParser(interpolation = None, comment_prefixes = ())
+        parser.read_string(serialized)
+
+        # Update version number.
+        parser["metadata"]["setting_version"] = "18"
+
+        if "values" in parser:
+            # Remove deleted settings from the instance containers.
+            for removed in _removed_settings:
+                if removed in parser["values"]:
+                    del parser["values"][removed]
+
+            # Replace Outer Before Inner Walls with equivalent setting.
+            if "outer_inset_first" in parser["values"]:
+                old_value = parser["values"]["outer_inset_first"]
+                if old_value.startswith("="):  # Was already a formula.
+                    old_value = old_value[1:]
+                parser["values"]["inset_direction"] = f"='outside_in' if ({old_value}) else 'inside_out'"  # Makes it work both with plain setting values and formulas.
+
+            # Disable Fuzzy Skin as it doesn't work with with the libArachne walls
+            if "magic_fuzzy_skin_enabled" in parser["values"]:
+                parser["values"]["magic_fuzzy_skin_enabled"] = "False"
+
+        result = io.StringIO()
+        parser.write(result)
+        return [filename], [result.getvalue()]
+
+    def upgradeStack(self, serialized: str, filename: str) -> Tuple[List[str], List[str]]:
+        """
+        Upgrades stacks to have the new version number.
+
+        :param serialized: The original contents of the stack.
+        :param filename: The original file name of the stack.
+        :return: A list of new file names, and a list of the new contents for
+        those files.
+        """
+        parser = configparser.ConfigParser(interpolation = None)
+        parser.read_string(serialized)
+
+        # Update version number.
+        if "metadata" not in parser:
+            parser["metadata"] = {}
+
+        parser["general"]["version"] = "5"
+        parser["metadata"]["setting_version"] = "18"
+
+        result = io.StringIO()
+        parser.write(result)
+        return [filename], [result.getvalue()]

plugins/VersionUpgrade/VersionUpgrade49to50/__init__.py

@@ -0,0 +1,61 @@
+# Copyright (c) 2020 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+
+from typing import Any, Dict, TYPE_CHECKING
+
+from . import VersionUpgrade49to50
+
+if TYPE_CHECKING:
+    from UM.Application import Application
+
+upgrade = VersionUpgrade49to50.VersionUpgrade49to50()
+
+def getMetaData() -> Dict[str, Any]:
+    return {  # Since there is no VersionUpgrade from 48 to 49 yet, upgrade the 48 profiles to 50.
+        "version_upgrade": {
+            # From                           To                              Upgrade function
+            ("preferences", 6000016):        ("preferences", 6000018,        upgrade.upgradePreferences),
+            ("machine_stack", 5000016):      ("machine_stack", 5000018,      upgrade.upgradeStack),
+            ("extruder_train", 5000016):     ("extruder_train", 5000018,     upgrade.upgradeStack),
+            ("machine_stack", 4000018):      ("machine_stack", 5000018,      upgrade.upgradeStack),  # We made a mistake in the arachne beta 1
+            ("extruder_train", 4000018):     ("extruder_train", 5000018,     upgrade.upgradeStack),  # We made a mistake in the arachne beta 1
+            ("definition_changes", 4000016): ("definition_changes", 4000018, upgrade.upgradeInstanceContainer),
+            ("quality_changes", 4000016):    ("quality_changes", 4000018,    upgrade.upgradeInstanceContainer),
+            ("quality", 4000016):            ("quality", 4000018,            upgrade.upgradeInstanceContainer),
+            ("user", 4000016):               ("user", 4000018,               upgrade.upgradeInstanceContainer),
+        },
+        "sources": {
+            "preferences": {
+                "get_version": upgrade.getCfgVersion,
+                "location": {"."}
+            },
+            "machine_stack": {
+                "get_version": upgrade.getCfgVersion,
+                "location": {"./machine_instances"}
+            },
+            "extruder_train": {
+                "get_version": upgrade.getCfgVersion,
+                "location": {"./extruders"}
+            },
+            "definition_changes": {
+                "get_version": upgrade.getCfgVersion,
+                "location": {"./definition_changes"}
+            },
+            "quality_changes": {
+                "get_version": upgrade.getCfgVersion,
+                "location": {"./quality_changes"}
+            },
+            "quality": {
+                "get_version": upgrade.getCfgVersion,
+                "location": {"./quality"}
+            },
+            "user": {
+                "get_version": upgrade.getCfgVersion,
+                "location": {"./user"}
+            }
+        }
+    }
+
+
+def register(app: "Application") -> Dict[str, Any]:
+    return {"version_upgrade": upgrade}

plugins/VersionUpgrade/VersionUpgrade49to50/plugin.json

@@ -0,0 +1,8 @@
+{
+    "name": "Version Upgrade 4.9 to 5.0",
+    "author": "Ultimaker B.V.",
+    "version": "1.0.0",
+    "description": "Upgrades configurations from Cura 4.9 to Cura 5.0.",
+    "api": "7.4.0",
+    "i18n-catalog": "cura"
+}

requirements.txt

@@ -29,7 +29,7 @@ pywin32==301
 requests==2.22.0
 scipy==1.6.2
 sentry-sdk==0.13.5
-shapely[vectorized]==1.7.1
+shapely[vectorized]==1.8.0
 six==1.12.0
 trimesh==3.2.33
 twisted==21.2.0

resources/bundled_packages/cura.json

@@ -6,7 +6,7 @@
             "display_name": "3MF Reader",
             "description": "Provides support for reading 3MF files.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -23,7 +23,7 @@
             "display_name": "3MF Writer",
             "description": "Provides support for writing 3MF files.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -40,7 +40,7 @@
             "display_name": "AMF Reader",
             "description": "Provides support for reading AMF files.",
             "package_version": "1.0.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "fieldOfView",
@@ -57,7 +57,7 @@
             "display_name": "Cura Backups",
             "description": "Backup and restore your configuration.",
             "package_version": "1.2.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -74,7 +74,7 @@
             "display_name": "CuraEngine Backend",
             "description": "Provides the link to the CuraEngine slicing backend.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -91,7 +91,7 @@
             "display_name": "Cura Profile Reader",
             "description": "Provides support for importing Cura profiles.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -108,7 +108,7 @@
             "display_name": "Cura Profile Writer",
             "description": "Provides support for exporting Cura profiles.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -125,7 +125,7 @@
             "display_name": "Ultimaker Digital Library",
             "description": "Connects to the Digital Library, allowing Cura to open files from and save files to the Digital Library.",
             "package_version": "1.1.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -142,7 +142,7 @@
             "display_name": "Firmware Update Checker",
             "description": "Checks for firmware updates.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -159,7 +159,7 @@
             "display_name": "Firmware Updater",
             "description": "Provides a machine actions for updating firmware.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -176,7 +176,7 @@
             "display_name": "Compressed G-code Reader",
             "description": "Reads g-code from a compressed archive.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -193,7 +193,7 @@
             "display_name": "Compressed G-code Writer",
             "description": "Writes g-code to a compressed archive.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -210,7 +210,7 @@
             "display_name": "G-Code Profile Reader",
             "description": "Provides support for importing profiles from g-code files.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -227,7 +227,7 @@
             "display_name": "G-Code Reader",
             "description": "Allows loading and displaying G-code files.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "VictorLarchenko",
@@ -244,7 +244,7 @@
             "display_name": "G-Code Writer",
             "description": "Writes g-code to a file.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -261,7 +261,7 @@
             "display_name": "Image Reader",
             "description": "Enables ability to generate printable geometry from 2D image files.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -278,7 +278,7 @@
             "display_name": "Legacy Cura Profile Reader",
             "description": "Provides support for importing profiles from legacy Cura versions.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -295,7 +295,7 @@
             "display_name": "Machine Settings Action",
             "description": "Provides a way to change machine settings (such as build volume, nozzle size, etc.).",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "fieldOfView",
@@ -312,7 +312,7 @@
             "display_name": "Model Checker",
             "description": "Checks models and print configuration for possible printing issues and give suggestions.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -329,7 +329,7 @@
             "display_name": "Monitor Stage",
             "description": "Provides a monitor stage in Cura.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -346,7 +346,7 @@
             "display_name": "Per-Object Settings Tool",
             "description": "Provides the per-model settings.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -363,7 +363,7 @@
             "display_name": "Post Processing",
             "description": "Extension that allows for user created scripts for post processing.",
             "package_version": "2.2.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -380,7 +380,7 @@
             "display_name": "Prepare Stage",
             "description": "Provides a prepare stage in Cura.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -397,7 +397,7 @@
             "display_name": "Preview Stage",
             "description": "Provides a preview stage in Cura.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -414,7 +414,7 @@
             "display_name": "Removable Drive Output Device",
             "description": "Provides removable drive hotplugging and writing support.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -431,7 +431,7 @@
             "display_name": "Sentry Logger",
             "description": "Logs certain events so that they can be used by the crash reporter",
             "package_version": "1.0.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -448,7 +448,7 @@
             "display_name": "Simulation View",
             "description": "Provides the Simulation view.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -465,7 +465,7 @@
             "display_name": "Slice Info",
             "description": "Submits anonymous slice info. Can be disabled through preferences.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -482,7 +482,7 @@
             "display_name": "Solid View",
             "description": "Provides a normal solid mesh view.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -499,7 +499,7 @@
             "display_name": "Support Eraser Tool",
             "description": "Creates an eraser mesh to block the printing of support in certain places.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -516,7 +516,7 @@
             "display_name": "Trimesh Reader",
             "description": "Provides support for reading model files.",
             "package_version": "1.0.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -533,7 +533,7 @@
             "display_name": "Toolbox",
             "description": "Find, manage and install new Cura packages.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -550,7 +550,7 @@
             "display_name": "UFP Reader",
             "description": "Provides support for reading Ultimaker Format Packages.",
             "package_version": "1.0.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -567,7 +567,7 @@
             "display_name": "UFP Writer",
             "description": "Provides support for writing Ultimaker Format Packages.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -584,7 +584,7 @@
             "display_name": "Ultimaker Machine Actions",
             "description": "Provides machine actions for Ultimaker machines (such as bed leveling wizard, selecting upgrades, etc.).",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -601,7 +601,7 @@
             "display_name": "UM3 Network Printing",
             "description": "Manages network connections to Ultimaker 3 printers.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -618,7 +618,7 @@
             "display_name": "USB Printing",
             "description": "Accepts G-Code and sends them to a printer. Plugin can also update firmware.",
             "package_version": "1.0.2",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -635,7 +635,7 @@
             "display_name": "Version Upgrade 2.1 to 2.2",
             "description": "Upgrades configurations from Cura 2.1 to Cura 2.2.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -652,7 +652,7 @@
             "display_name": "Version Upgrade 2.2 to 2.4",
             "description": "Upgrades configurations from Cura 2.2 to Cura 2.4.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -669,7 +669,7 @@
             "display_name": "Version Upgrade 2.5 to 2.6",
             "description": "Upgrades configurations from Cura 2.5 to Cura 2.6.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -686,7 +686,7 @@
             "display_name": "Version Upgrade 2.6 to 2.7",
             "description": "Upgrades configurations from Cura 2.6 to Cura 2.7.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -703,7 +703,7 @@
             "display_name": "Version Upgrade 2.7 to 3.0",
             "description": "Upgrades configurations from Cura 2.7 to Cura 3.0.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -720,7 +720,7 @@
             "display_name": "Version Upgrade 3.0 to 3.1",
             "description": "Upgrades configurations from Cura 3.0 to Cura 3.1.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -737,7 +737,7 @@
             "display_name": "Version Upgrade 3.2 to 3.3",
             "description": "Upgrades configurations from Cura 3.2 to Cura 3.3.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -754,7 +754,7 @@
             "display_name": "Version Upgrade 3.3 to 3.4",
             "description": "Upgrades configurations from Cura 3.3 to Cura 3.4.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -771,7 +771,7 @@
             "display_name": "Version Upgrade 3.4 to 3.5",
             "description": "Upgrades configurations from Cura 3.4 to Cura 3.5.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -788,7 +788,7 @@
             "display_name": "Version Upgrade 3.5 to 4.0",
             "description": "Upgrades configurations from Cura 3.5 to Cura 4.0.",
             "package_version": "1.0.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -805,7 +805,7 @@
             "display_name": "Version Upgrade 4.0 to 4.1",
             "description": "Upgrades configurations from Cura 4.0 to Cura 4.1.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -822,7 +822,7 @@
             "display_name": "Version Upgrade 4.1 to 4.2",
             "description": "Upgrades configurations from Cura 4.1 to Cura 4.2.",
             "package_version": "1.0.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -839,7 +839,7 @@
             "display_name": "Version Upgrade 4.2 to 4.3",
             "description": "Upgrades configurations from Cura 4.2 to Cura 4.3.",
             "package_version": "1.0.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -856,7 +856,7 @@
             "display_name": "Version Upgrade 4.3 to 4.4",
             "description": "Upgrades configurations from Cura 4.3 to Cura 4.4.",
             "package_version": "1.0.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -873,7 +873,7 @@
             "display_name": "Version Upgrade 4.4 to 4.5",
             "description": "Upgrades configurations from Cura 4.4 to Cura 4.5.",
             "package_version": "1.0.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -890,7 +890,7 @@
             "display_name": "Version Upgrade 4.5 to 4.6",
             "description": "Upgrades configurations from Cura 4.5 to Cura 4.6.",
             "package_version": "1.0.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -907,7 +907,7 @@
             "display_name": "Version Upgrade 4.6.0 to 4.6.2",
             "description": "Upgrades configurations from Cura 4.6.0 to Cura 4.6.2.",
             "package_version": "1.0.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -924,7 +924,7 @@
             "display_name": "Version Upgrade 4.6.2 to 4.7",
             "description": "Upgrades configurations from Cura 4.6.2 to Cura 4.7.",
             "package_version": "1.0.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -941,7 +941,7 @@
             "display_name": "Version Upgrade 4.7.0 to 4.8.0",
             "description": "Upgrades configurations from Cura 4.7.0 to Cura 4.8.0",
             "package_version": "1.0.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -958,7 +958,7 @@
             "display_name": "Version Upgrade 4.8.0 to 4.9.0",
             "description": "Upgrades configurations from Cura 4.8.0 to Cura 4.9.0",
             "package_version": "1.0.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -976,7 +976,7 @@
             "description": "Upgrades configurations from Cura 4.9 to Cura 4.10",
             "package_version": "1.0.0",
             "sdk_version": 7,
-            "sdk_version_semver": "7.8.0",
+            "sdk_version_semver": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -1011,7 +1011,7 @@
             "display_name": "X3D Reader",
             "description": "Provides support for reading X3D files.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "SevaAlekseyev",
@@ -1028,7 +1028,7 @@
             "display_name": "XML Material Profiles",
             "description": "Provides capabilities to read and write XML-based material profiles.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -1045,7 +1045,7 @@
             "display_name": "X-Ray View",
             "description": "Provides the X-Ray view.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -1062,7 +1062,7 @@
             "display_name": "Generic ABS",
             "description": "The generic ABS profile which other profiles can be based upon.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://github.com/Ultimaker/fdm_materials",
             "author": {
                 "author_id": "Generic",
@@ -1080,7 +1080,7 @@
             "display_name": "Generic BAM",
             "description": "The generic BAM profile which other profiles can be based upon.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://github.com/Ultimaker/fdm_materials",
             "author": {
                 "author_id": "Generic",
@@ -1098,7 +1098,7 @@
             "display_name": "Generic CFF CPE",
             "description": "The generic CFF CPE profile which other profiles can be based upon.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://github.com/Ultimaker/fdm_materials",
             "author": {
                 "author_id": "Generic",
@@ -1116,7 +1116,7 @@
             "display_name": "Generic CFF PA",
             "description": "The generic CFF PA profile which other profiles can be based upon.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://github.com/Ultimaker/fdm_materials",
             "author": {
                 "author_id": "Generic",
@@ -1134,7 +1134,7 @@
             "display_name": "Generic CPE",
             "description": "The generic CPE profile which other profiles can be based upon.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://github.com/Ultimaker/fdm_materials",
             "author": {
                 "author_id": "Generic",
@@ -1152,7 +1152,7 @@
             "display_name": "Generic CPE+",
             "description": "The generic CPE+ profile which other profiles can be based upon.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://github.com/Ultimaker/fdm_materials",
             "author": {
                 "author_id": "Generic",
@@ -1170,7 +1170,7 @@
             "display_name": "Generic GFF CPE",
             "description": "The generic GFF CPE profile which other profiles can be based upon.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://github.com/Ultimaker/fdm_materials",
             "author": {
                 "author_id": "Generic",
@@ -1188,7 +1188,7 @@
             "display_name": "Generic GFF PA",
             "description": "The generic GFF PA profile which other profiles can be based upon.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://github.com/Ultimaker/fdm_materials",
             "author": {
                 "author_id": "Generic",
@@ -1206,7 +1206,7 @@
             "display_name": "Generic HIPS",
             "description": "The generic HIPS profile which other profiles can be based upon.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://github.com/Ultimaker/fdm_materials",
             "author": {
                 "author_id": "Generic",
@@ -1224,7 +1224,7 @@
             "display_name": "Generic Nylon",
             "description": "The generic Nylon profile which other profiles can be based upon.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://github.com/Ultimaker/fdm_materials",
             "author": {
                 "author_id": "Generic",
@@ -1242,7 +1242,7 @@
             "display_name": "Generic PC",
             "description": "The generic PC profile which other profiles can be based upon.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://github.com/Ultimaker/fdm_materials",
             "author": {
                 "author_id": "Generic",
@@ -1260,7 +1260,7 @@
             "display_name": "Generic PETG",
             "description": "The generic PETG profile which other profiles can be based upon.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://github.com/Ultimaker/fdm_materials",
             "author": {
                 "author_id": "Generic",
@@ -1278,7 +1278,7 @@
             "display_name": "Generic PLA",
             "description": "The generic PLA profile which other profiles can be based upon.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://github.com/Ultimaker/fdm_materials",
             "author": {
                 "author_id": "Generic",
@@ -1296,7 +1296,7 @@
             "display_name": "Generic PP",
             "description": "The generic PP profile which other profiles can be based upon.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://github.com/Ultimaker/fdm_materials",
             "author": {
                 "author_id": "Generic",
@@ -1314,7 +1314,7 @@
             "display_name": "Generic PVA",
             "description": "The generic PVA profile which other profiles can be based upon.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://github.com/Ultimaker/fdm_materials",
             "author": {
                 "author_id": "Generic",
@@ -1332,7 +1332,7 @@
             "display_name": "Generic Tough PLA",
             "description": "The generic Tough PLA profile which other profiles can be based upon.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://github.com/Ultimaker/fdm_materials",
             "author": {
                 "author_id": "Generic",
@@ -1350,7 +1350,7 @@
             "display_name": "Generic TPU",
             "description": "The generic TPU profile which other profiles can be based upon.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://github.com/Ultimaker/fdm_materials",
             "author": {
                 "author_id": "Generic",
@@ -1368,7 +1368,7 @@
             "display_name": "Dagoma Chromatik PLA",
             "description": "Filament testé et approuvé pour les imprimantes 3D Dagoma. Chromatik est l'idéal pour débuter et suivre les tutoriels premiers pas. Il vous offre qualité et résistance pour chacune de vos impressions.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://dagoma.fr/boutique/filaments.html",
             "author": {
                 "author_id": "Dagoma",
@@ -1385,7 +1385,7 @@
             "display_name": "FABtotum ABS",
             "description": "This material is easy to be extruded but it is not the simplest to use. It is one of the most used in 3D printing to get very well finished objects. It is not sustainable and its smoke can be dangerous if inhaled. The reason to prefer this filament to PLA is mainly because of its precision and mechanical specs. ABS (for plastic) stands for Acrylonitrile Butadiene Styrene and it is a thermoplastic which is widely used in everyday objects. It can be printed with any FFF 3D printer which can get to high temperatures as it must be extruded in a range between 220° and 245°, so it’s compatible with all versions of the FABtotum Personal fabricator.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://store.fabtotum.com/eu/products/filaments.html?filament_type=40",
             "author": {
                 "author_id": "FABtotum",
@@ -1402,7 +1402,7 @@
             "display_name": "FABtotum Nylon",
             "description": "When 3D printing started this material was not listed among the extrudable filaments. It is flexible as well as resistant to tractions. It is well known for its uses in textile but also in industries which require a strong and flexible material. There are different kinds of Nylon: 3D printing mostly uses Nylon 6 and Nylon 6.6, which are the most common. It requires higher temperatures to be printed, so a 3D printer must be able to reach them (around 240°C): the FABtotum, of course, can.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://store.fabtotum.com/eu/products/filaments.html?filament_type=53",
             "author": {
                 "author_id": "FABtotum",
@@ -1419,7 +1419,7 @@
             "display_name": "FABtotum PLA",
             "description": "It is the most common filament used for 3D printing. It is studied to be bio-degradable as it comes from corn starch’s sugar mainly. It is completely made of renewable sources and has no footprint on polluting. PLA stands for PolyLactic Acid and it is a thermoplastic that today is still considered the easiest material to be 3D printed. It can be extruded at lower temperatures: the standard range of FABtotum’s one is between 185° and 195°.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://store.fabtotum.com/eu/products/filaments.html?filament_type=39",
             "author": {
                 "author_id": "FABtotum",
@@ -1436,7 +1436,7 @@
             "display_name": "FABtotum TPU Shore 98A",
             "description": "",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://store.fabtotum.com/eu/products/filaments.html?filament_type=66",
             "author": {
                 "author_id": "FABtotum",
@@ -1453,7 +1453,7 @@
             "display_name": "Fiberlogy HD PLA",
             "description": "With our HD PLA you have many more options. You can use this material in two ways. Choose the one you like best. You can use it as a normal PLA and get prints characterized by a very good adhesion between the layers and high precision. You can also make your prints acquire similar properties to that of ABS – better impact resistance and high temperature resistance. All you need is an oven. Yes, an oven! By annealing our HD PLA in an oven, in accordance with the manual, you will avoid all the inconveniences of printing with ABS, such as unpleasant odour or hazardous fumes.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "http://fiberlogy.com/en/fiberlogy-filaments/filament-hd-pla/",
             "author": {
                 "author_id": "Fiberlogy",
@@ -1470,7 +1470,7 @@
             "display_name": "Filo3D PLA",
             "description": "Fast, safe and reliable printing. PLA is ideal for the fast and reliable printing of parts and prototypes with a great surface quality.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://dagoma.fr",
             "author": {
                 "author_id": "Dagoma",
@@ -1487,7 +1487,7 @@
             "display_name": "IMADE3D JellyBOX PETG",
             "description": "",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "http://shop.imade3d.com/filament.html",
             "author": {
                 "author_id": "IMADE3D",
@@ -1504,7 +1504,7 @@
             "display_name": "IMADE3D JellyBOX PLA",
             "description": "",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "http://shop.imade3d.com/filament.html",
             "author": {
                 "author_id": "IMADE3D",
@@ -1521,7 +1521,7 @@
             "display_name": "Octofiber PLA",
             "description": "PLA material from Octofiber.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://nl.octofiber.com/3d-printing-filament/pla.html",
             "author": {
                 "author_id": "Octofiber",
@@ -1538,7 +1538,7 @@
             "display_name": "PolyFlex™ PLA",
             "description": "PolyFlex™ is a highly flexible yet easy to print 3D printing material. Featuring good elasticity and a large strain-to- failure, PolyFlex™ opens up a completely new realm of applications.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "http://www.polymaker.com/shop/polyflex/",
             "author": {
                 "author_id": "Polymaker",
@@ -1555,7 +1555,7 @@
             "display_name": "PolyMax™ PLA",
             "description": "PolyMax™ PLA is a 3D printing material with excellent mechanical properties and printing quality. PolyMax™ PLA has an impact resistance of up to nine times that of regular PLA, and better overall mechanical properties than ABS.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "http://www.polymaker.com/shop/polymax/",
             "author": {
                 "author_id": "Polymaker",
@@ -1572,7 +1572,7 @@
             "display_name": "PolyPlus™ PLA True Colour",
             "description": "PolyPlus™ PLA is a premium PLA designed for all desktop FDM/FFF 3D printers. It is produced with our patented Jam-Free™ technology that ensures consistent extrusion and prevents jams.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "http://www.polymaker.com/shop/polyplus-true-colour/",
             "author": {
                 "author_id": "Polymaker",
@@ -1589,7 +1589,7 @@
             "display_name": "PolyWood™ PLA",
             "description": "PolyWood™ is a wood mimic printing material that contains no actual wood ensuring a clean Jam-Free™ printing experience.",
             "package_version": "1.0.1",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "http://www.polymaker.com/shop/polywood/",
             "author": {
                 "author_id": "Polymaker",
@@ -1606,7 +1606,7 @@
             "display_name": "Ultimaker ABS",
             "description": "Example package for material and quality profiles for Ultimaker materials.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com/products/materials/abs",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -1625,7 +1625,7 @@
             "display_name": "Ultimaker Breakaway",
             "description": "Example package for material and quality profiles for Ultimaker materials.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com/products/materials/breakaway",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -1644,7 +1644,7 @@
             "display_name": "Ultimaker CPE",
             "description": "Example package for material and quality profiles for Ultimaker materials.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com/products/materials/abs",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -1663,7 +1663,7 @@
             "display_name": "Ultimaker CPE+",
             "description": "Example package for material and quality profiles for Ultimaker materials.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com/products/materials/cpe",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -1682,7 +1682,7 @@
             "display_name": "Ultimaker Nylon",
             "description": "Example package for material and quality profiles for Ultimaker materials.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com/products/materials/abs",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -1701,7 +1701,7 @@
             "display_name": "Ultimaker PC",
             "description": "Example package for material and quality profiles for Ultimaker materials.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com/products/materials/pc",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -1720,7 +1720,7 @@
             "display_name": "Ultimaker PLA",
             "description": "Example package for material and quality profiles for Ultimaker materials.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com/products/materials/abs",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -1739,7 +1739,7 @@
             "display_name": "Ultimaker PP",
             "description": "Example package for material and quality profiles for Ultimaker materials.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com/products/materials/pp",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -1758,7 +1758,7 @@
             "display_name": "Ultimaker PVA",
             "description": "Example package for material and quality profiles for Ultimaker materials.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com/products/materials/abs",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -1777,7 +1777,7 @@
             "display_name": "Ultimaker TPU 95A",
             "description": "Example package for material and quality profiles for Ultimaker materials.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com/products/materials/tpu-95a",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -1796,7 +1796,7 @@
             "display_name": "Ultimaker Tough PLA",
             "description": "Example package for material and quality profiles for Ultimaker materials.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://ultimaker.com/products/materials/tough-pla",
             "author": {
                 "author_id": "UltimakerPackages",
@@ -1815,7 +1815,7 @@
             "display_name": "Vertex Delta ABS",
             "description": "ABS material and quality files for the Delta Vertex K8800.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://vertex3dprinter.eu",
             "author": {
                 "author_id": "Velleman",
@@ -1832,7 +1832,7 @@
             "display_name": "Vertex Delta PET",
             "description": "ABS material and quality files for the Delta Vertex K8800.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://vertex3dprinter.eu",
             "author": {
                 "author_id": "Velleman",
@@ -1849,7 +1849,7 @@
             "display_name": "Vertex Delta PLA",
             "description": "ABS material and quality files for the Delta Vertex K8800.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://vertex3dprinter.eu",
             "author": {
                 "author_id": "Velleman",
@@ -1866,7 +1866,7 @@
             "display_name": "Vertex Delta TPU",
             "description": "ABS material and quality files for the Delta Vertex K8800.",
             "package_version": "1.4.0",
-            "sdk_version": "7.8.0",
+            "sdk_version": "7.9.0",
             "website": "https://vertex3dprinter.eu",
             "author": {
                 "author_id": "Velleman",

resources/definitions/anet3d.def.json

@@ -74,7 +74,6 @@
         "material_initial_print_temperature": { "value": "material_print_temperature" },
         "material_final_print_temperature": { "value": "material_print_temperature" },
         "material_flow": { "value": 100 },
-        "travel_compensate_overlapping_walls_0_enabled": { "value": "False" },
 
         "z_seam_type": { "value": "'back'" },
         "z_seam_corner": { "value": "'z_seam_corner_weighted'" },
@@ -87,7 +86,6 @@
         "infill_wipe_dist": { "value": 0 },
         "wall_0_wipe_dist": { "value": 0.2 },
 
-        "fill_perimeter_gaps": { "value": "'everywhere'" },
         "fill_outline_gaps": { "value": false },
         "filter_out_tiny_gaps": { "value": true },
 

resources/definitions/anycubic_i3_mega_s.def.json

@@ -78,7 +78,6 @@
         "material_initial_print_temperature": { "value": "material_print_temperature + 10" },
         "material_final_print_temperature": { "value": "material_print_temperature" },
         "material_flow": { "value": 100 },
-        "travel_compensate_overlapping_walls_0_enabled": { "value": "False" },
         
         "infill_sparse_density": { "value": 25 },
         "infill_before_walls": { "value": false },
@@ -91,21 +90,21 @@
         
         "retraction_hop_enabled": { "value": true },
         "retraction_hop": { "value": 0.075 },
-		"retraction_hop_only_when_collides": { "value": true },
+        "retraction_hop_only_when_collides": { "value": true },
 
         "retraction_combing": { "value": "'off'" },
         "retraction_combing_max_distance": { "value": 30 },
         "travel_avoid_other_parts": { "value": true },
         "travel_avoid_supports": { "value": true },
         "travel_retract_before_outer_wall": { "value": true },
-        
+
-		"retraction_amount": { "value": 6 },
+        "retraction_amount": { "value": 6 },
         "retraction_enable": { "value": true },
         "retraction_min_travel": { "value": 1.5 },
 
         "cool_fan_full_at_height": { "value": "layer_height_0 + 2 * layer_height" },
-		"cool_fan_speed": { "value": 70 },
+        "cool_fan_speed": { "value": 70 },
-		"cool_fan_speed_0": { "value": 30 },
+        "cool_fan_speed_0": { "value": 30 },
 
         "cool_fan_enabled": { "value": true },
         "cool_min_layer_time": { "value": 10 },
@@ -116,7 +115,6 @@
         "skirt_line_count": { "value": 4 },
 
         "meshfix_maximum_deviation": { "value": 0.05 },
-       
         "support_angle": { "value": "math.floor(math.degrees(math.atan(line_width / 2.0 / layer_height)))" },
         "support_pattern": { "value": "'zigzag'" },
         "support_infill_rate": { "value": "0 if support_enable and support_structure == 'tree' else 20" },
@@ -124,14 +122,15 @@
         "support_xy_distance": { "value": "wall_line_width_0 * 2" },
         "support_xy_distance_overhang": { "value": "wall_line_width_0" },
         "support_z_distance": { "value": "layer_height if layer_height >= 0.16 else layer_height * 2" },
+        "support_top_distance": { "value":  "extruderValue(support_roof_extruder_nr if support_roof_enable else support_infill_extruder_nr, 'support_z_distance') + (layer_height if support_structure == 'tree' else 0)"},
         "support_xy_overrides_z": { "value": "'xy_overrides_z'" },
         "support_wall_count": { "value": 1 },
         "support_brim_enable": { "value": true },
         "support_brim_width": { "value": 4 },
 
         "support_interface_enable": { "value": true },
-		"support_structure": { "value": "'tree'" },
+        "support_structure": { "value": "'tree'" },
-		"support_type": { "value": "'buildplate' if support_structure == 'tree' else 'everywhere'" },
+        "support_type": { "value": "'buildplate' if support_structure == 'tree' else 'everywhere'" },
         "support_interface_height": { "value": "layer_height * 4" },
         "support_interface_density": { "value": 33.333 },
         "support_interface_pattern": { "value": "'grid'" },

resources/definitions/artillery_base.def.json

@@ -179,7 +179,6 @@
         "material_initial_print_temperature": { "value": "material_print_temperature" },
         "material_final_print_temperature": { "value": "material_print_temperature" },
         "material_flow": { "value": 100 },
-        "travel_compensate_overlapping_walls_0_enabled": { "value": "False" },
 
         "z_seam_type": { "value": "'back'" },
         "z_seam_corner": { "value": "'z_seam_corner_none'" },
@@ -192,7 +191,6 @@
         "infill_wipe_dist": { "value": 0.0 },
         "wall_0_wipe_dist": { "value": 0.0 },
 
-        "fill_perimeter_gaps": { "value": "'everywhere'" },
         "fill_outline_gaps": { "value": false },
         "filter_out_tiny_gaps": { "value": false },
 

resources/definitions/atmat_signal_pro_base.def.json

@@ -258,7 +258,6 @@
         "layer_height_0":                               { "resolve": "max(0.2, min(extruderValues('layer_height')))" },
         "line_width":                                   { "value": "machine_nozzle_size * 1.125" },
         "wall_line_width":                              { "value": "machine_nozzle_size" },
-        "fill_perimeter_gaps":                          { "default_value": "everywhere" },
         "fill_outline_gaps":                            { "value": "True" },
         "meshfix_maximum_resolution":                   { "value": "0.01" },
         "meshfix_maximum_deviation":                    { "value": "layer_height / 2" },

resources/definitions/atom2.def.json

@@ -22,8 +22,8 @@
     "machine_heated_bed":     { "default_value": false },
     "machine_center_is_zero": { "default_value": true },
 
-    "machine_start_gcode":    { "default_value": "G21\nG90 \nM107\nG28\nG92 E0\nG1 F200 E3\nG92 E0" },
+    "machine_start_gcode":    { "default_value": "G21\nG90 \nM107\nG28\nG1 Y-110 Z15\nG0 Z{layer_height_0}\nG92 E0\nG1 F200 Y-100 E6\nG92 E0" },
-    "machine_end_gcode":      { "default_value": "M104 S0\nG28\nG91\nG1 E-6 F300\nM84\nG90" },
+    "machine_end_gcode":      { "default_value": "G28\nG91\nG1 E-6 F300\nM104 S0\nG1 E-1000 F5000\nM84\nG90" },
 
     "layer_height": { "default_value": 0.2 },
     "default_material_print_temperature": { "default_value": 210 },

resources/definitions/bfb.def.json

@@ -4,7 +4,6 @@
     "inherits": "fdmprinter",
     "metadata": {
         "visible": true,
-        "author": "Ultimaker",
         "manufacturer": "BFB",
         "file_formats": "text/x-gcode",
         "platform_offset": [ 0, 0, 0],

resources/definitions/biqu_base.def.json

@@ -83,7 +83,6 @@
         "material_initial_print_temperature": { "value": "material_print_temperature" },
         "material_final_print_temperature": { "value": "material_print_temperature" },
         "material_flow": { "value": 100 },
-        "travel_compensate_overlapping_walls_0_enabled": { "value": "False" },
 
         "z_seam_type": { "value": "'sharpest_corner'" },
         "z_seam_corner": { "value": "'z_seam_corner_inner'" },
@@ -97,7 +96,6 @@
         "infill_wipe_dist": { "value": 0.0 },
         "wall_0_wipe_dist": { "value": 0.0 },
 
-        "fill_perimeter_gaps": { "value": "'everywhere'" },
         "fill_outline_gaps": { "value": false },
         "filter_out_tiny_gaps": { "value": false },
 

resources/definitions/blv_mgn_cube_base.def.json

@@ -45,9 +45,6 @@
     "machine_gcode_flavor": {
       "default_value": "RepRap (RepRap)"
     },
-    "fill_perimeter_gaps": {
-      "value": "'everywhere'"
-    },
     "fill_outline_gaps": {
       "value": true
     },

resources/definitions/crazy3dprint_cz_300.def.json

@@ -1,5 +1,5 @@
 {
-    "version": 2, 
+    "version": 2,
     "name": "Crazy3DPrint CZ-300",
     "inherits": "crazy3dprint_base",
     "metadata": {
@@ -52,9 +52,9 @@
 		"skirt_line_count": { "default_value" : 5 },
 		"initial_layer_line_width_factor": { "default_value" : 140 },
 		"top_bottom_pattern": { "default_value" : "concentric" },
-		"outer_inset_first": { "default_value": true },
 		"fill_outline_gaps": { "default_value": true },
         "machine_gcode_flavor": { "default_value": "RepRap (Marlin/Sprinter)" },
+        "inset_direction": {"value": "'outside_in'" },
         "machine_start_gcode": {
             "default_value": "G28 ; home all axes\nG1 Z15 F5000 ; lift nozzle\nG92 E0\nG1 F200 E3\n"
          },

resources/definitions/creality_base.def.json

@@ -183,7 +183,6 @@
         "material_initial_print_temperature": { "value": "material_print_temperature" },
         "material_final_print_temperature": { "value": "material_print_temperature" },
         "material_flow": { "value": 100 },
-        "travel_compensate_overlapping_walls_0_enabled": { "value": "False" },
 
         "z_seam_type": { "value": "'back'" },
         "z_seam_corner": { "value": "'z_seam_corner_weighted'" },
@@ -196,7 +195,6 @@
         "infill_wipe_dist": { "value": 0.0 },
         "wall_0_wipe_dist": { "value": 0.0 },
 
-        "fill_perimeter_gaps": { "value": "'everywhere'" },
         "fill_outline_gaps": { "value": false },
         "filter_out_tiny_gaps": { "value": false },
 
@@ -247,7 +245,8 @@
         "support_use_towers": { "value": false },
         "support_xy_distance": { "value": "wall_line_width_0 * 2" },
         "support_xy_distance_overhang": { "value": "wall_line_width_0" },
-        "support_z_distance": { "value": "layer_height if layer_height >= 0.16 else layer_height*2" },
+        "support_z_distance": { "value": "layer_height if layer_height >= 0.16 else layer_height * 2" },
+        "support_top_distance": { "value":  "extruderValue(support_roof_extruder_nr if support_roof_enable else support_infill_extruder_nr, 'support_z_distance') + (layer_height if support_structure == 'tree' else 0)"},
         "support_xy_overrides_z": { "value": "'xy_overrides_z'" },
         "support_wall_count": { "value": 1 },
         "support_brim_enable": { "value": true },

resources/definitions/creality_cr100.def.json

@@ -0,0 +1,25 @@
+{
+    "name": "Creality CR-100",
+    "version": 2,
+    "inherits": "creality_base",
+    "overrides": {
+        "machine_name": { "default_value": "Creality CR-100" },
+        "machine_width": { "default_value": 100 },
+        "machine_depth": { "default_value": 100 },
+        "machine_height": { "default_value": 80 },
+        "machine_head_with_fans_polygon": { "default_value": [
+                [-26, 34],
+                [-26, -32],
+                [32, -32],
+                [32, 34]
+            ]
+        },
+
+        "gantry_height": { "value": 25 }
+
+    },
+    "metadata": {
+        "quality_definition": "creality_base",
+        "visible": true
+    }
+}

resources/definitions/creality_ender5.def.json

@@ -4,7 +4,7 @@
     "inherits": "creality_base",
     "overrides": {
         "machine_name": { "default_value": "Creality Ender-5" },
-        "machine_end_gcode": { "default_value": "G91 ;Relative positioning\nG1 E-2 F2700 ;Retract a bit\nG1 E-2 Z0.2 F2400 ;Retract and raise Z\nG1 X5 Y5 F3000 ;Wipe out\nG1 Z10 ;Raise Z more\nG90 ;Absolute positioning\n\nG1 X0 Y0 ;Present print\nM106 S0 ;Turn-off fan\nM104 S0 ;Turn-off hotend\nM140 S0 ;Turn-off bed\n\nM84 X Y E ;Disable all steppers but Z\n" },
+        "machine_end_gcode": { "default_value": "G91 ;Relative positioning\nG1 E-2 F2700 ;Retract a bit\nG1 E-2 Z0.2 F2400 ;Retract and raise Z\nG1 X5 Y5 F3000 ;Wipe out\nG1 Z10 ;Raise Z more\nG90 ;Absolute positioning\n\nG28 X0 Y0 ;Present print\nM106 S0 ;Turn-off fan\nM104 S0 ;Turn-off hotend\nM140 S0 ;Turn-off bed\n\nM84 X Y E ;Disable all steppers but Z\n" },
         "machine_width": { "default_value": 220 },
         "machine_depth": { "default_value": 220 },
         "machine_height": { "default_value": 300 },

resources/definitions/creality_ender6.def.json

@@ -5,7 +5,7 @@
     "overrides": {
         "machine_name": { "default_value": "Creality Ender-6" },
         "machine_start_gcode": { "default_value": "\nG28 ;Home\n\nG92 E0 ;Reset Extruder\nG1 Z2.0 F3000 ;Move Z Axis up\nG1 X10.1 Y20 Z0.28 F5000.0 ;Move to start position\nG1 X10.1 Y200.0 Z0.28 F1500.0 E15 ;Draw the first line\nG1 X10.4 Y200.0 Z0.28 F5000.0 ;Move to side a little\nG1 X10.4 Y20 Z0.28 F1500.0 E30 ;Draw the second line\nG92 E0 ;Reset Extruder\nG1 Z2.0 F3000 ;Move Z Axis up\n"},
-        "machine_end_gcode": { "default_value": "G91 ;Relative positionning\nG1 E-2 F2700 ;Retract a bit\nG1 E-2 Z0.2 F2400 ;Retract and raise Z\nG1 X5 Y5 F3000 ;Wipe out\nG1 Z10 ;Raise Z more\nG90 ;Absolute positionning\n\nG28 X Y ;Present print\nM106 S0 ;Turn-off fan\nM104 S0 ;Turn-off hotend\nM140 S0 ;Turn-off bed\n\nM84 X Y E ;Disable all steppers but Z\n" },
+        "machine_end_gcode": { "default_value": "G91 ;Relative positioning\nG1 E-2 F2700 ;Retract a bit\nG1 E-2 Z0.2 F2400 ;Retract and raise Z\nG1 X5 Y5 F3000 ;Wipe out\nG1 Z10 ;Raise Z more\nG90 ;Absolute positioning\n\nG28 X Y ;Present print\nM106 S0 ;Turn-off fan\nM104 S0 ;Turn-off hotend\nM140 S0 ;Turn-off bed\n\nM84 X Y E ;Disable all steppers but Z\n" },
         "machine_width": { "default_value": 260 },
         "machine_depth": { "default_value": 260 },
         "machine_height": { "default_value": 400 },

resources/definitions/creality_sermoond1.def.json

@@ -0,0 +1,25 @@
+{
+    "name": "Creality Sermoon D1",
+    "version": 2,
+    "inherits": "creality_base",
+    "overrides": {
+        "machine_name": { "default_value": "Creality Sermoon D1" },
+        "machine_width": { "default_value": 280 },
+        "machine_depth": { "default_value": 260 },
+        "machine_height": { "default_value": 310 },
+        "machine_head_with_fans_polygon": { "default_value": [
+                [-26, 34],
+                [-26, -32],
+                [32, -32],
+                [32, 34]
+            ]
+        },
+
+        "gantry_height": { "value": 25 }
+
+    },
+    "metadata": {
+        "quality_definition": "creality_base",
+        "visible": true
+    }
+}

resources/definitions/cubicon_common.def.json

@@ -20,9 +20,6 @@
         "machine_heated_bed": {
             "default_value": true
         },
-        "travel_compensate_overlapping_walls_enabled": {
-            "default_value": false
-        },
         "layer_height": {
             "default_value": 0.2
         },
@@ -33,7 +30,6 @@
             "default_value": "raft"
         },
         "top_bottom_pattern": { "default_value": "lines" },
-        "fill_perimeter_gaps": { "default_value": "everywhere" },
         "infill_sparse_density": { "default_value": 20 },
         "infill_before_walls": { "default_value": false },
         "top_bottom_thickness": {

resources/definitions/eazao_zero.def.json

@@ -0,0 +1,126 @@
+{
+    "version": 2,
+    "name": "Eazao Zero",
+    "inherits": "fdmprinter",
+    "metadata": 
+  {
+        "visible": true,
+        "author": "Eazao",
+        "manufacturer": "Eazao",
+        "file_formats": "text/x-gcode",
+        "has_materials": true,
+        "has_machine_quality": false,
+        "preferred_quality_type": "normal",
+        "preferred_material": "generic_pla",
+    
+        "machine_extruder_trains":
+        {
+            "0": "eazao_zero_extruder_0"
+        }  
+  },
+  "overrides":
+    {
+        "machine_name":
+        {
+            "default_value": "EAZAO Zero"
+        },
+        "machine_heated_bed":
+        {
+            "default_value": false
+        },
+        "machine_width":
+        {
+            "default_value": 150
+        },
+        "machine_depth":
+        {
+            "default_value": 150
+        },
+        "machine_height":
+        {
+            "default_value": 240
+        },
+        "machine_center_is_zero":
+        {
+            "default_value": false
+        },
+        "machine_gcode_flavor":
+        {
+            "default_value": "Marlin (Marlin/Sprinter)"
+        },
+        "machine_start_gcode":
+        {
+            "default_value": "G21 \nG90 ;absolute positioning\nM82 ;set extruder to absolute mode\nG28 ;Home \nG1 Z15.0 F1500 ;move the platform down 15mm\nG92 E0 \nG1 F300 E10\nG92 E0\nM302\nM163 S0 P0.9; Set Mix Factor\nM163 S1 P0.1; Set Mix Factor\nM164 S0\n"
+        },
+        "machine_end_gcode":
+        {
+            "default_value": "G92 E10\nG1 E-10 F300\nG28 X0 Y0 ;move X Y to min endstops\nM82\nM84 ;steppers off\n"
+        },
+        "machine_max_feedrate_x": { "value": 100 },
+        "machine_max_feedrate_y": { "value": 100 },
+        "machine_max_feedrate_z": { "value": 5 },
+        "machine_max_feedrate_e": { "value": 25 },
+
+        "machine_max_acceleration_x": { "value": 500 },
+        "machine_max_acceleration_y": { "value": 500 },
+        "machine_max_acceleration_z": { "value": 50 },
+        "machine_max_acceleration_e": { "value": 500 },
+        "machine_acceleration": { "value": 300 },
+        "acceleration_print": { "value": 300 },
+        "acceleration_travel": { "value": 300 },
+        "acceleration_enabled": { "value": false },
+
+        "machine_max_jerk_xy": { "value": 10 },
+        "machine_max_jerk_z": { "value": 0.3 },
+        "machine_max_jerk_e": { "value": 5 },
+        "jerk_print": { "value": 10 },
+        "jerk_travel": { "value": "jerk_print" },
+        "jerk_travel_layer_0": { "value": "jerk_travel" },
+        "jerk_enabled": { "value": false },
+
+        "layer_height": {"value":1.0},
+        "layer_height_0": {"value":1.0},
+        "line_width": {"value":3.0},
+        
+        "wall_thickness": {"value":3.0},
+        "optimize_wall_printing_order": { "value": "True" },
+        
+        "top_bottom_thickness": {"value":0},
+        "bottom_layers":{"value":2},
+        "initial_bottom_layers":{"value":2},
+
+        "infill_sparse_density": {"value":0},
+
+        "material_print_temperature": { "value": "0" },
+        "material_print_temperature_layer_0": { "value": "0" },
+        "material_initial_print_temperature": { "value": "0" },
+        "material_final_print_temperature": { "value": "0" },
+
+        "speed_print": { "value": 20.0 },
+        "speed_wall": { "value": 20.0 },
+        "speed_wall_0": { "value": 20.0 },
+        "speed_wall_x": { "value": 20.0 },
+        "speed_travel": { "value": 20.0 },
+        "speed_z_hop": { "value": "machine_max_feedrate_z" },
+             
+        "retraction_hop_enabled": { "value": false },
+        "retraction_hop": { "value": 0.2 },
+        "retraction_combing": { "value": "'noskin'" },
+        "retraction_combing_max_distance": { "value": 0 },
+
+        "travel_avoid_other_parts": { "value": true },
+        "travel_avoid_supports": { "value": false },
+        "travel_retract_before_outer_wall": { "value": false },
+
+        "retraction_enable": { "value": false },
+        "retraction_speed": { "value": 25 },
+        "retraction_amount": { "value": 7 },
+        "retraction_count_max": { "value": 100 },
+        "retraction_extrusion_window": { "value": 10 },
+        
+        "cool_fan_enabled": { "value": false },
+        
+        "adhesion_type": { "default_value": "none" }
+
+    }
+}

resources/definitions/eryone_thinker.def.json

@@ -83,9 +83,6 @@
         "optimize_wall_printing_order": {
             "default_value": true 
         },
-        "outer_inset_first": {
-            "default_value": false 
-        },
         "z_seam_type": {
             "value": "'shortest'"
         },
@@ -122,6 +119,9 @@
         "infill_before_walls": {
             "value": false
         },
+        "inset_direction": {
+            "default_value": "inside_out"
+        },
         "material_print_temperature": {
             "value": "default_material_print_temperature",
             "maximum_value_warning": 250

resources/definitions/erzay3d.def.json

@@ -62,8 +62,6 @@
     "retraction_amount": { "default_value": 6.5 },
 
     "speed_print": { "default_value": 40 },
-    "speed_equalize_flow_enabled": { "default_value": true },
-    "speed_equalize_flow_max": { "default_value": 100 },
 
     "acceleration_print": { "default_value": 1000 },
 

resources/definitions/fdmprinter.def.json

@@ -4,7 +4,7 @@
     "metadata":
     {
         "type": "machine",
-        "author": "Ultimaker",
+        "author": "Unknown",
         "manufacturer": "Unknown",
         "setting_version": 19,
         "file_formats": "text/x-gcode;model/stl;application/x-wavefront-obj;application/x3g",
@@ -159,6 +159,16 @@
                     "settable_per_extruder": false,
                     "settable_per_meshgroup": false
                 },
+                "machine_height":
+                {
+                    "label": "Machine Height",
+                    "description": "The height (Z-direction) of the printable area.",
+                    "default_value": 100,
+                    "type": "float",
+                    "settable_per_mesh": false,
+                    "settable_per_extruder": false,
+                    "settable_per_meshgroup": false
+                },
                 "machine_shape":
                 {
                     "label": "Build Plate Shape",
@@ -189,16 +199,6 @@
                     "settable_per_extruder": false,
                     "settable_per_meshgroup": false
                 },
-                "machine_height":
-                {
-                    "label": "Machine Height",
-                    "description": "The height (Z-direction) of the printable area.",
-                    "default_value": 100,
-                    "type": "float",
-                    "settable_per_mesh": false,
-                    "settable_per_extruder": false,
-                    "settable_per_meshgroup": false
-                },
                 "machine_heated_bed":
                 {
                     "label": "Has Heated Build Plate",
@@ -448,7 +448,7 @@
                 "machine_head_with_fans_polygon":
                 {
                     "label": "Machine Head & Fan Polygon",
-                    "description": "A 2D silhouette of the print head (fan caps included).",
+                    "description": "The shape of the print head. These are coordinates relative to the position of the print head, which is usually the position of its first extruder. The dimensions left and in front of the print head must be negative coordinates.",
                     "type": "polygon",
                     "default_value":
                     [
@@ -571,7 +571,7 @@
                 },
                 "machine_max_feedrate_e":
                 {
-                    "label": "Maximum Feedrate",
+                    "label": "Maximum Speed E",
                     "description": "The maximum speed of the filament.",
                     "unit": "mm/s",
                     "type": "float",
@@ -831,7 +831,7 @@
                                     "description": "Width of the outermost wall line. By lowering this value, higher levels of detail can be printed.",
                                     "unit": "mm",
                                     "minimum_value": "0.001",
-                                    "minimum_value_warning": "(0.1 + 0.4 * machine_nozzle_size) if outer_inset_first else 0.1 * machine_nozzle_size",
+                                    "minimum_value_warning": "(0.1 + 0.4 * machine_nozzle_size) if inset_direction == \"outside_in\" else 0.1 * machine_nozzle_size",
                                     "maximum_value_warning": "2 * machine_nozzle_size",
                                     "default_value": 0.4,
                                     "value": "wall_line_width",
@@ -1056,6 +1056,7 @@
                     "minimum_value": "0",
                     "minimum_value_warning": "line_width",
                     "maximum_value_warning": "10 * line_width",
+                    "maximum_value": "999999 * line_width",
                     "type": "float",
                     "limit_to_extruder": "wall_x_extruder_nr",
                     "settable_per_mesh": true,
@@ -1069,6 +1070,7 @@
                             "minimum_value": "0",
                             "minimum_value_warning": "1",
                             "maximum_value_warning": "10",
+                            "maximum_value": "999999",
                             "type": "int",
                             "value": "1 if magic_spiralize else max(1, round((wall_thickness - wall_line_width_0) / wall_line_width_x) + 1) if wall_thickness != 0 else 0",
                             "limit_to_extruder": "wall_x_extruder_nr",
@@ -1076,6 +1078,98 @@
                         }
                     }
                 },
+                "beading_strategy_type":
+                {
+                    "label": "Variable Line Strategy",
+                    "description": "Strategy to use to print the width of a part with a number of walls. This determines how many walls it will use for a certain total width, and how wide each of these lines are. \"Center Deviation\" will print all walls at the nominal line width except the central one(s), causing big variations in the center but very consistent outsides. \"Distributed\" distributes the width equally over all walls. \"Inward Distributed\" is a balance between the other two, distributing the changes in width over all walls but keeping the walls on the outside slightly more consistent.",
+                    "type": "enum",
+                    "options":
+                    {
+                        "center_deviation": "Center Deviation",
+                        "distributed": "Distributed",
+                        "inward_distributed": "Inward Distributed"
+                    },
+                    "default_value": "inward_distributed",
+                    "limit_to_extruder": "wall_0_extruder_nr"
+                },
+                "wall_transition_threshold": {
+                    "label": "Middle Line Threshold",
+                    "description": "The smallest line width, as a factor of the normal line width, below which it will choose to use fewer, but wider lines to fill the available space the wall needs to occupy. Reduce this setting to use more, thinner lines. Increase to use fewer, wider lines. Note that this applies -as if- the entire shape should be filled with wall, so the middle here refers to the middle of the object between two outer edges of the shape, even if there actually is fill or (other) skin in the print instead of wall.",
+                    "type": "float",
+                    "unit": "%",
+                    "default_value": 90,
+                    "minimum_value": "1",
+                    "maximum_value": "99",
+                    "children":
+                    {
+                        "wall_split_middle_threshold": {
+                            "label": "Split Middle Line Threshold",
+                            "description": "The smallest line width, as a factor of the normal line width, above which the middle line (if there is one) will be split into two. Reduce this setting to use more, thinner lines. Increase to use fewer, wider lines. Note that this applies -as if- the entire shape should be filled with wall, so the middle here refers to the middle of the object between two outer edges of the shape, even if there actually is fill or (other) skin in the print instead of wall.",
+                            "type": "float",
+                            "unit": "%",
+                            "default_value": 50,
+                            "value": "wall_transition_threshold",
+                            "minimum_value": "1",
+                            "maximum_value": "99"
+                        },
+                        "wall_add_middle_threshold": {
+                            "label": "Add Middle Line Threshold",
+                            "description": "The smallest line width, as a factor of the normal line width, above which a middle line (if there wasn't one already) will be added. Reduce this setting to use more, thinner lines. Increase to use fewer, wider lines. Note that this applies -as if- the entire shape should be filled with wall, so the middle here refers to the middle of the object between two outer edges of the shape, even if there actually is fill or (other) skin in the print instead of wall.",
+                            "type": "float",
+                            "unit": "%",
+                            "default_value": 50,
+                            "value": "wall_transition_threshold * 8 / 9",
+                            "minimum_value": "1",
+                            "maximum_value": "99"
+                        }
+                    }
+                },
+                "wall_transition_length":
+                {
+                    "label": "Wall Transition Length",
+                    "description": "When transitioning between different numbers of walls as the part becomes thinner, a certain amount of space is allotted to split or join the wall lines.",
+                    "type": "float",
+                    "unit": "mm",
+                    "default_value": 0.4,
+                    "value": "line_width",
+                    "minimum_value": "0.001",
+                    "minimum_value_warning": "0.5 * line_width",
+                    "maximum_value_warning": "2 * line_width",
+                    "maximum_value": "min_bead_width * 3 * math.pi"
+                },
+                "wall_distribution_count":
+                {
+                    "label": "Wall Distribution Count",
+                    "description": "The number of walls, counted from the center, over which the variation needs to be spread. Lower values mean that the outer walls don't change in width.",
+                    "type": "int",
+                    "default_value": 1,
+                    "minimum_value": "1",
+                    "enabled": "beading_strategy_type == 'inward_distributed'"
+                },
+                "wall_transition_angle":
+                {
+                    "label": "Wall Transition Angle",
+                    "description": "When transitioning between different numbers of walls as the part becomes thinner, two adjacent walls will join together at this angle. This can make the walls come together faster than what the Wall Transition Length indicates, filling the space better.",
+                    "type": "float",
+                    "unit": "°",
+                    "default_value": 10,
+                    "minimum_value": "1",
+                    "minimum_value_warning": "5",
+                    "maximum_value_warning": "50",
+                    "maximum_value": "59"
+                },
+                "wall_transition_filter_distance":
+                {
+                    "label": "Wall Transition Distance Filter",
+                    "description": "If it would be transitioning back and forth between different numbers of walls in quick succession, don't transition at all. Remove transitions if they are closer together than this distance.",
+                    "type": "float",
+                    "unit": "mm",
+                    "default_value": 1.4,
+                    "value": "4 * math.cos(wall_transition_angle / 180 * math.pi) * wall_line_width_x",
+                    "minimum_value": "wall_transition_length",
+                    "minimum_value_warning": "math.cos(wall_transition_angle / 180 * math.pi) * wall_line_width_x",
+                    "maximum_value_warning": "10 * math.cos(wall_transition_angle / 180 * math.pi) * wall_line_width_x"
+                },
                 "wall_0_wipe_dist":
                 {
                     "label": "Outer Wall Wipe Distance",
@@ -1096,7 +1190,7 @@
                     "unit": "mm",
                     "type": "float",
                     "default_value": 0.0,
-                    "value": "(machine_nozzle_size - wall_line_width_0) / 2 if (wall_line_width_0 < machine_nozzle_size and not outer_inset_first) else 0",
+                    "value": "(machine_nozzle_size - wall_line_width_0) / 2 if (wall_line_width_0 < machine_nozzle_size and inset_direction != \"outside_in\") else 0",
                     "minimum_value_warning": "0",
                     "maximum_value_warning": "machine_nozzle_size",
                     "limit_to_extruder": "wall_0_extruder_nr",
@@ -1104,19 +1198,23 @@
                 },
                 "optimize_wall_printing_order":
                 {
-                    "label": "Optimize Wall Printing Order",
+                    "label": "Order Inner Walls By Inset",
-                    "description": "Optimize the order in which walls are printed so as to reduce the number of retractions and the distance travelled. Most parts will benefit from this being enabled but some may actually take longer so please compare the print time estimates with and without optimization. First layer is not optimized when choosing brim as build plate adhesion type.",
+                    "description": "Order inner wall printing by inset-index, instead of by (hole) region.",
                     "type": "bool",
                     "default_value": false,
                     "settable_per_mesh": true
                 },
-                "outer_inset_first":
+                "inset_direction":
                 {
-                    "label": "Outer Before Inner Walls",
+                    "label": "Wall Ordering",
-                    "description": "Prints walls in order of outside to inside when enabled. This can help improve dimensional accuracy in X and Y when using a high viscosity plastic like ABS; however it can decrease outer surface print quality, especially on overhangs.",
+                    "description": "Determines the order in which walls are printed. Printing outer walls earlier helps with dimensional accuracy, as faults from inner walls cannot propagate to the outside. However printing them later allows them to stack better when overhangs are printed.",
-                    "type": "bool",
+                    "type": "enum",
-                    "default_value": false,
+                    "options": {
-                    "enabled": "wall_0_extruder_nr == wall_x_extruder_nr",
+                        "inside_out": "Inside To Outside",
+                        "outside_in": "Outside To Inside",
+                        "center_last": "Center Last"
+                    },
+                    "default_value": "center_last",
                     "settable_per_mesh": true
                 },
                 "alternate_extra_perimeter":
@@ -1128,72 +1226,6 @@
                     "limit_to_extruder": "infill_extruder_nr",
                     "settable_per_mesh": true
                 },
-                "travel_compensate_overlapping_walls_enabled":
-                {
-                    "label": "Compensate Wall Overlaps",
-                    "description": "Compensate the flow for parts of a wall being printed where there is already a wall in place.",
-                    "type": "bool",
-                    "default_value": true,
-                    "limit_to_extruder": "wall_x_extruder_nr",
-                    "settable_per_mesh": true,
-                    "children":
-                    {
-                        "travel_compensate_overlapping_walls_0_enabled":
-                        {
-                            "label": "Compensate Outer Wall Overlaps",
-                            "description": "Compensate the flow for parts of an outer wall being printed where there is already a wall in place.",
-                            "type": "bool",
-                            "default_value": true,
-                            "value": "travel_compensate_overlapping_walls_enabled",
-                            "limit_to_extruder": "wall_0_extruder_nr",
-                            "settable_per_mesh": true
-                        },
-                        "travel_compensate_overlapping_walls_x_enabled":
-                        {
-                            "label": "Compensate Inner Wall Overlaps",
-                            "description": "Compensate the flow for parts of an inner wall being printed where there is already a wall in place.",
-                            "type": "bool",
-                            "default_value": true,
-                            "value": "travel_compensate_overlapping_walls_enabled",
-                            "limit_to_extruder": "wall_x_extruder_nr",
-                            "settable_per_mesh": true
-                        }
-                    }
-                },
-                "wall_min_flow":
-                {
-                    "label": "Minimum Wall Flow",
-                    "description": "Minimum allowed percentage flow for a wall line. The wall overlap compensation reduces a wall's flow when it lies close to an existing wall. Walls whose flow is less than this value will be replaced with a travel move. When using this setting, you must enable the wall overlap compensation and print the outer wall before inner walls.",
-                    "unit": "%",
-                    "minimum_value": "0",
-                    "maximum_value": "100",
-                    "default_value": 0,
-                    "type": "float",
-                    "enabled": "travel_compensate_overlapping_walls_0_enabled or travel_compensate_overlapping_walls_x_enabled",
-                    "settable_per_mesh": true
-                },
-                "wall_min_flow_retract":
-                {
-                    "label": "Prefer Retract",
-                    "description": "If enabled, retraction is used rather than combing for travel moves that replace walls whose flow is below the minimum flow threshold.",
-                    "type": "bool",
-                    "default_value": false,
-                    "enabled": "(travel_compensate_overlapping_walls_0_enabled or travel_compensate_overlapping_walls_x_enabled) and wall_min_flow > 0",
-                    "settable_per_mesh": true
-                },
-                "fill_perimeter_gaps":
-                {
-                    "label": "Fill Gaps Between Walls",
-                    "description": "Fills the gaps between walls where no walls fit.",
-                    "type": "enum",
-                    "options": {
-                        "nowhere": "Nowhere",
-                        "everywhere": "Everywhere"
-                    },
-                    "default_value": "everywhere",
-                    "limit_to_extruder": "wall_0_extruder_nr",
-                    "settable_per_mesh": true
-                },
                 "filter_out_tiny_gaps":
                 {
                     "label": "Filter Out Tiny Gaps",
@@ -1207,10 +1239,36 @@
                     "label": "Print Thin Walls",
                     "description": "Print pieces of the model which are horizontally thinner than the nozzle size.",
                     "type": "bool",
-                    "default_value": false,
+                    "default_value": true,
                     "limit_to_extruder": "wall_0_extruder_nr",
                     "settable_per_mesh": true
                 },
+                "min_feature_size":
+                {
+                    "label": "Minimum Feature Size",
+                    "description": "Minimum thickness of thin features. Model features that are thinner than this value will not be printed, while features thicker than the Minimum Feature Size will be widened to the Minimum Wall Line Width.",
+                    "unit": "mm",
+                    "value": "wall_line_width_0 / 4",
+                    "minimum_value": "0",
+                    "maximum_value": "wall_line_width_0",
+                    "type": "float",
+                    "limit_to_extruder": "wall_0_extruder_nr",
+                    "enabled": "fill_outline_gaps"
+                },
+                "min_bead_width":
+                {
+                    "label": "Minimum Wall Line Width",
+                    "description": "Width of the wall that will replace thin features (according to the Minimum Feature Size) of the model. If the Minimum Wall Line Width is thinner than the thickness of the feature, the wall will become as thick as the feature itself.",
+                    "unit": "mm",
+                    "value": "wall_line_width_0 * (100.0 + wall_split_middle_threshold)/200",
+                    "default_value": "0.2",
+                    "minimum_value": "0.001",
+                    "minimum_value_warning": "min_feature_size",
+                    "maximum_value_warning": "wall_line_width_0",
+                    "type": "float",
+                    "limit_to_extruder": "wall_0_extruder_nr",
+                    "enabled": "fill_outline_gaps"
+                },
                 "xy_offset":
                 {
                     "label": "Horizontal Expansion",
@@ -1557,6 +1615,7 @@
                     "default_value": 1,
                     "minimum_value": "0",
                     "maximum_value_warning": "10",
+                    "maximum_value": "999999",
                     "type": "int",
                     "enabled": "(top_layers > 0 or bottom_layers > 0) and (top_bottom_pattern != 'concentric' or top_bottom_pattern_0 != 'concentric' or (roofing_layer_count > 0 and roofing_pattern != 'concentric'))",
                     "limit_to_extruder": "top_bottom_extruder_nr",
@@ -1890,7 +1949,7 @@
                 "infill_pattern":
                 {
                     "label": "Infill Pattern",
-                    "description": "The pattern of the infill material of the print. The line and zig zag infill swap direction on alternate layers, reducing material cost. The grid, triangle, tri-hexagon, cubic, octet, quarter cubic, cross and concentric patterns are fully printed every layer. Gyroid, cubic, quarter cubic and octet infill change with every layer to provide a more equal distribution of strength over each direction. Lightning infill tries to minimize the infill, by only supporting the (internal) roofs of the object. As such, the infill percentage is only 'valid' one layer below whatever it needs to support of the model.",
+                    "description": "The pattern of the infill material of the print. The line and zig zag infill swap direction on alternate layers, reducing material cost. The grid, triangle, tri-hexagon, cubic, octet, quarter cubic, cross and concentric patterns are fully printed every layer. Gyroid, cubic, quarter cubic and octet infill change with every layer to provide a more equal distribution of strength over each direction. Lightning infill tries to minimize the infill, by only supporting the ceiling of the object.",
                     "type": "enum",
                     "options":
                     {
@@ -1943,7 +2002,7 @@
                     "description": "A list of integer line directions to use. Elements from the list are used sequentially as the layers progress and when the end of the list is reached, it starts at the beginning again. The list items are separated by commas and the whole list is contained in square brackets. Default is an empty list which means use the traditional default angles (45 and 135 degrees for the lines and zig zag patterns and 45 degrees for all other patterns).",
                     "type": "[int]",
                     "default_value": "[ ]",
-                    "enabled": "infill_pattern != 'lightning' and infill_pattern != 'concentric' and infill_sparse_density > 0",
+                    "enabled": "infill_pattern not in ('concentric', 'cross', 'cross_3d', 'gyroid', 'lightning') and infill_sparse_density > 0",
                     "limit_to_extruder": "infill_extruder_nr",
                     "settable_per_mesh": true
                 },
@@ -1999,6 +2058,7 @@
                     "default_value": 0,
                     "type": "int",
                     "minimum_value": "0",
+                    "maximum_value": "999999",
                     "enabled": "infill_sparse_density > 0",
                     "limit_to_extruder": "infill_extruder_nr",
                     "settable_per_mesh": true
@@ -2083,9 +2143,9 @@
                     "default_value": 0,
                     "type": "int",
                     "minimum_value": "0",
-                    "maximum_value_warning": "1 if (infill_pattern == 'cross' or infill_pattern == 'cross_3d' or support_pattern == 'concentric') else 5",
+                    "maximum_value_warning": "1 if (infill_pattern == 'cross' or infill_pattern == 'cross_3d' or infill_pattern == 'concentric') else 5",
                     "maximum_value": "999999 if infill_line_distance == 0 else (20 - math.log(infill_line_distance) / math.log(2))",
-                    "enabled": "infill_pattern != 'lightning' and infill_sparse_density > 0 and infill_pattern != 'cubicsubdiv'",
+                    "enabled": "infill_sparse_density > 0 and infill_pattern not in ['cubicsubdiv', 'cross', 'cross_3d', 'lightning']",
                     "limit_to_extruder": "infill_extruder_nr",
                     "settable_per_mesh": true
                 },
@@ -2098,7 +2158,7 @@
                     "default_value": 1.5,
                     "minimum_value": "0.0001",
                     "minimum_value_warning": "3 * resolveOrValue('layer_height')",
-                    "enabled": "infill_pattern != 'lightning' and infill_sparse_density > 0 and gradual_infill_steps > 0 and infill_pattern != 'cubicsubdiv'",
+                    "enabled": "infill_sparse_density > 0 and gradual_infill_steps > 0 and infill_pattern not in ['cubicsubdiv', 'cross', 'cross_3d', 'lightning']",
                     "limit_to_extruder": "infill_extruder_nr",
                     "settable_per_mesh": true
                 },
@@ -2212,7 +2272,7 @@
                         "lightning_infill_prune_angle":
                         {
                             "label": "Lightning Infill Prune Angle",
-                            "description": "The difference a lightning infill layer can have with the one immediately above w.r.t the pruning of the outer extremities of trees. Measured in the angle given the thickness.",
+                            "description": "The endpoints of infill lines are shortened to save on material. This setting is the angle of overhang of the endpoints of these lines.",
                             "unit": "°",
                             "type": "float",
                             "minimum_value": "0",
@@ -2228,7 +2288,7 @@
                         "lightning_infill_straightening_angle":
                         {
                             "label": "Lightning Infill Straightening Angle",
-                            "description": "The difference a lightning infill layer can have with the one immediately above w.r.t the smoothing of trees. Measured in the angle given the thickness.",
+                            "description": "The infill lines are straightened out to save on printing time. This is the maximum angle of overhang allowed across the length of the infill line.",
                             "unit": "°",
                             "type": "float",
                             "minimum_value": "0",
@@ -2452,7 +2512,42 @@
                     "maximum_value_warning": "120",
                     "settable_per_mesh": false,
                     "settable_per_extruder": false,
-                    "resolve": "sum(extruderValues(\"material_shrinkage_percentage\")) / len(extruderValues(\"material_shrinkage_percentage\"))"
+                    "resolve": "sum(extruderValues(\"material_shrinkage_percentage\")) / len(extruderValues(\"material_shrinkage_percentage\"))",
+                    "children":
+                    {
+                        "material_shrinkage_percentage_xy":
+                        {
+                            "label": "Horizontal Scaling Factor Shrinkage Compensation",
+                            "description": "To compensate for the shrinkage of the material as it cools down, the model will be scaled with this factor in the XY-direction (horizontally).",
+                            "unit": "%",
+                            "type": "float",
+                            "default_value": 100.0,
+                            "enabled": false,
+                            "minimum_value": "0.001",
+                            "minimum_value_warning": "100",
+                            "maximum_value_warning": "120",
+                            "settable_per_mesh": false,
+                            "settable_per_extruder": false,
+                            "resolve": "sum(extruderValues(\"material_shrinkage_percentage_xy\")) / len(extruderValues(\"material_shrinkage_percentage_xy\"))",
+                            "value": "material_shrinkage_percentage"
+                        },
+                        "material_shrinkage_percentage_z":
+                        {
+                            "label": "Vertical Scaling Factor Shrinkage Compensation",
+                            "description": "To compensate for the shrinkage of the material as it cools down, the model will be scaled with this factor in the Z-direction (vertically).",
+                            "unit": "%",
+                            "type": "float",
+                            "default_value": 100.0,
+                            "enabled": false,
+                            "minimum_value": "0.001",
+                            "minimum_value_warning": "100",
+                            "maximum_value_warning": "120",
+                            "settable_per_mesh": false,
+                            "settable_per_extruder": false,
+                            "resolve": "sum(extruderValues(\"material_shrinkage_percentage_z\")) / len(extruderValues(\"material_shrinkage_percentage_z\"))",
+                            "value": "material_shrinkage_percentage"
+                        }
+                    }
                 },
                 "material_crystallinity":
                 {
@@ -3163,26 +3258,15 @@
                     "settable_per_mesh": false,
                     "settable_per_extruder": false
                 },
-                "speed_equalize_flow_enabled":
+                "speed_equalize_flow_width_factor":
                 {
-                    "label": "Equalize Filament Flow",
+                    "label": "Flow Equalization Ratio",
-                    "description": "Print thinner than normal lines faster so that the amount of material extruded per second remains the same. Thin pieces in your model might require lines printed with smaller line width than provided in the settings. This setting controls the speed changes for such lines.",
+                    "description": "Extrusion width based correction factor on the speed. At 0% the movement speed is kept constant at the Print Speed. At 100% the movement speed is adjusted so that the flow (in mm³/s) is kept constant, i.e. lines half the normal Line Width are printed twice as fast and lines twice as wide are printed half as fast. A value larger than 100% can help to compensate for the higher pressure required to extrude wide lines.",
-                    "type": "bool",
-                    "default_value": false,
-                    "settable_per_mesh": false,
-                    "settable_per_extruder": true
-                },
-                "speed_equalize_flow_max":
-                {
-                    "label": "Maximum Speed for Flow Equalization",
-                    "description": "Maximum print speed when adjusting the print speed in order to equalize flow.",
                     "type": "float",
-                    "unit": "mm/s",
+                    "unit": "%",
-                    "enabled": "speed_equalize_flow_enabled",
+                    "default_value": 100.0,
-                    "default_value": 150,
+                    "minimum_value": "0.0",
-                    "minimum_value": "0.1",
+                    "maximum_value_warning": "200.0",
-                    "maximum_value": "math.sqrt(machine_max_feedrate_x ** 2 + machine_max_feedrate_y ** 2)",
-                    "maximum_value_warning": "150",
                     "settable_per_mesh": false,
                     "settable_per_extruder": true
                 },
@@ -4446,6 +4530,7 @@
                     "minimum_value": "0",
                     "minimum_value_warning": "1 if support_pattern == 'concentric' else 0",
                     "maximum_value_warning": "0 if (support_skip_some_zags and support_pattern == 'zigzag') else 3",
+                    "maximum_value": "999999",
                     "type": "int",
                     "value": "1 if support_enable and support_structure == 'tree' else (1 if (support_pattern == 'grid' or support_pattern == 'triangles' or support_pattern == 'concentric') else 0)",
                     "enabled": "support_enable or support_meshes_present",
@@ -4556,6 +4641,7 @@
                     "default_value": 8.0,
                     "minimum_value": "0.0",
                     "maximum_value_warning": "50.0",
+                    "maximum_value": "0.5 * min(machine_width, machine_depth)",
                     "enabled": "(support_enable or support_meshes_present) and support_brim_enable",
                     "settable_per_mesh": false,
                     "settable_per_extruder": true,
@@ -4570,6 +4656,7 @@
                             "default_value": 20,
                             "minimum_value": "0",
                             "maximum_value_warning": "50 / skirt_brim_line_width",
+                            "maximum_value": "0.5 * min(machine_width, machine_depth) / skirt_brim_line_width",
                             "value": "math.ceil(support_brim_width / (skirt_brim_line_width * initial_layer_line_width_factor / 100.0))",
                             "enabled": "(support_enable or support_meshes_present) and support_brim_enable",
                             "settable_per_mesh": false,
@@ -4602,7 +4689,7 @@
                             "default_value": 0.1,
                             "type": "float",
                             "enabled": "support_enable or support_meshes_present",
-                            "value": "extruderValue(support_roof_extruder_nr if support_roof_enable else support_infill_extruder_nr, 'support_z_distance')",
+                            "value": "extruderValue(support_roof_extruder_nr if support_roof_enable else support_infill_extruder_nr, 'support_z_distance') + (layer_height if support_structure == 'tree' else 0)",
                             "limit_to_extruder": "support_roof_extruder_nr if support_roof_enable else support_infill_extruder_nr",
                             "settable_per_mesh": true
                         },
@@ -5333,6 +5420,7 @@
                     "default_value": 1,
                     "minimum_value": "0",
                     "maximum_value_warning": "10",
+                    "maximum_value": "0.5 * min(machine_width, machine_depth) / skirt_brim_line_width",
                     "enabled": "resolveOrValue('adhesion_type') == 'skirt'",
                     "settable_per_mesh": false,
                     "settable_per_extruder": true,
@@ -5458,7 +5546,7 @@
                     "default_value": 5,
                     "minimum_value": "0",
                     "minimum_value_warning": "raft_interface_line_width",
-                    "enabled": "resolveOrValue('adhesion_type') == 'raft'",
+                    "enabled": "resolveOrValue('adhesion_type') == 'raft' and not raft_remove_inside_corners",
                     "limit_to_extruder": "adhesion_extruder_nr",
                     "settable_per_mesh": false,
                     "settable_per_extruder": true
@@ -6244,6 +6332,18 @@
                     "minimum_value_warning": "0.01",
                     "maximum_value_warning": "0.3",
                     "settable_per_mesh": true
+                },
+                "meshfix_maximum_extrusion_area_deviation":
+                {
+                    "label": "Maximum Extrusion Area Deviation",
+                    "description": "The maximum extrusion area deviation allowed when removing intermediate points from a straight line. An intermediate point may serve as width-changing point in a long straight line. Therefore, if it is removed, it will cause the line to have a uniform width and, as a result, lose (or gain) a bit of extrusion area. If you increase this you may notice slight under- (or over-) extrusion in between straight parallel walls, as more intermediate width-changing points will be allowed to be removed. Your print will be less accurate, but the g-code will be smaller.",
+                    "type": "float",
+                    "unit": "μm²",
+                    "default_value": 2000,
+                    "minimum_value": "0",
+                    "minimum_value_warning": "500",
+                    "maximum_value_warning": "50000",
+                    "settable_per_mesh": true
                 }
             }
         },
@@ -6793,6 +6893,7 @@
                     "type": "bool",
                     "default_value": false,
                     "limit_to_extruder": "wall_0_extruder_nr",
+                    "enabled": false,
                     "settable_per_mesh": true
                 },
                 "magic_fuzzy_skin_outside_only":
@@ -6801,7 +6902,7 @@
                     "description": "Jitter only the parts' outlines and not the parts' holes.",
                     "type": "bool",
                     "default_value": false,
-                    "enabled": "magic_fuzzy_skin_enabled",
+                    "enabled": "magic_fuzzy_skin_enabled and False" ,
                     "limit_to_extruder": "wall_0_extruder_nr",
                     "settable_per_mesh": true
                 },
@@ -6814,7 +6915,7 @@
                     "default_value": 0.3,
                     "minimum_value": "0.001",
                     "maximum_value_warning": "wall_line_width_0",
-                    "enabled": "magic_fuzzy_skin_enabled",
+                    "enabled": "magic_fuzzy_skin_enabled and False",
                     "limit_to_extruder": "wall_0_extruder_nr",
                     "settable_per_mesh": true
                 },
@@ -6829,7 +6930,7 @@
                     "minimum_value_warning": "0.1",
                     "maximum_value_warning": "10",
                     "maximum_value": "2 / magic_fuzzy_skin_thickness",
-                    "enabled": "magic_fuzzy_skin_enabled",
+                    "enabled": "magic_fuzzy_skin_enabled and False",
                     "limit_to_extruder": "wall_0_extruder_nr",
                     "settable_per_mesh": true,
                     "children":
@@ -6845,7 +6946,7 @@
                             "minimum_value_warning": "0.1",
                             "maximum_value_warning": "10",
                             "value": "10000 if magic_fuzzy_skin_point_density == 0 else 1 / magic_fuzzy_skin_point_density",
-                            "enabled": "magic_fuzzy_skin_enabled",
+                            "enabled": "magic_fuzzy_skin_enabled and False",
                             "limit_to_extruder": "wall_0_extruder_nr",
                             "settable_per_mesh": true
                         }
@@ -7424,6 +7525,7 @@
                     "minimum_value": "5",
                     "maximum_value": "100",
                     "minimum_value_warning": "20",
+                    "maximum_value_warning": "100",
                     "enabled": "bridge_settings_enabled",
                     "settable_per_mesh": true
                 },
@@ -7469,8 +7571,7 @@
                     "unit": "%",
                     "default_value": 100,
                     "type": "float",
-                    "minimum_value": "5",
+                    "minimum_value": "0.0001",
-                    "maximum_value": "500",
                     "minimum_value_warning": "50",
                     "maximum_value_warning": "150",
                     "enabled": "bridge_settings_enabled and bridge_enable_more_layers",
@@ -7483,9 +7584,9 @@
                     "unit": "%",
                     "default_value": 75,
                     "type": "float",
-                    "minimum_value": "5",
+                    "minimum_value": "0",
-                    "maximum_value": "100",
                     "minimum_value_warning": "20",
+                    "maximum_value_warning": "100",
                     "enabled": "bridge_settings_enabled and bridge_enable_more_layers",
                     "settable_per_mesh": true
                 },
@@ -7522,8 +7623,7 @@
                     "unit": "%",
                     "default_value": 110,
                     "type": "float",
-                    "minimum_value": "5",
+                    "minimum_value": "0.001",
-                    "maximum_value": "500",
                     "minimum_value_warning": "50",
                     "maximum_value_warning": "150",
                     "enabled": "bridge_settings_enabled and bridge_enable_more_layers",
@@ -7536,9 +7636,9 @@
                     "unit": "%",
                     "default_value": 80,
                     "type": "float",
-                    "minimum_value": "5",
+                    "minimum_value": "0",
-                    "maximum_value": "100",
                     "minimum_value_warning": "20",
+                    "maximum_value_warning": "100",
                     "enabled": "bridge_settings_enabled and bridge_enable_more_layers",
                     "settable_per_mesh": true
                 },
@@ -7806,6 +7906,36 @@
                     "minimum_value_warning": "25",
                     "maximum_value_warning": "100",
                     "settable_per_mesh": true
+                },
+                "material_alternate_walls":
+                {
+                    "label": "Alternate Wall Directions",
+                    "description": "Alternate wall directions every other layer and inset. Useful for materials that can build up stress, like for metal printing.",
+                    "type": "bool",
+                    "default_value": false,
+                    "enabled": false,
+                    "settable_per_mesh": true,
+                    "settable_per_extruder": true
+                },
+                "raft_remove_inside_corners":
+                {
+                    "label": "Remove Raft Inside Corners",
+                    "description": "Remove inside corners from the raft, causing the raft to become convex.",
+                    "type": "bool",
+                    "default_value": false,
+                    "enabled": "resolveOrValue('adhesion_type') == 'raft'",
+                    "settable_per_mesh": false,
+                    "settable_per_extruder": false
+                },
+                "raft_base_wall_count":
+                {
+                    "label": "Raft Base Wall Count",
+                    "description": "The number of contours to print around the linear pattern in the base layer of the raft.",
+                    "type": "int",
+                    "default_value": 1,
+                    "enabled": "resolveOrValue('adhesion_type') == 'raft'",
+                    "settable_per_mesh": false,
+                    "settable_per_extruder": false
                 }
             }
         },

resources/definitions/flyingbear_base.def.json

@@ -175,8 +175,6 @@
         "wall_0_wipe_dist": { "value": 0.0 },
         "top_bottom_thickness": { "value":  "layer_height_0 + layer_height * 3 if layer_height > 0.15 else 0.8" },
         "optimize_wall_printing_order": { "value": true },
-        "travel_compensate_overlapping_walls_0_enabled": { "value": false },
-        "fill_perimeter_gaps": { "value": "'everywhere'" },
         "filter_out_tiny_gaps": { "value": false },
         "fill_outline_gaps": { "value": false },
         "z_seam_type": { "value": "'sharpest_corner'" },

resources/definitions/fusedform_base.def.json

@@ -48,7 +48,6 @@
  	"speed_topbottom": {"value": 40 },
 	"speed_wall": { "value": 35 },
 	"speed_wall_x": { "value": 40 },
-	"speed_equalize_flow_max": { "value": 70 },
 
  	"retraction_enable": {"default_value":true},
 	"retraction_amount": { "default_value": 4 },

resources/definitions/fusedform_doppia_base.def.json

@@ -48,7 +48,6 @@
  	"speed_topbottom": {"value": 40 },
 	"speed_wall": { "value": 35 },
 	"speed_wall_x": { "value": 40 },
-	"speed_equalize_flow_max": { "value": 70 },
 
  	"retraction_enable": {"default_value":true},
 	"retraction_amount": { "default_value": 4 },

resources/definitions/goofoo_base.def.json

@@ -84,7 +84,6 @@
         "material_initial_print_temperature": { "value": "material_print_temperature" },
         "material_final_print_temperature": { "value": "material_print_temperature" },
         "material_flow": { "value": 100 },
-        "travel_compensate_overlapping_walls_0_enabled": { "value": "False" },
 
         "z_seam_type": { "value": "'back'" },
         "z_seam_corner": { "value": "'z_seam_corner_weighted'" },
@@ -97,7 +96,6 @@
         "infill_wipe_dist": { "value": 0.0 },
         "wall_0_wipe_dist": { "value": 0.0 },
 
-        "fill_perimeter_gaps": { "value": "'everywhere'" },
         "fill_outline_gaps": { "value": false },
         "filter_out_tiny_gaps": { "value": false },
 

resources/definitions/hellbot_magna_2_230_dual.def.json

@@ -37,9 +37,15 @@
         },
         "machine_extruder_count": {
             "default_value": 2
+        },
+	      "machine_extruders_share_heater": {
+            "default_value": true
+        },
+	      "machine_extruders_share_nozzle": {
+            "default_value": true
         },
         "machine_start_gcode": {
-             "default_value": "G21\nG90\nM107\nG28 X0 Y0\nG28 Z0\nG1 Z15.0 F300\nT0\nG92 E0\nG1 F700 E-80\nT1\nG92 E0\nG1 F1000 X1 Y1 Z0.3\nG1 F600 X200 E60\nG1 F1000 Y3\nG1 F600 X1 E120\nT1\nG92 E0\nG28 X0 Y0\nG1 F700 E-80\nT0\nG92 E0"
+             "default_value": "M104 T0 S{material_print_temperature}\nM104 T1 S{material_print_temperature}\nM109 T0 S{material_print_temperature}\nM109 T1 S{material_print_temperature}\nG21\nG90 \nG28 X0 Y0 \nG28 Z0 \nG1 Z15.0 F300 \nT0 \nG92 E0 \nG1 F700 E-80 \nT1 \nG92 E0 \nG1 F1000 X1 Y1 Z0.3 \nG1 F600 X200 E60 \nG1 F1000 Y3 \nG1 F600 X1 E120 \nT1 \nG92 E0 \nG28 X0 Y0 \nG1 F700 E-80 \nT0 \nG92 E0"
         },
         "machine_end_gcode": {
             "default_value": "M104 T0 S0\nM104 T1 S0\nM140 S0\nG92 E1\nG1 E-1 F300\nG28 X0 Y0\nM84"

resources/definitions/hellbot_magna_2_300_dual.def.json

@@ -37,9 +37,15 @@
         },
         "machine_extruder_count": {
             "default_value": 2
+        },
+	     "machine_extruders_share_heater": {
+            "default_value": true
+        },
+	      "machine_extruders_share_nozzle": {
+            "default_value": true
         },
         "machine_start_gcode": {
-            "default_value": "G21\nG90\nM107\nG28 X0 Y0\nG28 Z0\nG1 Z15.0 F300\nT0\nG92 E0\nG1 F700 E-80\nT1\nG92 E0\nG1 F1000 X1 Y1 Z0.3\nG1 F600 X200 E60\nG1 F1000 Y3\nG1 F600 X1 E120\nT1\nG92 E0\nG28 X0 Y0\nG1 F700 E-80\nT0\nG92 E0"
+            "default_value": "M104 T0 S{material_print_temperature}\nM104 T1 S{material_print_temperature}\nM109 T0 S{material_print_temperature}\nM109 T1 S{material_print_temperature}\nG21\nG90 \nG28 X0 Y0 \nG28 Z0 \nG1 Z15.0 F300 \nT0 \nG92 E0 \nG1 F700 E-80 \nT1 \nG92 E0 \nG1 F1000 X1 Y1 Z0.3 \nG1 F600 X200 E60 \nG1 F1000 Y3 \nG1 F600 X1 E120 \nT1 \nG92 E0 \nG28 X0 Y0 \nG1 F700 E-80 \nT0 \nG92 E0"
         },
         "machine_end_gcode": {
             "default_value": "M104 T0 S0\nM104 T1 S0\nM140 S0\nG92 E1\nG1 E-1 F300\nG28 X0 Y0\nM84"

resources/definitions/hellbot_magna_2_400_dual.def.json

@@ -38,6 +38,12 @@
         "machine_extruder_count": {
             "default_value": 2
         },
+	"machine_extruders_share_heater": {
+            "default_value": true
+        },
+	"machine_extruders_share_nozzle": {
+            "default_value": true
+        },
         "machine_start_gcode": {
             "default_value": "M104 T0 S{material_print_temperature}\nM104 T1 S{material_print_temperature}\nM109 T0 S{material_print_temperature}\nM109 T1 S{material_print_temperature}\nG21\nG90 \nG28 X0 Y0 \nG28 Z0 \nG1 Z15.0 F300 \nT0 \nG92 E0 \nG1 F700 E-80 \nT1 \nG92 E0 \nG1 F1000 X1 Y1 Z0.3 \nG1 F600 X200 E60 \nG1 F1000 Y3 \nG1 F600 X1 E120 \nT1 \nG92 E0 \nG28 X0 Y0 \nG1 F700 E-80 \nT0 \nG92 E0"
         },

resources/definitions/hellbot_magna_2_500_dual.def.json

@@ -37,6 +37,12 @@
         },
         "machine_extruder_count": {
             "default_value": 2
+        },
+	      "machine_extruders_share_heater": {
+            "default_value": true
+        },
+	      "machine_extruders_share_nozzle": {
+            "default_value": true
         },
         "machine_start_gcode": {
             "default_value": "M104 T0 S{material_print_temperature}\nM104 T1 S{material_print_temperature}\nM109 T0 S{material_print_temperature}\nM109 T1 S{material_print_temperature}\nG21\nG90 \nG28 X0 Y0 \nG28 Z0 \nG1 Z15.0 F300 \nT0 \nG92 E0 \nG1 F700 E-80 \nT1 \nG92 E0 \nG1 F1000 X1 Y1 Z0.3 \nG1 F600 X200 E60 \nG1 F1000 Y3 \nG1 F600 X1 E120 \nT1 \nG92 E0 \nG28 X0 Y0 \nG1 F700 E-80 \nT0 \nG92 E0"

resources/definitions/hellbot_magna_SE.def.json

@@ -0,0 +1,41 @@
+{
+    "version": 2,
+    "name": "Hellbot Magna SE",
+    "inherits": "fdmprinter",
+    "metadata": {
+        "visible": true,
+        "author": "Hellbot Development Team",
+        "manufacturer": "Hellbot",
+        "file_formats": "text/x-gcode",
+		"platform": "hellbot_magna_SE.obj",
+        "platform_texture": "hellbot_magna_SE.png",
+        "has_materials": true,
+        "machine_extruder_trains":
+        {
+            "0": "hellbot_magna_SE_extruder"
+        }
+
+    },
+
+    "overrides": {
+        "machine_name": { "default_value": "Hellbot Magna SE" },
+        "machine_width": {
+            "default_value": 230
+        },
+		"machine_depth": {
+            "default_value": 230
+        },  
+        "machine_height": {
+            "default_value": 250
+        },      
+		"machine_heated_bed": {
+			"default_value": true 
+		},
+        "machine_center_is_zero": {
+            "default_value": false
+        },
+        "machine_extruder_count": {
+            "default_value": 1
+        }
+    }
+}

resources/definitions/hms434.def.json

@@ -89,9 +89,8 @@
         "top_layers":                {"value": "4 if infill_sparse_density < 95 else 1" },
         "bottom_layers":             {"value": "(top_layers)" },
         "wall_0_inset":              {"value": "0" },
-        "outer_inset_first":         {"value": true },
+        "inset_direction":           {"value": "'outside_in'" },
         "alternate_extra_perimeter": {"value": false },
-        "travel_compensate_overlapping_walls_enabled": {"value": false },
         "filter_out_tiny_gaps":      {"value": true },
         "fill_outline_gaps":         {"value": true },
         "z_seam_type":               {"value": "'shortest'"},

resources/definitions/julia.def.json

@@ -4,7 +4,6 @@
     "inherits": "fdmprinter",
     "metadata": {
         "visible": true,
-        "author": "Ultimaker",
         "manufacturer": "Fracktal",
         "file_formats": "text/x-gcode",
         "platform_offset": [ 0, 0, 0],

resources/definitions/kingroon_base.def.json

@@ -194,7 +194,6 @@
         "material_initial_print_temperature": { "value": "material_print_temperature" },
         "material_final_print_temperature": { "value": "material_print_temperature" },
         "material_flow": { "value": 100 },
-        "travel_compensate_overlapping_walls_0_enabled": { "value": false },
 
         "z_seam_type": { "value": "'back'" },
         "z_seam_corner": { "value": "'z_seam_corner_none'" },
@@ -207,7 +206,6 @@
         "infill_wipe_dist": { "value": 0.0 },
         "wall_0_wipe_dist": { "value": 0.0 },
 
-        "fill_perimeter_gaps": { "value": "'everywhere'" },
         "fill_outline_gaps": { "value": false },
         "filter_out_tiny_gaps": { "value": false },
 

resources/definitions/koonovo_base.def.json

@@ -112,7 +112,6 @@
         "minimum_support_area": { "value": 2 },
         "minimum_interface_area": { "value": 10 },
 
-        "fill_perimeter_gaps": { "value": "'everywhere'" },
         "fill_outline_gaps": { "value": false },
         "filter_out_tiny_gaps": { "value": false },
 

resources/definitions/koonovo_kn3.def.json

@@ -129,7 +129,6 @@
         "minimum_support_area": { "value": 2 },
         "minimum_interface_area": { "value": 10 },
 
-        "fill_perimeter_gaps": { "value": "'everywhere'" },
         "fill_outline_gaps": { "value": false },
         "filter_out_tiny_gaps": { "value": false },
 

resources/definitions/koonovo_kn5.def.json

@@ -130,7 +130,6 @@
         "minimum_support_area": { "value": 2 },
         "minimum_interface_area": { "value": 10 },
 
-        "fill_perimeter_gaps": { "value": "'everywhere'" },
         "fill_outline_gaps": { "value": false },
         "filter_out_tiny_gaps": { "value": false },
 

resources/definitions/liquid.def.json

@@ -144,7 +144,6 @@
         "retraction_prime_speed": { "value": "35" },
         
         "skin_overlap": { "value": "10" },
-        "speed_equalize_flow_enabled": { "value": "True" },
         "speed_layer_0": { "value": "20" },
         "speed_prime_tower": { "value": "speed_topbottom" },
         "speed_print": { "value": "35" },

resources/definitions/longer_base.def.json

@@ -84,7 +84,6 @@
         "material_initial_print_temperature": { "value": "material_print_temperature" },
         "material_final_print_temperature": { "value": "material_print_temperature" },
         "material_flow": { "value": 100 },
-        "travel_compensate_overlapping_walls_0_enabled": { "value": "False" },
 
         "z_seam_type": { "value": "'back'" },
         "z_seam_corner": { "value": "'z_seam_corner_weighted'" },
@@ -97,7 +96,6 @@
         "infill_wipe_dist": { "value": 0.0 },
         "wall_0_wipe_dist": { "value": 0.0 },
 
-        "fill_perimeter_gaps": { "value": "'everywhere'" },
         "fill_outline_gaps": { "value": false },
         "filter_out_tiny_gaps": { "value": false },
 

resources/definitions/maker_made_300x.def.json

@@ -49,13 +49,8 @@
         "top_bottom_pattern_0": {"value": "'lines'" },
         "wall_0_inset": {"value": 0},
         "optimize_wall_printing_order": {"value": false },
-        "outer_inset_first": {"value": false },
+        "inset_direction": {"value": "'inside_out'" },
         "alternate_extra_perimeter": {"value": false },
-        "travel_compensate_overlapping_walls_enabled": {"value": true },
-        "travel_compensate_overlapping_walls_0_enabled": {"value": true },
-        "travel_compensate_overlapping_walls_x_enabled": {"value": true },
-        "wall_min_flow": {"value": 0},
-        "fill_perimeter_gaps": {"value": "'everywhere'" },
         "filter_out_tiny_gaps": {"value": true },
         "fill_outline_gaps": {"value": true },
         "xy_offset": {"value": 0},
@@ -97,7 +92,6 @@
         "speed_layer_0": {"value": 10},
         "speed_travel_layer_0": {"value": 50},
         "speed_slowdown_layers": {"value": 2},
-        "speed_equalize_flow_enabled": {"value": false },
         "acceleration_enabled": {"value": false },
         "acceleration_roofing":  {"value": 3000 },
         "jerk_enabled":  {"value": false },

resources/definitions/maker_starter.def.json

@@ -78,7 +78,7 @@
             "default_value": 0.2
         },
         "support_pattern": {
-            "default_value": "ZigZag"
+            "default_value": "zigzag"
         },
         "support_infill_rate": {
             "value": "15 if support_enable and support_structure == 'normal' else 0 if support_enable and support_structure == 'tree' else 15"

resources/definitions/makerbotreplicator.def.json

@@ -4,7 +4,6 @@
     "inherits": "fdmprinter",
     "metadata": {
         "visible": true,
-        "author": "Ultimaker",
         "manufacturer": "MakerBot",
         "machine_x3g_variant": "r1",
         "file_formats": "application/x3g",