Merge branch 'main' into fest_silent_uninstall

.github/ISSUE_TEMPLATE/SlicingCrash.yaml

@@ -6,9 +6,9 @@ body:
   attributes:
     value: |      
        ### ✨Try our improved Cura 5.7✨
-       Before filling out the report below, we want you to try the latest Cura 5.7 Beta. 
+       Before filling out the report below, we want you to try the latest Cura 5.7. 
        This version of Cura has become significantly more reliable and has an updated slicing engine that will automatically send a report to the Cura Team for analysis. 
-       #### [You can find the downloads here](https://github.com/Ultimaker/Cura/releases/tag/5.7.0-beta.1) #### 
+       #### [You can find the downloads here](https://github.com/Ultimaker/Cura/releases/latest) #### 
        If you still encounter a crash you are still welcome to report the issue so we can use your model as a test case, you can find instructions on how to do that below.      
        
        ### Project File
@@ -35,7 +35,7 @@ body:
 - type: markdown
   attributes:
     value: |
-      We work hard on improving our slicing crashes. Our most recent release is 5.6.0.
+      We work hard on improving our slicing crashes. Our most recent release is 5.7.1.
       If you are not on the latest version of Cura, [you can download it here](https://github.com/Ultimaker/Cura/releases/latest)
 - type: input
   attributes:

.github/workflows/printer-linter-format.yml

@@ -16,7 +16,7 @@ jobs:
         runs-on: ubuntu-latest
         steps:
             -   name: Checkout
-                uses: actions/checkout@v3
+                uses: actions/checkout@v4
 
             -   uses: technote-space/get-diff-action@v6
                 with:

.github/workflows/printer-linter-pr-diagnose.yml

@@ -15,7 +15,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 2
 
@@ -55,7 +55,7 @@ jobs:
           echo ${{ github.event.pull_request.head.repo.full_name }} > printer-linter-result/pr-head-repo.txt
           echo ${{ github.event.pull_request.head.sha }} > printer-linter-result/pr-head-sha.txt
 
-      - uses: actions/upload-artifact@v2
+      - uses: actions/upload-artifact@v4
         with:
           name: printer-linter-result
           path: printer-linter-result/

.github/workflows/release-process_release-candidate.yml

@@ -9,6 +9,11 @@ on:
         required: true
         type: string
 
+      publish_release_description:
+        description: 'Create the GitHub release (if existing, the description will be overridden based on the changelog)'
+        required: true
+        type: boolean
+
 jobs:
   parse-version:
     name: Parse input version string
@@ -65,6 +70,8 @@ jobs:
     name: Create tags
     runs-on: ubuntu-latest
     needs: [parse-version, find-rc-tag]
+    outputs:
+      main_commit: ${{ steps.export-main-commit.outputs.main_commit }}
     strategy:
       matrix:
         repository: [Cura, Uranium, CuraEngine, cura-binary-data, fdm_materials]
@@ -76,11 +83,23 @@ jobs:
           ref: ${{ needs.parse-version.outputs.branch_name }}
           token: ${{ secrets.CURA_AUTORELEASE_PAT }}
 
-      - name: Create tag
+      - name: Create RC tag
         run: |
           git tag ${{ needs.find-rc-tag.outputs.tag_name }}
           git push origin tag ${{ needs.find-rc-tag.outputs.tag_name }}
 
+      - name: Create or update release tag
+        run: |
+          git tag -f ${{ inputs.cura_version }}
+          git push -f origin tag ${{ inputs.cura_version }}
+
+      - name: Export Cura tagged commit
+        id: export-main-commit
+        if: ${{ matrix.repository == 'Cura' }}
+        run: |
+          echo "main_commit=`git rev-parse HEAD`" >> "$GITHUB_OUTPUT"
+
+
   create-dependencies-packages:
     name: Create conan packages for dependencies
     uses: ultimaker/cura-workflows/.github/workflows/conan-package-release.yml@main
@@ -131,7 +150,7 @@ jobs:
   create-release-draft:
     name: Create the release draft
     runs-on: ubuntu-latest
-    needs: [create-installers, parse-version]
+    needs: [create-installers, parse-version, create-tags]
     steps:
       - name: Checkout Cura repo
         uses: actions/checkout@v4
@@ -139,18 +158,14 @@ jobs:
           ref: ${{ needs.parse-version.outputs.branch_name }}
 
       - name: Extract changelog
+        if: ${{ inputs.publish_release_description }}
         run: python ./scripts/extract_changelog.py --version ${{ needs.parse-version.outputs.version_major }}.${{ needs.parse-version.outputs.version_minor }}.${{ needs.parse-version.outputs.version_patch }} --changelog ./resources/texts/change_log.txt > formatted_changelog.txt
 
-      - name: Get commit id for release
-        id: get-commit-id
-        uses: iawia002/get-tag-or-commit-id@v1.0.1
-        with:
-          length: 40
-
       - name: Create release
         uses: notpeelz/action-gh-create-release@v5.0.1
+        if: ${{ inputs.publish_release_description }}
         with:
-          target: ${{ steps.get-commit-id.outputs.id }}
+          target: ${{ needs.create-tags.outputs.main_commit }}
           tag: ${{ inputs.cura_version }}
           strategy: replace
           title: UltiMaker Cura ${{ inputs.cura_version }}

conandata.yml

@@ -1,17 +1,16 @@
-version: "5.8.0-beta.1"
+version: "5.9.0-alpha.0"
 requirements:
-  - "cura_resources/5.8.0-beta.1"
-  - "uranium/5.8.0-beta.1"
-  - "curaengine/5.8.0-beta.1"
-  - "cura_binary_data/5.8.0-beta.1"
-  - "fdm_materials/5.8.0-beta.1"
-  - "curaengine_plugin_gradual_flow/0.1.0-beta.4"
+  - "cura_resources/(latest)@ultimaker/testing"
+  - "uranium/(latest)@ultimaker/testing"
+  - "curaengine/(latest)@ultimaker/testing"
+  - "cura_binary_data/(latest)@ultimaker/testing"
+  - "fdm_materials/(latest)@ultimaker/testing"
   - "dulcificum/0.2.1"
   - "pysavitar/5.3.0"
   - "pynest2d/5.3.0"
   - "native_cad_plugin/2.0.0"
 requirements_internal:
-  - "fdm_materials/5.8.0-beta.1"
+  - "fdm_materials/5.8.1"
   - "cura_private_data/(latest)@internal/testing"
 urls:
     default:
@@ -34,14 +33,6 @@ pyinstaller:
             package: "cura"
             src: "plugins"
             dst: "share/cura/plugins"
-        curaengine_gradual_flow_plugin:
-            package: "curaengine_plugin_gradual_flow"
-            src: "res/plugins/CuraEngineGradualFlow"
-            dst: "share/cura/plugins/CuraEngineGradualFlow"
-        curaengine_gradual_flow_plugin_bundled:
-            package: "curaengine_plugin_gradual_flow"
-            src: "res/bundled_packages"
-            dst: "share/cura/resources/bundled_packages"
         native_cad_plugin:
           package: "native_cad_plugin"
           src: "res/plugins/NativeCADplugin"
@@ -105,11 +96,6 @@ pyinstaller:
             src: "bin"
             dst: "."
             binary: "CuraEngine"
-        curaengine_gradual_flow_plugin_service:
-            package: "curaengine_plugin_gradual_flow"
-            src: "bin"
-            dst: "."
-            binary: "curaengine_plugin_gradual_flow"
     hiddenimports:
         - "pySavitar"
         - "pyArcus"

conanfile.py

@@ -390,17 +390,11 @@ class CuraConan(ConanFile):
             copy(self, "CuraEngine", curaengine.bindirs[0], self.source_folder, keep_path = False)
 
             # Copy the external plugins that we want to bundle with Cura
-            rmdir(self,str(self.source_path.joinpath("plugins", "CuraEngineGradualFlow")))
-            curaengine_plugin_gradual_flow = self.dependencies["curaengine_plugin_gradual_flow"].cpp_info
-            copy(self, "*", curaengine_plugin_gradual_flow.resdirs[0], str(self.source_path.joinpath("plugins", "CuraEngineGradualFlow")), keep_path = True)
-            copy(self, "*", curaengine_plugin_gradual_flow.bindirs[0], self.source_folder, keep_path = False)
-            copy(self, "bundled_*.json", curaengine_plugin_gradual_flow.resdirs[1], str(self.source_path.joinpath("resources", "bundled_packages")), keep_path = False)
-
             if self._enterprise:
                 rmdir(self, str(self.source_path.joinpath("plugins", "NativeCADplugin")))
-                curaengine_plugin_gradual_flow = self.dependencies["native_cad_plugin"].cpp_info
-                copy(self, "*", curaengine_plugin_gradual_flow.resdirs[0], str(self.source_path.joinpath("plugins", "NativeCADplugin")), keep_path = True)
-                copy(self, "bundled_*.json", curaengine_plugin_gradual_flow.resdirs[1], str(self.source_path.joinpath("resources", "bundled_packages")), keep_path = False)
+                native_cad_plugin = self.dependencies["native_cad_plugin"].cpp_info
+                copy(self, "*", native_cad_plugin.resdirs[0], str(self.source_path.joinpath("plugins", "NativeCADplugin")), keep_path = True)
+                copy(self, "bundled_*.json", native_cad_plugin.resdirs[1], str(self.source_path.joinpath("resources", "bundled_packages")), keep_path = False)
 
         # Copy resources of cura_binary_data
         cura_binary_data = self.dependencies["cura_binary_data"].cpp_info
@@ -517,10 +511,6 @@ echo "CURA_APP_NAME={{ cura_app_name }}" >> ${{ env_prefix }}GITHUB_ENV
         copy(self, "requirement*.txt", src = self.source_folder, dst = os.path.join(self.package_folder, self.cpp.package.resdirs[-1]))
         copy(self, "*", src = os.path.join(self.source_folder, "packaging"), dst = os.path.join(self.package_folder, self.cpp.package.resdirs[2]))
 
-        # Remove the CuraEngineGradualFlow plugin from the package
-        rmdir(self, os.path.join(self.package_folder, self.cpp.package.resdirs[1], "CuraEngineGradualFlow"))
-        rm(self, "bundled_*.json", os.path.join(self.package_folder, self.cpp.package.resdirs[0], "bundled_packages"), recursive = False)
-
         # Remove the fdm_materials from the package
         rmdir(self, os.path.join(self.package_folder, self.cpp.package.resdirs[0], "materials"))
 

cura/API/Account.py

@@ -232,6 +232,7 @@ class Account(QObject):
 
     def _onProfileChanged(self, profile: Optional[UserProfile]) -> None:
         self._user_profile = profile
+        self._updatePermissions()
         self.userProfileChanged.emit()
 
     def _sync(self) -> None:

cura/API/Interface/Settings.py

@@ -1,7 +1,13 @@
 # Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
-from typing import TYPE_CHECKING
+from dataclasses import asdict
+
+from typing import cast, Dict, TYPE_CHECKING
+
+from UM.Settings.InstanceContainer import InstanceContainer
+from UM.Settings.SettingFunction import SettingFunction
+from cura.Settings.GlobalStack import GlobalStack
 
 if TYPE_CHECKING:
     from cura.CuraApplication import CuraApplication
@@ -47,3 +53,57 @@ class Settings:
         """
 
         return self.application.getSidebarCustomMenuItems()
+
+    def getSliceMetadata(self) -> Dict[str, Dict[str, Dict[str, str]]]:
+        """Get all changed settings and all settings. For each extruder and the global stack"""
+        print_information = self.application.getPrintInformation()
+        machine_manager = self.application.getMachineManager()
+        settings = {
+            "material": {
+                "length": print_information.materialLengths,
+                "weight": print_information.materialWeights,
+                "cost": print_information.materialCosts,
+            },
+            "global": {
+                "changes": {},
+                "all_settings": {},
+            },
+            "quality": asdict(machine_manager.activeQualityDisplayNameMap()),
+        }
+
+        def _retrieveValue(container: InstanceContainer, setting_: str):
+            value_ = container.getProperty(setting_, "value")
+            for _ in range(0, 1024):  # Prevent possibly endless loop by not using a limit.
+                if not isinstance(value_, SettingFunction):
+                    return value_  # Success!
+                value_ = value_(container)
+            return 0  # Fallback value after breaking possibly endless loop.
+
+        global_stack = cast(GlobalStack, self.application.getGlobalContainerStack())
+
+        # Add global user or quality changes
+        global_flattened_changes = InstanceContainer.createMergedInstanceContainer(global_stack.userChanges, global_stack.qualityChanges)
+        for setting in global_flattened_changes.getAllKeys():
+            settings["global"]["changes"][setting] = _retrieveValue(global_flattened_changes, setting)
+
+        # Get global all settings values without user or quality changes
+        for setting in global_stack.getAllKeys():
+            settings["global"]["all_settings"][setting] = _retrieveValue(global_stack, setting)
+
+        for i, extruder in enumerate(global_stack.extruderList):
+            # Add extruder fields to settings dictionary
+            settings[f"extruder_{i}"] = {
+                "changes": {},
+                "all_settings": {},
+            }
+
+            # Add extruder user or quality changes
+            extruder_flattened_changes = InstanceContainer.createMergedInstanceContainer(extruder.userChanges, extruder.qualityChanges)
+            for setting in extruder_flattened_changes.getAllKeys():
+                settings[f"extruder_{i}"]["changes"][setting] = _retrieveValue(extruder_flattened_changes, setting)
+
+            # Get extruder all settings values without user or quality changes
+            for setting in extruder.getAllKeys():
+                settings[f"extruder_{i}"]["all_settings"][setting] = _retrieveValue(extruder, setting)
+
+        return settings

cura/CuraApplication.py

@@ -139,7 +139,7 @@ class CuraApplication(QtApplication):
     # SettingVersion represents the set of settings available in the machine/extruder definitions.
     # You need to make sure that this version number needs to be increased if there is any non-backwards-compatible
     # changes of the settings.
-    SettingVersion = 23
+    SettingVersion = 24
 
     Created = False
 

cura/Machines/MachineNode.py

@@ -1,8 +1,9 @@
-# Copyright (c) 2019 Ultimaker B.V.
+# Copyright (c) 2024 UltiMaker
 # Cura is released under the terms of the LGPLv3 or higher.
 
 from typing import Dict, List
 
+from UM.Decorators import deprecated
 from UM.Logger import Logger
 from UM.Signal import Signal
 from UM.Util import parseBool
@@ -47,6 +48,7 @@ class MachineNode(ContainerNode):
         self.preferred_variant_name = my_metadata.get("preferred_variant_name", "")
         self.preferred_material = my_metadata.get("preferred_material", "")
         self.preferred_quality_type = my_metadata.get("preferred_quality_type", "")
+        self.supports_abstract_color = parseBool(my_metadata.get("supports_abstract_color", "false"))
 
         self._loadAll()
 
@@ -168,13 +170,18 @@ class MachineNode(ContainerNode):
 
         return self.global_qualities.get(self.preferred_quality_type, next(iter(self.global_qualities.values())))
 
-    def isExcludedMaterial(self, material: MaterialNode) -> bool:
+    def isExcludedMaterialBaseFile(self, material_base_file: str) -> bool:
         """Returns whether the material should be excluded from the list of materials."""
         for exclude_material in self.exclude_materials:
-            if exclude_material in material["id"]:
+            if exclude_material in material_base_file:
                 return True
         return False
 
+    @deprecated("Use isExcludedMaterialBaseFile instead.", since = "5.9.0")
+    def isExcludedMaterial(self, material: MaterialNode) -> bool:
+        """Returns whether the material should be excluded from the list of materials."""
+        return self.isExcludedMaterialBaseFile(material.base_file)
+
     @UM.FlameProfiler.profile
     def _loadAll(self) -> None:
         """(Re)loads all variants under this printer."""

cura/Machines/Models/QualityManagementModel.py

@@ -127,13 +127,12 @@ class QualityManagementModel(ListModel):
         # have no container for the global stack, because "my_profile" just got renamed to "my_new_profile". This results
         # in crashes because the rest of the system assumes that all data in a QualityChangesGroup will be correct.
         #
-        # Renaming the container for the global stack in the end seems to be ok, because the assumption is mostly based
-        # on the quality changes container for the global stack.
+        # This is why we use the "supress_signals" flag for the set name. This basically makes the change silent.
         for metadata in quality_changes_group.metadata_per_extruder.values():
             extruder_container = cast(InstanceContainer, container_registry.findContainers(id = metadata["id"])[0])
-            extruder_container.setName(new_name)
+            extruder_container.setName(new_name, supress_signals=True)
         global_container = cast(InstanceContainer, container_registry.findContainers(id = quality_changes_group.metadata_for_global["id"])[0])
-        global_container.setName(new_name)
+        global_container.setName(new_name, supress_signals=True)
 
         quality_changes_group.name = new_name
 

cura/Machines/VariantNode.py

@@ -60,9 +60,11 @@ class VariantNode(ContainerNode):
             materials = list(materials_per_base_file.values())
 
         # Filter materials based on the exclude_materials property.
-        filtered_materials = [material for material in materials if not self.machine.isExcludedMaterial(material)]
+        filtered_materials = [material for material in materials if not self.machine.isExcludedMaterialBaseFile(material["id"])]
 
         for material in filtered_materials:
+            if material.get("abstract_color", False) and not self.machine.supports_abstract_color:
+                continue  # do not show abstract color profiles if the machine does not support them
             base_file = material["base_file"]
             if base_file not in self.materials:
                 self.materials[base_file] = MaterialNode(material["id"], variant = self)
@@ -126,8 +128,10 @@ class VariantNode(ContainerNode):
             return  # We won't add any materials.
         material_definition = container.getMetaDataEntry("definition")
 
+        if (not self.machine.supports_abstract_color) and container.getMetaDataEntry("abstract_color", False):
+            return
         base_file = container.getMetaDataEntry("base_file")
-        if base_file in self.machine.exclude_materials:
+        if self.machine.isExcludedMaterialBaseFile(base_file):
             return  # Material is forbidden for this printer.
         if base_file not in self.materials:  # Completely new base file. Always better than not having a file as long as it matches our set-up.
             if material_definition != "fdmprinter" and material_definition != self.machine.container_id:

cura/PrinterOutput/FormatMaps.py

@@ -0,0 +1,108 @@
+# Copyright (c) 2024 UltiMaker
+# Cura is released under the terms of the LGPLv3 or higher.
+
+from UM.Resources import Resources
+
+import json
+from typing import Dict, List, Optional
+
+class FormatMaps:
+
+    # A map from the printer-type in their native file-formats to the internal name we use.
+    PRINTER_TYPE_NAME = {
+        "fire_e": "ultimaker_method",
+        "lava_f": "ultimaker_methodx",
+        "magma_10": "ultimaker_methodxl",
+        "sketch": "ultimaker_sketch"
+    }
+
+    # A map from the extruder-name in their native file-formats to the internal name we use.
+    EXTRUDER_NAME_MAP = {
+        "mk14_hot": "1XA",
+        "mk14_hot_s": "2XA",
+        "mk14_c": "1C",
+        "mk14": "1A",
+        "mk14_s": "2A",
+        "mk14_e": "LABS"
+    }
+
+    # A map from the material-name in their native file-formats to some info, including the internal name we use.
+    MATERIAL_MAP = {
+        "abs": {"name": "ABS", "guid": "e0f1d581-cc6b-4e36-8f3c-3f5601ecba5f"},
+         "abs-cf10": {"name": "ABS-CF", "guid": "495a0ce5-9daf-4a16-b7b2-06856d82394d"},
+         "abs-wss1": {"name": "ABS-R", "guid": "88c8919c-6a09-471a-b7b6-e801263d862d"},
+         "asa": {"name": "ASA", "guid": "f79bc612-21eb-482e-ad6c-87d75bdde066"},
+         "nylon12-cf": {"name": "Nylon 12 CF", "guid": "3c6f2877-71cc-4760-84e6-4b89ab243e3b"},
+         "nylon-cf": {"name": "Nylon CF", "guid": "17abb865-ca73-4ccd-aeda-38e294c9c60b"},
+         "nylon": {"name": "Nylon", "guid": "9475b03d-fd19-48a2-b7b5-be1fb46abb02"},
+         "pc": {"name": "PC", "guid": "62414577-94d1-490d-b1e4-7ef3ec40db02"},
+         "petg": {"name": "PETG", "guid": "2d004bbd-d1bb-47f8-beac-b066702d5273"},
+         "pla": {"name": "PLA", "guid": "abb9c58e-1f56-48d1-bd8f-055fde3a5b56"},
+         "pva": {"name": "PVA", "guid": "add51ef2-86eb-4c39-afd5-5586564f0715"},
+         "wss1": {"name": "RapidRinse", "guid": "a140ef8f-4f26-4e73-abe0-cfc29d6d1024"},
+         "sr30": {"name": "SR-30", "guid": "77873465-83a9-4283-bc44-4e542b8eb3eb"},
+         "bvoh": {"name": "BVOH", "guid": "923e604c-8432-4b09-96aa-9bbbd42207f4"},
+         "cpe": {"name": "CPE", "guid": "da1872c1-b991-4795-80ad-bdac0f131726"},
+         "hips": {"name": "HIPS", "guid": "a468d86a-220c-47eb-99a5-bbb47e514eb0"},
+         "tpu": {"name": "TPU 95A", "guid": "19baa6a9-94ff-478b-b4a1-8157b74358d2"},
+         "im-pla": {"name": "Tough", "guid": "96fca5d9-0371-4516-9e96-8e8182677f3c"}
+         # /!\ When changing this list, make sure the changes are reported accordingly on Digital Factory
+    }
+
+    __inverse_printer_name: Optional[Dict[str, str]] = None
+    __inverse_extruder_type: Optional[Dict[str, str]] = None
+    __inverse_material_map: Optional[Dict[str, str]] = None
+    __product_to_id_map: Optional[Dict[str, List[str]]] = None
+
+    @classmethod
+    def getInversePrinterNameMap(cls) -> Dict[str, str]:
+        """Returns the inverse of the printer name map, that is, from the internal name to the name used in output."""
+        if cls.__inverse_printer_name is not None:
+            return cls.__inverse_printer_name
+        cls.__inverse_printer_name = {}
+        for key, value in cls.PRINTER_TYPE_NAME.items():
+            cls.__inverse_printer_name[value] = key
+        return cls.__inverse_printer_name
+
+    @classmethod
+    def getInverseExtruderTypeMap(cls) -> Dict[str, str]:
+        """Returns the inverse of the extruder type map, that is, from the internal name to the name used in output."""
+        if cls.__inverse_extruder_type is not None:
+            return cls.__inverse_extruder_type
+        cls.__inverse_extruder_type = {}
+        for key, value in cls.EXTRUDER_NAME_MAP.items():
+            cls.__inverse_extruder_type[value] = key
+        return cls.__inverse_extruder_type
+
+    @classmethod
+    def getInverseMaterialMap(cls) -> Dict[str, str]:
+        """Returns the inverse of the material map, that is, from the internal name to the name used in output.
+
+        Note that this drops the extra info saved in the non-inverse material map, use that if you need it.
+        """
+        if cls.__inverse_material_map is not None:
+            return cls.__inverse_material_map
+        cls.__inverse_material_map = {}
+        for key, value in cls.MATERIAL_MAP.items():
+            cls.__inverse_material_map[value["name"]] = key
+        return cls.__inverse_material_map
+
+    @classmethod
+    def getProductIdMap(cls) -> Dict[str, List[str]]:
+        """Gets a mapping from product names (for example, in the XML files) to their definition IDs.
+
+        This loads the mapping from a file.
+        """
+        if cls.__product_to_id_map is not None:
+            return cls.__product_to_id_map
+
+        product_to_id_file = Resources.getPath(Resources.Texts, "product_to_id.json")
+        with open(product_to_id_file, encoding = "utf-8") as f:
+            contents = ""
+            for line in f:
+                contents += line if "#" not in line else "".join([line.replace("#", str(n)) for n in range(1, 12)])
+            cls.__product_to_id_map = json.loads(contents)
+        cls.__product_to_id_map = {key: [value] for key, value in cls.__product_to_id_map.items()}
+        #This also loads "Ultimaker S5" -> "ultimaker_s5" even though that is not strictly necessary with the default to change spaces into underscores.
+        #However it is not always loaded with that default; this mapping is also used in serialize() without that default.
+        return cls.__product_to_id_map

cura/PrinterOutput/Models/ExtruderConfigurationModel.py

@@ -1,9 +1,10 @@
-# Copyright (c) 2018 Ultimaker B.V.
+# Copyright (c) 2024 UltiMaker
 # Cura is released under the terms of the LGPLv3 or higher.
 from typing import Optional
 
 from PyQt6.QtCore import pyqtProperty, QObject, pyqtSignal
 
+from cura.PrinterOutput.FormatMaps import FormatMaps
 from .MaterialOutputModel import MaterialOutputModel
 
 
@@ -45,16 +46,8 @@ class ExtruderConfigurationModel(QObject):
 
     @staticmethod
     def applyNameMappingHotend(hotendId) -> str:
-        _EXTRUDER_NAME_MAP = {
-            "mk14_hot":"1XA",
-            "mk14_hot_s":"2XA",
-            "mk14_c":"1C",
-            "mk14":"1A",
-            "mk14_s":"2A",
-            "mk14_e": "LABS"
-        }
-        if hotendId in _EXTRUDER_NAME_MAP:
-            return _EXTRUDER_NAME_MAP[hotendId]
+        if hotendId in FormatMaps.EXTRUDER_NAME_MAP:
+            return FormatMaps.EXTRUDER_NAME_MAP[hotendId]
         return hotendId
 
     @pyqtProperty(str, fset = setHotendID, notify = extruderConfigurationChanged)

cura/PrinterOutput/Models/MaterialOutputModel.py

@@ -1,9 +1,10 @@
-# Copyright (c) 2017 Ultimaker B.V.
+# Copyright (c) 2024 UltiMaker
 # Cura is released under the terms of the LGPLv3 or higher.
 
 from typing import Optional
 
 from PyQt6.QtCore import pyqtProperty, QObject
+from cura.PrinterOutput.FormatMaps import FormatMaps
 
 
 class MaterialOutputModel(QObject):
@@ -23,30 +24,9 @@ class MaterialOutputModel(QObject):
 
     @staticmethod
     def getMaterialFromDefinition(guid, type, brand, name):
-
-        _MATERIAL_MAP = {	"abs"       :{"name" :"ABS"           ,"guid": "2780b345-577b-4a24-a2c5-12e6aad3e690"},
-                            "abs-cf10"  :{"name": "ABS-CF"        ,"guid": "495a0ce5-9daf-4a16-b7b2-06856d82394d"},
-                            "abs-wss1"  :{"name" :"ABS-R"         ,"guid": "88c8919c-6a09-471a-b7b6-e801263d862d"},
-                            "asa"       :{"name" :"ASA"           ,"guid": "f79bc612-21eb-482e-ad6c-87d75bdde066"},
-                            "nylon12-cf":{"name": "Nylon 12 CF"   ,"guid": "3c6f2877-71cc-4760-84e6-4b89ab243e3b"},
-                            "nylon"     :{"name" :"Nylon"         ,"guid": "283d439a-3490-4481-920c-c51d8cdecf9c"},
-                            "pc"        :{"name" :"PC"            ,"guid": "62414577-94d1-490d-b1e4-7ef3ec40db02"},
-                            "petg"      :{"name" :"PETG"          ,"guid": "69386c85-5b6c-421a-bec5-aeb1fb33f060"},
-                            "pla"       :{"name" :"PLA"           ,"guid": "abb9c58e-1f56-48d1-bd8f-055fde3a5b56"},
-                            "pva"       :{"name" :"PVA"           ,"guid": "add51ef2-86eb-4c39-afd5-5586564f0715"},
-                            "wss1"      :{"name" :"RapidRinse"    ,"guid": "a140ef8f-4f26-4e73-abe0-cfc29d6d1024"},
-                            "sr30"      :{"name" :"SR-30"         ,"guid": "77873465-83a9-4283-bc44-4e542b8eb3eb"},
-                            "bvoh"      :{"name" :"BVOH"          ,"guid": "923e604c-8432-4b09-96aa-9bbbd42207f4"},
-                            "cpe"       :{"name" :"CPE"           ,"guid": "da1872c1-b991-4795-80ad-bdac0f131726"},
-                            "hips"      :{"name" :"HIPS"          ,"guid": "a468d86a-220c-47eb-99a5-bbb47e514eb0"},
-                            "tpu"       :{"name" :"TPU 95A"       ,"guid": "19baa6a9-94ff-478b-b4a1-8157b74358d2"},
-                            "im-pla"    :{"name": "Tough"         ,"guid": "de031137-a8ca-4a72-bd1b-17bb964033ad"}
-                        }
-
-
-        if guid is None and brand != "empty" and type in _MATERIAL_MAP:
-            name = _MATERIAL_MAP[type]["name"]
-            guid = _MATERIAL_MAP[type]["guid"]
+        if guid is None and brand != "empty" and type in FormatMaps.MATERIAL_MAP:
+            name = FormatMaps.MATERIAL_MAP[type]["name"]
+            guid = FormatMaps.MATERIAL_MAP[type]["guid"]
         return name, guid
 
 

cura/PrinterOutput/NetworkedPrinterOutputDevice.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Ultimaker B.V.
+# Copyright (c) 2024 UltiMaker
 # Cura is released under the terms of the LGPLv3 or higher.
 
 from UM.FileHandler.FileHandler import FileHandler #For typing.
@@ -6,6 +6,7 @@ from UM.Logger import Logger
 from UM.Scene.SceneNode import SceneNode #For typing.
 from cura.API import Account
 from cura.CuraApplication import CuraApplication
+from cura.PrinterOutput.FormatMaps import FormatMaps
 
 from cura.PrinterOutput.PrinterOutputDevice import PrinterOutputDevice, ConnectionState, ConnectionType
 
@@ -419,14 +420,8 @@ class NetworkedPrinterOutputDevice(PrinterOutputDevice):
 
     @staticmethod
     def applyPrinterTypeMapping(printer_type):
-        _PRINTER_TYPE_NAME = {
-            "fire_e": "ultimaker_method",
-            "lava_f": "ultimaker_methodx",
-            "magma_10": "ultimaker_methodxl",
-            "sketch": "ultimaker_sketch"
-        }
-        if printer_type in _PRINTER_TYPE_NAME:
-            return _PRINTER_TYPE_NAME[printer_type]
+        if printer_type in FormatMaps.PRINTER_TYPE_NAME:
+            return FormatMaps.PRINTER_TYPE_NAME[printer_type]
         return printer_type
 
     @pyqtProperty(str, constant = True)

cura/Settings/CuraContainerStack.py

@@ -5,7 +5,7 @@ from typing import Any, cast, List, Optional, Dict
 from PyQt6.QtCore import pyqtProperty, pyqtSignal, QObject
 
 from UM.Application import Application
-from UM.Decorators import override
+from UM.Decorators import CachedMemberFunctions, override
 from UM.FlameProfiler import pyqtSlot
 from UM.Logger import Logger
 from UM.Settings.ContainerStack import ContainerStack, InvalidContainerStackError
@@ -237,6 +237,7 @@ class CuraContainerStack(ContainerStack):
         :param new_value: The new value to set the property to.
         """
 
+        CachedMemberFunctions.clearInstanceCache(self)
         container_index = _ContainerIndexes.UserChanges
         self._containers[container_index].setProperty(key, property_name, property_value, container, set_from_cache)
 

cura/Settings/ExtruderStack.py

@@ -5,7 +5,7 @@ from typing import Any, Dict, TYPE_CHECKING, Optional
 
 from PyQt6.QtCore import pyqtProperty, pyqtSignal
 
-from UM.Decorators import override
+from UM.Decorators import CachedMemberFunctions, override
 from UM.MimeTypeDatabase import MimeType, MimeTypeDatabase
 from UM.Settings.ContainerStack import ContainerStack
 from UM.Settings.ContainerRegistry import ContainerRegistry
@@ -86,6 +86,7 @@ class ExtruderStack(CuraContainerStack):
     def setCompatibleMaterialDiameter(self, value: float) -> None:
         old_approximate_diameter = self.getApproximateMaterialDiameter()
         if self.getCompatibleMaterialDiameter() != value:
+            CachedMemberFunctions.clearInstanceCache(self)
             self.definitionChanges.setProperty("material_diameter", "value", value)
             self.compatibleMaterialDiameterChanged.emit()
 

plugins/3MFWriter/ThreeMFWriter.py

@@ -114,22 +114,24 @@ class ThreeMFWriter(MeshWriter):
 
         mesh_data = um_node.getMeshData()
 
+        node_matrix = um_node.getLocalTransformation()
+        node_matrix.preMultiply(transformation)
+        
         if center_mesh:
-            node_matrix = Matrix()
+            center_matrix = Matrix()
             # compensate for original center position, if object(s) is/are not around its zero position
             if mesh_data is not None:
                 extents = mesh_data.getExtents()
                 if extents is not None:
                     # We use a different coordinate space while writing, so flip Z and Y
-                    center_vector = Vector(extents.center.x, extents.center.y, extents.center.z)
-                    node_matrix.setByTranslation(center_vector)
-            node_matrix.multiply(um_node.getLocalTransformation())
-        else:
-            node_matrix = um_node.getLocalTransformation()
+                    center_vector = Vector(-extents.center.x, -extents.center.y, -extents.center.z)
+                    center_matrix.setByTranslation(center_vector)
+            node_matrix.preMultiply(center_matrix)
 
-        matrix_string = ThreeMFWriter._convertMatrixToString(node_matrix.preMultiply(transformation))
+        matrix_string = ThreeMFWriter._convertMatrixToString(node_matrix)
 
         savitar_node.setTransformation(matrix_string)
+
         if mesh_data is not None:
             savitar_node.getMeshData().setVerticesFromBytes(mesh_data.getVerticesAsByteArray())
             indices_array = mesh_data.getIndicesAsByteArray()

plugins/CuraEngineBackend/CuraEngineBackend.py

@@ -197,7 +197,8 @@ class CuraEngineBackend(QObject, Backend):
         self._slicing_error_message.actionTriggered.connect(self._reportBackendError)
 
         self._resetLastSliceTimeStats()
-        self._snapshot: Optional[QImage] = None 
+        self._snapshot: Optional[QImage] = None
+        self._last_socket_error: Optional[Arcus.Error] = None
 
         application.initializationFinished.connect(self.initialize)
 
@@ -569,7 +570,20 @@ class CuraEngineBackend(QObject, Backend):
             return
 
         # Preparation completed, send it to the backend.
-        self._socket.sendMessage(job.getSliceMessage())
+        immediate_success = self._socket.sendMessage(job.getSliceMessage())
+        if (not CuraApplication.getInstance().getUseExternalBackend()) and (not immediate_success):
+            if self._last_socket_error is not None and self._last_socket_error.getErrorCode() == Arcus.ErrorCode.MessageTooBigError:
+                error_txt = catalog.i18nc("@info:status", "Unable to send the model data to the engine. Please try to use a less detailed model, or reduce the number of instances.")
+            else:
+                error_txt = catalog.i18nc("@info:status", "Unable to send the model data to the engine. Please try again, or contact support.")
+
+            self._error_message = Message(error_txt,
+                                          title=catalog.i18nc("@info:title", "Unable to slice"),
+                                          message_type=Message.MessageType.WARNING)
+            self._error_message.show()
+            self.setState(BackendState.Error)
+            self.backendError.emit(job)
+            return
 
         # Notify the user that it's now up to the backend to do its job
         self.setState(BackendState.Processing)
@@ -691,6 +705,7 @@ class CuraEngineBackend(QObject, Backend):
         if error.getErrorCode() == Arcus.ErrorCode.Debug:
             return
 
+        self._last_socket_error = error
         self._terminate()
         self._createSocket()
 

plugins/CuraEngineBackend/StartSliceJob.py

@@ -49,7 +49,20 @@ class StartJobResult(IntEnum):
     ObjectsWithDisabledExtruder = 8
 
 
-class GcodeStartEndFormatter(Formatter):
+class GcodeConditionState(IntEnum):
+    OutsideCondition = 1
+    ConditionFalse = 2
+    ConditionTrue = 3
+    ConditionDone = 4
+
+
+class GcodeInstruction(IntEnum):
+    Skip = 1
+    Evaluate = 2
+    EvaluateAndWrite = 3
+
+
+class GcodeStartEndFormatter:
     # Formatter class that handles token expansion in start/end gcode
     # Example of a start/end gcode string:
     # ```
@@ -63,22 +76,50 @@ class GcodeStartEndFormatter(Formatter):
     # will be used. Alternatively, if the expression is formatted as "{[expression], [extruder_nr]}",
     # then the expression will be evaluated with the extruder stack of the specified extruder_nr.
 
-    _extruder_regex = re.compile(r"^\s*(?P<expression>.*)\s*,\s*(?P<extruder_nr_expr>.*)\s*$")
+    _instruction_regex = re.compile(r"{(?P<condition>if|else|elif|endif)?\s*(?P<expression>.*?)\s*(?:,\s*(?P<extruder_nr_expr>.*))?\s*}(?P<end_of_line>\n?)")
 
-    def __init__(self, all_extruder_settings: Dict[str, Any], default_extruder_nr: int = -1) -> None:
+    def __init__(self, all_extruder_settings: Dict[str, Dict[str, Any]], default_extruder_nr: int = -1) -> None:
         super().__init__()
-        self._all_extruder_settings: Dict[str, Any] = all_extruder_settings
+        self._all_extruder_settings: Dict[str, Dict[str, Any]] = all_extruder_settings
         self._default_extruder_nr: int = default_extruder_nr
+        self._cura_application = CuraApplication.getInstance()
+        self._extruder_manager = ExtruderManager.getInstance()
 
-    def get_field(self, field_name, args: [str], kwargs: dict) -> Tuple[str, str]:
-        # get_field method parses all fields in the format-string and parses them individually to the get_value method.
-        # e.g. for a string "Hello {foo.bar}" would the complete field "foo.bar" would be passed to get_field, and then
-        # the individual parts "foo" and "bar" would be passed to get_value. This poses a problem for us, because  want
-        # to parse the entire field as a single expression. To solve this, we override the get_field method and return
-        # the entire field as the expression.
-        return self.get_value(field_name, args, kwargs), field_name
+    def format(self, text: str) -> str:
+        remaining_text: str = text
+        result: str = ""
 
-    def get_value(self, expression: str, args: [str], kwargs: dict) -> str:
+        self._condition_state: GcodeConditionState = GcodeConditionState.OutsideCondition
+
+        while len(remaining_text) > 0:
+            next_code_match = self._instruction_regex.search(remaining_text)
+            if next_code_match is not None:
+                expression_start, expression_end = next_code_match.span()
+
+                if expression_start > 0:
+                    result += self._process_statement(remaining_text[:expression_start])
+
+                result += self._process_code(next_code_match)
+
+                remaining_text = remaining_text[expression_end:]
+
+            else:
+                result += self._process_statement(remaining_text)
+                remaining_text = ""
+
+        return result
+
+    def _process_statement(self, statement: str) -> str:
+        if self._condition_state in [GcodeConditionState.OutsideCondition, GcodeConditionState.ConditionTrue]:
+            return statement
+        else:
+            return ""
+
+    def _process_code(self, code: re.Match) -> str:
+        condition: Optional[str] = code.group("condition")
+        expression: Optional[str] = code.group("expression")
+        extruder_nr_expr: Optional[str] = code.group("extruder_nr_expr")
+        end_of_line: Optional[str] = code.group("end_of_line")
 
         # The following variables are not settings, but only become available after slicing.
         # when these variables are encountered, we return them as-is. They are replaced later
@@ -87,53 +128,100 @@ class GcodeStartEndFormatter(Formatter):
         if expression in post_slice_data_variables:
             return f"{{{expression}}}"
 
-        extruder_nr = str(self._default_extruder_nr)
+        extruder_nr: str = str(self._default_extruder_nr)
+        instruction: GcodeInstruction = GcodeInstruction.Skip
 
         # The settings may specify a specific extruder to use. This is done by
         # formatting the expression as "{expression}, {extruder_nr_expr}". If the
         # expression is formatted like this, we extract the extruder_nr and use
         # it to get the value from the correct extruder stack.
-        match = self._extruder_regex.match(expression)
-        if match:
-            expression = match.group("expression")
-            extruder_nr_expr = match.group("extruder_nr_expr")
-
-            if extruder_nr_expr.isdigit():
-                extruder_nr = extruder_nr_expr
+        if condition is None:
+            # This is a classic statement
+            if self._condition_state in [GcodeConditionState.OutsideCondition, GcodeConditionState.ConditionTrue]:
+                # Skip and move to next
+                instruction = GcodeInstruction.EvaluateAndWrite
+        else:
+            # This is a condition statement, first check validity
+            if condition == "if":
+                if self._condition_state != GcodeConditionState.OutsideCondition:
+                    raise SyntaxError("Nested conditions are not supported")
             else:
-                # We get the value of the extruder_nr_expr from `_all_extruder_settings` dictionary
-                # rather than the global container stack. The `_all_extruder_settings["-1"]` is a
-                # dict-representation of the global container stack, with additional properties such
-                # as `initial_extruder_nr`. As users may enter such expressions we can't use the
-                # global container stack.
-                extruder_nr = str(self._all_extruder_settings["-1"].get(extruder_nr_expr, "-1"))
+                if self._condition_state == GcodeConditionState.OutsideCondition:
+                    raise SyntaxError("Condition should start with an 'if' statement")
 
-        if extruder_nr in self._all_extruder_settings:
-            additional_variables = self._all_extruder_settings[extruder_nr].copy()
-        else:
-            Logger.warning(f"Extruder {extruder_nr} does not exist, using global settings")
-            additional_variables = self._all_extruder_settings["-1"].copy()
+            if condition == "if":
+                # First instruction, just evaluate it
+                instruction = GcodeInstruction.Evaluate
 
-        # Add the arguments and keyword arguments to the additional settings. These
-        # are currently _not_ used, but they are added for consistency with the
-        # base Formatter class.
-        for key, value in enumerate(args):
-            additional_variables[key] = value
-        for key, value in kwargs.items():
-            additional_variables[key] = value
+            else:
+                if self._condition_state == GcodeConditionState.ConditionTrue:
+                    # We have reached the next condition after a valid one has been found, skip the rest
+                    self._condition_state = GcodeConditionState.ConditionDone
 
-        if extruder_nr == "-1":
-            container_stack = CuraApplication.getInstance().getGlobalContainerStack()
-        else:
-            container_stack = ExtruderManager.getInstance().getExtruderStack(extruder_nr)
-            if not container_stack:
+                if condition == "elif":
+                    if self._condition_state == GcodeConditionState.ConditionFalse:
+                        # New instruction, and valid condition has not been reached so far => evaluate it
+                        instruction = GcodeInstruction.Evaluate
+                    else:
+                        # New instruction, but valid condition has already been reached => skip it
+                        instruction = GcodeInstruction.Skip
+
+                elif condition == "else":
+                    instruction = GcodeInstruction.Skip # Never evaluate, expression should be empty
+                    if self._condition_state == GcodeConditionState.ConditionFalse:
+                        # Fallback instruction, and valid condition has not been reached so far => active next
+                        self._condition_state = GcodeConditionState.ConditionTrue
+
+                elif condition == "endif":
+                    instruction = GcodeInstruction.Skip  # Never evaluate, expression should be empty
+                    self._condition_state = GcodeConditionState.OutsideCondition
+
+        if instruction >= GcodeInstruction.Evaluate and extruder_nr_expr is not None:
+            extruder_nr_function = SettingFunction(extruder_nr_expr)
+            container_stack = self._cura_application.getGlobalContainerStack()
+
+            # We add the variables contained in `_all_extruder_settings["-1"]`, which is a dict-representation of the
+            # global container stack, with additional properties such as `initial_extruder_nr`. As users may enter such
+            # expressions we can't use the global container stack. The variables contained in the global container stack
+            # will then be inserted twice, which is not optimal but works well.
+            extruder_nr = str(extruder_nr_function(container_stack, additional_variables=self._all_extruder_settings["-1"]))
+
+        if instruction >= GcodeInstruction.Evaluate:
+            if extruder_nr in self._all_extruder_settings:
+                additional_variables = self._all_extruder_settings[extruder_nr].copy()
+            else:
                 Logger.warning(f"Extruder {extruder_nr} does not exist, using global settings")
-                container_stack = CuraApplication.getInstance().getGlobalContainerStack()
+                additional_variables = self._all_extruder_settings["-1"].copy()
 
-        setting_function = SettingFunction(expression)
-        value = setting_function(container_stack, additional_variables=additional_variables)
+            if extruder_nr == "-1":
+                container_stack = self._cura_application.getGlobalContainerStack()
+            else:
+                container_stack = self._extruder_manager.getExtruderStack(extruder_nr)
+                if not container_stack:
+                    Logger.warning(f"Extruder {extruder_nr} does not exist, using global settings")
+                    container_stack = self._cura_application.getGlobalContainerStack()
 
-        return value
+            setting_function = SettingFunction(expression)
+            value = setting_function(container_stack, additional_variables=additional_variables)
+
+            if instruction == GcodeInstruction.Evaluate:
+                if value:
+                    self._condition_state = GcodeConditionState.ConditionTrue
+                else:
+                    self._condition_state = GcodeConditionState.ConditionFalse
+
+                return ""
+            else:
+                value_str = str(value)
+
+                if end_of_line is not None:
+                    # If we are evaluating an expression that is not a condition, restore the end of line
+                    value_str += end_of_line
+
+                return value_str
+
+        else:
+            return ""
 
 
 class StartSliceJob(Job):
@@ -470,6 +558,9 @@ class StartSliceJob(Job):
         result["day"] = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"][int(time.strftime("%w"))]
         result["initial_extruder_nr"] = CuraApplication.getInstance().getExtruderManager().getInitialExtruderNr()
 
+        # If adding or changing a setting here, please update the associated wiki page
+        # https://github.com/Ultimaker/Cura/wiki/Start-End-G%E2%80%90Code
+
         return result
 
     def _cacheAllExtruderSettings(self):

plugins/DigitalLibrary/resources/qml/SaveProjectFilesPage.qml

@@ -208,7 +208,14 @@ Item
         anchors.rightMargin: UM.Theme.getSize("thin_margin").height
 
         enabled: UM.Backend.state == UM.Backend.Done
-        currentIndex: UM.Backend.state == UM.Backend.Done ? (Cura.MachineManager.activeMachine.getOutputFileFormats.includes("application/x-makerbot") ? 1 : 0) : 2
+
+        // Pre-select the correct index, depending on the situation (see the model-property below):
+        // - Don't select any post-slice-file-format when the engine isn't done.
+        // - Choose either the S-series or the Makerbot-series of printers' format otherwise, depending on the active printer.
+        // This way, the user can just click 'save' without having to worry about wether or not the format is right.
+        property int isMakerbotFormat: Cura.MachineManager.activeMachine.getOutputFileFormats.includes("application/x-makerbot") || Cura.MachineManager.activeMachine.getOutputFileFormats.includes("application/x-makerbot-sketch")
+        property int isBackendDone: UM.Backend.state == UM.Backend.Done
+        currentIndex: isBackendDone ? (isMakerbotFormat ? 1 : 0) : 2
 
         textRole: "text"
         valueRole: "value"

plugins/MachineSettingsAction/MachineSettingsExtruderTab.qml

@@ -182,7 +182,7 @@ Item
         Cura.GcodeTextArea   // "Extruder Start G-code"
         {
             anchors.top: parent.top
-            anchors.bottom: parent.bottom
+            anchors.bottom: buttonLearnMore.top
             anchors.bottomMargin: UM.Theme.getSize("default_margin").height
             anchors.left: parent.left
             width: base.columnWidth - UM.Theme.getSize("default_margin").width
@@ -196,7 +196,7 @@ Item
         Cura.GcodeTextArea   // "Extruder End G-code"
         {
             anchors.top: parent.top
-            anchors.bottom: parent.bottom
+            anchors.bottom: buttonLearnMore.top
             anchors.bottomMargin: UM.Theme.getSize("default_margin").height
             anchors.right: parent.right
             width: base.columnWidth - UM.Theme.getSize("default_margin").width
@@ -206,5 +206,17 @@ Item
             settingKey: "machine_extruder_end_code"
             settingStoreIndex: propertyStoreIndex
         }
+
+        Cura.TertiaryButton
+        {
+            id: buttonLearnMore
+
+            text: catalog.i18nc("@button", "Learn more")
+            iconSource: UM.Theme.getIcon("LinkExternal")
+            isIconOnRightSide: true
+            onClicked: Qt.openUrlExternally("https://github.com/Ultimaker/Cura/wiki/Start-End-G%E2%80%90Code")
+            anchors.bottom: parent.bottom
+            anchors.right: parent.right
+        }
     }
 }

plugins/MachineSettingsAction/MachineSettingsPrinterTab.qml

@@ -376,7 +376,7 @@ Item
         anchors
         {
             top: upperBlock.bottom
-            bottom: parent.bottom
+            bottom: buttonLearnMore.top
             left: parent.left
             right: parent.right
             margins: UM.Theme.getSize("default_margin").width
@@ -403,5 +403,19 @@ Item
             settingKey: "machine_end_gcode"
             settingStoreIndex: propertyStoreIndex
         }
+
+    }
+
+    Cura.TertiaryButton
+    {
+        id: buttonLearnMore
+
+        text: catalog.i18nc("@button", "Learn more")
+        iconSource: UM.Theme.getIcon("LinkExternal")
+        isIconOnRightSide: true
+        onClicked: Qt.openUrlExternally("https://github.com/Ultimaker/Cura/wiki/Start-End-G%E2%80%90Code")
+        anchors.bottom: parent.bottom
+        anchors.right: parent.right
+        anchors.margins: UM.Theme.getSize("default_margin").width
     }
 }

plugins/MakerbotWriter/MakerbotWriter.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2023 UltiMaker
+# Copyright (c) 2024 UltiMaker
 # Cura is released under the terms of the LGPLv3 or higher.
 from io import StringIO, BufferedIOBase
 import json
@@ -18,6 +18,7 @@ from UM.Scene.Iterator.DepthFirstIterator import DepthFirstIterator
 from UM.i18n import i18nCatalog
 
 from cura.CuraApplication import CuraApplication
+from cura.PrinterOutput.FormatMaps import FormatMaps
 from cura.Snapshot import Snapshot
 from cura.Utils.Threading import call_on_qt_thread
 from cura.CuraVersion import ConanInstalls
@@ -137,6 +138,30 @@ class MakerbotWriter(MeshWriter):
                 for png_file in png_files:
                     file, data = png_file["file"], png_file["data"]
                     zip_stream.writestr(file, data)
+                api = CuraApplication.getInstance().getCuraAPI()
+                metadata_json = api.interface.settings.getSliceMetadata()
+
+                # All the mapping stuff we have to do:
+                product_to_id_map = FormatMaps.getProductIdMap()
+                printer_name_map = FormatMaps.getInversePrinterNameMap()
+                extruder_type_map = FormatMaps.getInverseExtruderTypeMap()
+                material_map = FormatMaps.getInverseMaterialMap()
+                for key, value in metadata_json.items():
+                    if "all_settings" in value:
+                        if "machine_name" in value["all_settings"]:
+                            machine_name = value["all_settings"]["machine_name"]
+                            if machine_name in product_to_id_map:
+                                machine_name = product_to_id_map[machine_name][0]
+                            value["all_settings"]["machine_name"] = printer_name_map.get(machine_name, machine_name)
+                        if "machine_nozzle_id" in value["all_settings"]:
+                            extruder_type = value["all_settings"]["machine_nozzle_id"]
+                            value["all_settings"]["machine_nozzle_id"] = extruder_type_map.get(extruder_type, extruder_type)
+                        if "material_type" in value["all_settings"]:
+                            material_type = value["all_settings"]["material_type"]
+                            value["all_settings"]["material_type"] = material_map.get(material_type, material_type)
+
+                slice_metadata = json.dumps(metadata_json, separators=(", ", ": "), indent=4)
+                zip_stream.writestr("slicemetadata.json", slice_metadata)
         except (IOError, OSError, BadZipFile) as ex:
             Logger.log("e", f"Could not write to (.makerbot) file because: '{ex}'.")
             self.setInformation(catalog.i18nc("@error", "MakerbotWriter could not save to the designated path."))

plugins/PostProcessingPlugin/scripts/InsertAtLayerChange.py

@@ -1,65 +1,217 @@
 # Copyright (c) 2020 Ultimaker B.V.
-# Cura is released under the terms of the LGPLv3 or higher.
 # Created by Wayne Porter
+# Re-write in April of 2024 by GregValiant (Greg Foresi)
+# Changes:
+#     Added an 'Enable' setting
+#     Added support for multi-line insertions (comma delimited)
+#     Added insertions in a range of layers or a single insertion at a layer.  Numbers are consistent with the Cura Preview (base1)
+#     Added frequency of Insertion (once only, every layer, every 2nd, 3rd, 5th, 10th, 25th, 50th, 100th)
+#     Added support for 'One at a Time' print sequence
+#     Rafts are allowed and accounted for but no insertions are made in raft layers
 
 from ..Script import Script
+import re
+from UM.Application import Application
 
 class InsertAtLayerChange(Script):
-    def __init__(self):
-        super().__init__()
 
     def getSettingDataString(self):
         return """{
-            "name": "Insert at layer change",
+            "name": "Insert at Layer Change",
             "key": "InsertAtLayerChange",
             "metadata": {},
             "version": 2,
             "settings":
             {
-                "insert_location":
+                "enabled":
                 {
-                    "label": "When to insert",
-                    "description": "Whether to insert code before or after layer change.",
+                    "label": "Enable this script",
+                    "description": "You must enable the script for it to run.",
+                    "type": "bool",
+                    "default_value": true,
+                    "enabled": true
+                },
+                "insert_frequency":
+                {
+                    "label": "How often to insert",
+                    "description": "Every so many layers starting with the Start Layer OR as single insertion at a specific layer.  If the print sequence is 'one_at_a_time' then the insertions will be made for every model.  Insertions are made at the beginning of a layer.",
                     "type": "enum",
-                    "options": {"before": "Before", "after": "After"},
-                    "default_value": "before"
+                    "options": {
+                        "once_only": "One insertion only",
+                        "every_layer": "Every Layer",
+                        "every_2nd": "Every 2nd",
+                        "every_3rd": "Every 3rd",
+                        "every_5th": "Every 5th",
+                        "every_10th": "Every 10th",
+                        "every_25th": "Every 25th",
+                        "every_50th": "Every 50th",
+                        "every_100th": "Every 100th"},
+                    "default_value": "every_layer",
+                    "enabled": "enabled"
+                },
+                "start_layer":
+                {
+                    "label": "Starting Layer",
+                    "description": "The layer before which the first insertion will take place.  If the Print_Sequence is 'All at Once' then use the layer numbers from the Cura Preview.  Enter '1' to start at gcode LAYER:0. In 'One at a Time' mode use the layer numbers from the first model that prints AND all models will receive the same insertions.  NOTE: There is never an insertion for raft layers.",
+                    "type": "int",
+                    "default_value": 1,
+                    "minimum_value": 1,
+                    "enabled": "insert_frequency != 'once_only' and enabled"
+                },
+                "end_layer":
+                {
+                    "label": "Ending Layer",
+                    "description": "The layer before which the last insertion will take place.  Enter '-1' to indicate the entire file.  Use layer numbers from the Cura Preview.",
+                    "type": "int",
+                    "default_value": -1,
+                    "minimum_value": -1,
+                    "enabled": "insert_frequency != 'once_only' and enabled"
+                },
+                "single_end_layer":
+                {
+                    "label": "Layer # for Single Insertion.",
+                    "description": "The layer before which the Gcode insertion will take place.  Use the layer numbers from the Cura Preview.",
+                    "type": "str",
+                    "default_value": "",
+                    "enabled": "insert_frequency == 'once_only' and enabled"
                 },
                 "gcode_to_add":
                 {
-                    "label": "G-code to insert",
-                    "description": "G-code to add before or after layer change.",
+                    "label": "G-code to insert.",
+                    "description": "G-code to add at start of the layer. Use a comma to delimit multi-line commands. EX: G28 X Y,M220 S100,M117 HELL0.  NOTE:  All inserted text will be converted to upper-case as some firmwares don't understand lower-case.",
                     "type": "str",
-                    "default_value": ""
-                },
-                "skip_layers":
-                {
-                    "label": "Skip layers",
-                    "description": "Number of layers to skip between insertions (0 for every layer).",
-                    "type": "int",
-                    "default_value": 0,
-                    "minimum_value": 0
+                    "default_value": "",
+                    "enabled": "enabled"
                 }
             }
         }"""
 
     def execute(self, data):
-        gcode_to_add = self.getSettingValueByKey("gcode_to_add") + "\n"
-        skip_layers = self.getSettingValueByKey("skip_layers")
-        count = 0
-        for layer in data:
-            # Check that a layer is being printed
-            lines = layer.split("\n")
-            for line in lines:
-                if ";LAYER:" in line:
-                    index = data.index(layer)
-                    if count == 0:
-                        if self.getSettingValueByKey("insert_location") == "before":
-                            layer = gcode_to_add + layer
-                        else:
-                            layer = layer + gcode_to_add
-
-                        data[index] = layer
-
-                    count = (count + 1) % (skip_layers + 1)
-                    break
-        return data
+        # Exit if the script is not enabled
+        if not bool(self.getSettingValueByKey("enabled")):
+            return data
+        #Initialize variables
+        mycode = self.getSettingValueByKey("gcode_to_add").upper()
+        start_layer = int(self.getSettingValueByKey("start_layer"))
+        end_layer = int(self.getSettingValueByKey("end_layer"))
+        when_to_insert = self.getSettingValueByKey("insert_frequency")
+        end_list = [0]
+        print_sequence = Application.getInstance().getGlobalContainerStack().getProperty("print_sequence", "value")
+        # Get the topmost layer number and adjust the end_list
+        if end_layer == -1:
+            if print_sequence == "all_at_once":
+                for lnum in range(0, len(data) - 1):
+                    if ";LAYER:" in data[lnum]:
+                        the_top = int(data[lnum].split(";LAYER:")[1].split("\n")[0])
+                end_list[0] = the_top
+            # Get the topmost layer number for each model and append it to the end_list
+            if print_sequence == "one_at_a_time":
+                for lnum in range(0, 10):
+                    if ";LAYER:0" in data[lnum]:
+                        start_at = lnum + 1
+                        break
+                for lnum in range(start_at, len(data)-1, 1):
+                    if ";LAYER:" in data[lnum] and not ";LAYER:0" in data[lnum] and not ";LAYER:-" in data[lnum]:
+                        end_list[len(end_list) - 1] = int(data[lnum].split(";LAYER:")[1].split("\n")[0])
+                        continue
+                    if ";LAYER:0" in data[lnum]:
+                        end_list.append(0)
+        elif end_layer != -1:
+            if print_sequence == "all_at_once":
+                # Catch an error if the entered End_Layer > the top layer in the gcode
+                for e_num, layer in enumerate(data):
+                    if ";LAYER:" in layer:
+                        top_layer = int(data[e_num].split(";LAYER:")[1].split("\n")[0])
+                end_list[0] = end_layer - 1
+                if top_layer < end_layer - 1:
+                    end_list[0] = top_layer
+            elif print_sequence == "one_at_a_time":
+                # Find the index of the first Layer:0
+                for lnum in range(0, 10):
+                    if ";LAYER:0" in data[lnum]:
+                        start_at = lnum + 1
+                        break
+                # Get the top layer number for each model
+                for lnum in range(start_at, len(data)-1):
+                    if ";LAYER:" in data[lnum] and not ";LAYER:0" in data[lnum] and not ";LAYER:-" in data[lnum]:
+                        end_list[len(end_list) - 1] = int(data[lnum].split(";LAYER:")[1].split("\n")[0])
+                    if ";LAYER:0" in data[lnum]:
+                        end_list.append(0)
+                # Adjust the end list if an end layer was named
+                for index, num in enumerate(end_list):
+                    if num > end_layer - 1:
+                        end_list[index] = end_layer - 1
+        #If the gcode_to_enter is multi-line then replace the commas with newline characters
+        if mycode != "":
+            if "," in mycode:
+                mycode = re.sub(",", "\n",mycode)
+            gcode_to_add = mycode
+        #Get the insertion frequency
+        match when_to_insert:
+            case "every_layer":
+                freq = 1
+            case "every_2nd":
+                freq = 2
+            case "every_3rd":
+                freq = 3
+            case "every_5th":
+                freq = 5
+            case "every_10th":
+                freq = 10
+            case "every_25th":
+                freq = 25
+            case "every_50th":
+                freq = 50
+            case "every_100th":
+                freq = 100
+            case "once_only":
+                the_insert_layer = int(self.getSettingValueByKey("single_end_layer"))-1
+            case _:
+                raise ValueError(f"Unexpected insertion frequency {when_to_insert}")
+        #Single insertion
+        if when_to_insert == "once_only":
+            # For print sequence 'All at once'
+            if print_sequence == "all_at_once":
+                for index, layer in enumerate(data):
+                    if ";LAYER:" + str(the_insert_layer) + "\n" in layer:
+                        lines = layer.split("\n")
+                        lines.insert(1,gcode_to_add)
+                        data[index] = "\n".join(lines)
+                        return data
+            # For print sequence 'One at a time'
+            else:
+                for index, layer in enumerate(data):
+                    if ";LAYER:" + str(the_insert_layer) + "\n" in layer:
+                        lines = layer.split("\n")
+                        lines.insert(1,gcode_to_add)
+                        data[index] = "\n".join(lines)
+                return data
+        # For multiple insertions
+        if when_to_insert != "once_only":
+            # Search from the line after the first Layer:0 so we know when a model ends if in One at a Time mode.
+            first_0 = True
+            next_layer = start_layer - 1
+            end_layer = end_list.pop(0)
+            for index, layer in enumerate(data):
+                lines = layer.split("\n")
+                for l_index, line in enumerate(lines):
+                    if ";LAYER:" in line:
+                        layer_number = int(line.split(":")[1])
+                        if layer_number == next_layer and layer_number <= end_layer:
+                            lines.insert(l_index + 1,gcode_to_add)
+                            data[index] = "\n".join(lines)
+                            next_layer += freq
+                        # Reset the next_layer for one-at-a-time
+                        if next_layer > int(end_layer):
+                            next_layer = start_layer - 1
+                        # Index to the next end_layer when a Layer:0 is encountered
+                        try:
+                            if not first_0 and layer_number == 0:
+                                end_layer = end_list.pop(0)
+                        except:
+                            pass
+                        # Beyond the initial Layer:0 futher Layer:0's indicate the top layer of a model.
+                        if layer_number == 0:
+                            first_0 = False
+                        break
+        return data

plugins/PostProcessingPlugin/scripts/TimeLapse.py

@@ -1,9 +1,15 @@
-# Copyright (c) 2020 Ultimaker B.V.
-# Cura is released under the terms of the LGPLv3 or higher.
-# Created by Wayne Porter
+# Modified 5/15/2023 - Greg Valiant (Greg Foresi)
+#    Created by Wayne Porter
+#    Added insertion frequency
+#    Adjusted for use with Relative Extrusion
+#    Changed Retract to a boolean and when true use the regular Cura retract settings.
+#    Use the regular Cura settings for Travel Speed and Speed_Z instead of asking.
+#    Added code to check the E location to prevent retracts if the filament was already retracted.
+#    Added 'Pause before image' per LemanRus
 
 from ..Script import Script
-
+from UM.Application import Application
+from UM.Logger import Logger
 
 class TimeLapse(Script):
     def __init__(self):
@@ -11,7 +17,7 @@ class TimeLapse(Script):
 
     def getSettingDataString(self):
         return """{
-            "name": "Time Lapse",
+            "name": "Time Lapse Camera",
             "key": "TimeLapse",
             "metadata": {},
             "version": 2,
@@ -19,24 +25,49 @@ class TimeLapse(Script):
             {
                 "trigger_command":
                 {
-                    "label": "Trigger camera command",
-                    "description": "G-code command used to trigger camera.",
+                    "label": "Camera Trigger Command",
+                    "description": "G-code command used to trigger the camera.  The setting box will take any command and parameters.",
                     "type": "str",
                     "default_value": "M240"
                 },
+                "insert_frequency":
+                {
+                    "label": "How often (layers)",
+                    "description": "Every so many layers (always starts at the first layer whether it's the model or a raft).",
+                    "type": "enum",
+                    "options": {
+                        "every_layer": "Every Layer",
+                        "every_2nd": "Every 2nd",
+                        "every_3rd": "Every 3rd",
+                        "every_5th": "Every 5th",
+                        "every_10th": "Every 10th",
+                        "every_25th": "Every 25th",
+                        "every_50th": "Every 50th",
+                        "every_100th": "Every 100th"},
+                    "default_value": "every_layer"
+                },
+                "anti_shake_length":
+                {
+                    "label": "Pause before image",
+                    "description": "How long to wait (in ms) before capturing the image.  This is to allow the printer to 'settle down' after movement.  To disable set this to '0'.",
+                    "type": "int",
+                    "default_value": 0,
+                    "minimum_value": 0,
+                    "unit": "ms"
+                },
                 "pause_length":
                 {
-                    "label": "Pause length",
+                    "label": "Pause after image",
                     "description": "How long to wait (in ms) after camera was triggered.",
                     "type": "int",
-                    "default_value": 700,
+                    "default_value": 500,
                     "minimum_value": 0,
                     "unit": "ms"
                 },
                 "park_print_head":
                 {
                     "label": "Park Print Head",
-                    "description": "Park the print head out of the way. Assumes absolute positioning.",
+                    "description": "Park the print head out of the way.",
                     "type": "bool",
                     "default_value": true
                 },
@@ -55,90 +86,166 @@ class TimeLapse(Script):
                     "description": "What Y location does the head move to for photo.",
                     "unit": "mm",
                     "type": "float",
-                    "default_value": 190,
-                    "enabled": "park_print_head"
-                },
-                "park_feed_rate":
-                {
-                    "label": "Park Feed Rate",
-                    "description": "How fast does the head move to the park coordinates.",
-                    "unit": "mm/s",
-                    "type": "float",
-                    "default_value": 9000,
+                    "default_value": 0,
                     "enabled": "park_print_head"
                 },
                 "retract":
                 {
-                    "label": "Retraction Distance",
-                    "description": "Filament retraction distance for camera trigger.",
-                    "unit": "mm",
-                    "type": "int",
-                    "default_value": 0
+                    "label": "Retract when required",
+                    "description": "Retract if there isn't already a retraction.  If unchecked then there will be no retraction even if there is none in the gcode.  If retractions are not enabled in Cura there won't be a retraction. regardless of this setting.",
+                    "type": "bool",
+                    "default_value": true
                 },
                 "zhop":
                 {
                     "label": "Z-Hop Height When Parking",
-                    "description": "Z-hop length before parking",
+                    "description": "The height to lift the nozzle off the print before parking.",
                     "unit": "mm",
                     "type": "float",
-                    "default_value": 0
+                    "default_value": 2.0,
+                    "minimum_value": 0.0
+                },
+                "ensure_final_image":
+                {
+                    "label": "Ensure Final Image",
+                    "description": "Depending on how the layer numbers work out with the 'How Often' frequency there might not be an image taken at the end of the last layer.  This will ensure that one is taken.  There is no parking as the Ending Gcode comes right up.",
+                    "type": "bool",
+                    "default_value": false
                 }
             }
         }"""
 
     def execute(self, data):
-        feed_rate = self.getSettingValueByKey("park_feed_rate")
+        mycura = Application.getInstance().getGlobalContainerStack()
+        relative_extrusion = bool(mycura.getProperty("relative_extrusion", "value"))
+        extruder = mycura.extruderList
+        retract_speed = int(extruder[0].getProperty("retraction_speed", "value"))*60
+        retract_dist = round(float(extruder[0].getProperty("retraction_amount", "value")), 2)
+        retract_enabled = bool(extruder[0].getProperty("retraction_enable", "value"))
+        firmware_retract = bool(mycura.getProperty("machine_firmware_retract", "value"))
+        speed_z = int(extruder[0].getProperty("speed_z_hop", "value"))*60
+        if relative_extrusion:
+            rel_cmd = 83
+        else:
+            rel_cmd = 82
+        travel_speed = int(extruder[0].getProperty("speed_travel", "value"))*60
         park_print_head = self.getSettingValueByKey("park_print_head")
         x_park = self.getSettingValueByKey("head_park_x")
         y_park = self.getSettingValueByKey("head_park_y")
         trigger_command = self.getSettingValueByKey("trigger_command")
         pause_length = self.getSettingValueByKey("pause_length")
-        retract = int(self.getSettingValueByKey("retract"))
+        retract = bool(self.getSettingValueByKey("retract"))
         zhop = self.getSettingValueByKey("zhop")
-        gcode_to_append = ";TimeLapse Begin\n"
+        ensure_final_image = bool(self.getSettingValueByKey("ensure_final_image"))
+        when_to_insert = self.getSettingValueByKey("insert_frequency")
         last_x = 0
         last_y = 0
         last_z = 0
-
+        last_e = 0
+        prev_e = 0
+        is_retracted = False
+        gcode_to_append = ""
         if park_print_head:
-            gcode_to_append += self.putValue(G=1, F=feed_rate,
-                                             X=x_park, Y=y_park) + " ;Park print head\n"
-        gcode_to_append += self.putValue(M=400) + " ;Wait for moves to finish\n"
-        gcode_to_append += trigger_command + " ;Snap Photo\n"
-        gcode_to_append += self.putValue(G=4, P=pause_length) + " ;Wait for camera\n"
-
-        for idx, layer in enumerate(data):
-            for line in layer.split("\n"):
-                if self.getValue(line, "G") in {0, 1}:  # Track X,Y,Z location.
-                    last_x = self.getValue(line, "X", last_x)
-                    last_y = self.getValue(line, "Y", last_y)
-                    last_z = self.getValue(line, "Z", last_z)
-            # Check that a layer is being printed
-            lines = layer.split("\n")
-            for line in lines:
-                if ";LAYER:" in line:
-                    if retract != 0: # Retract the filament so no stringing happens
-                        layer += self.putValue(M=83) + " ;Extrude Relative\n"
-                        layer += self.putValue(G=1, E=-retract, F=3000) + " ;Retract filament\n"
-                        layer += self.putValue(M=82) + " ;Extrude Absolute\n"
-                        layer += self.putValue(M=400) + " ;Wait for moves to finish\n" # Wait to fully retract before hopping
-
-                    if zhop != 0:
-                        layer += self.putValue(G=1, Z=last_z+zhop, F=3000) + " ;Z-Hop\n"
-
-                    layer += gcode_to_append
-
-                    if zhop != 0:
-                        layer += self.putValue(G=0, X=last_x, Y=last_y, Z=last_z) + "; Restore position \n"
-                    else:
-                        layer += self.putValue(G=0, X=last_x, Y=last_y) + "; Restore position \n"
-
-                    if retract != 0:
-                        layer += self.putValue(M=400) + " ;Wait for moves to finish\n"
-                        layer += self.putValue(M=83) + " ;Extrude Relative\n"
-                        layer += self.putValue(G=1, E=retract, F=3000) + " ;Retract filament\n"
-                        layer += self.putValue(M=82) + " ;Extrude Absolute\n"
-
-                    data[idx] = layer
-                    break
+            gcode_to_append += f"G0 F{travel_speed} X{x_park} Y{y_park} ;Park print head\n"
+        gcode_to_append += "M400 ;Wait for moves to finish\n"
+        anti_shake_length = self.getSettingValueByKey("anti_shake_length")
+        if anti_shake_length > 0:
+            gcode_to_append += f"G4 P{anti_shake_length} ;Wait for printer to settle down\n"
+        gcode_to_append += trigger_command + " ;Snap the Image\n"
+        gcode_to_append += f"G4 P{pause_length} ;Wait for camera to finish\n"
+        match when_to_insert:
+            case "every_layer":
+                step_freq = 1
+            case "every_2nd":
+                step_freq = 2
+            case "every_3rd":
+                step_freq = 3
+            case "every_5th":
+                step_freq = 5
+            case "every_10th":
+                step_freq = 10
+            case "every_25th":
+                step_freq = 25
+            case "every_50th":
+                step_freq = 50
+            case "every_100th":
+                step_freq = 100
+            case _:
+                step_freq = 1
+        # Use the step_freq to index through the layers----------------------------------------
+        for num in range(2,len(data)-1,step_freq):
+            layer = data[num]
+            try:
+                # Track X,Y,Z location.--------------------------------------------------------
+                for line in layer.split("\n"):
+                    if self.getValue(line, "G") in {0, 1}:
+                        last_x = self.getValue(line, "X", last_x)
+                        last_y = self.getValue(line, "Y", last_y)
+                        last_z = self.getValue(line, "Z", last_z)
+                #Track the E location so that if there is already a retraction we don't double dip.
+                        if rel_cmd == 82:
+                            if " E" in line:
+                                last_e = line.split("E")[1]
+                                if float(last_e) < float(prev_e):
+                                    is_retracted = True
+                                else:
+                                    is_retracted = False
+                                prev_e = last_e
+                        elif rel_cmd == 83:
+                            if " E" in line:
+                                last_e = line.split("E")[1]
+                                if float(last_e) < 0:
+                                    is_retracted = True
+                                else:
+                                    is_retracted = False
+                                prev_e = last_e
+                    if firmware_retract and self.getValue(line, "G") in {10, 11}:
+                        if self.getValue(line, "G") == 10:
+                            is_retracted = True
+                            last_e = float(prev_e) - float(retract_dist)
+                        if self.getValue(line, "G") == 11:
+                            is_retracted = False
+                            last_e = float(prev_e) + float(retract_dist)
+                        prev_e = last_e
+                lines = layer.split("\n")
+                # Insert the code----------------------------------------------------
+                camera_code = ""
+                for line in lines:
+                    if ";LAYER:" in line:
+                        if retract and not is_retracted and retract_enabled: # Retract unless already retracted
+                            camera_code += ";TYPE:CUSTOM-----------------TimeLapse Begin\n"
+                            camera_code += "M83 ;Extrude Relative\n"
+                            if not firmware_retract:
+                                camera_code += f"G1 F{retract_speed} E-{retract_dist} ;Retract filament\n"
+                            else:
+                                camera_code += "G10 ;Retract filament\n"
+                        else:
+                            camera_code += ";TYPE:CUSTOM-----------------TimeLapse Begin\n"
+                        if zhop != 0:
+                            camera_code += f"G1 F{speed_z} Z{round(last_z + zhop,2)} ;Z-Hop\n"
+                        camera_code += gcode_to_append
+                        camera_code += f"G0 F{travel_speed} X{last_x} Y{last_y} ;Restore XY position\n"
+                        if zhop != 0:
+                            camera_code += f"G0 F{speed_z} Z{last_z} ;Restore Z position\n"
+                        if retract and not is_retracted and retract_enabled:
+                            if not firmware_retract:
+                                camera_code += f"G1 F{retract_speed} E{retract_dist} ;Un-Retract filament\n"
+                            else:
+                                camera_code += "G11 ;Un-Retract filament\n"
+                            camera_code += f"M{rel_cmd} ;Extrude Mode\n"
+                        camera_code += f";{'-' * 28}TimeLapse End"
+                        # Format the camera code to be inserted
+                        temp_lines = camera_code.split("\n")
+                        for temp_index, temp_line in enumerate(temp_lines):
+                            if ";" in temp_line and not temp_line.startswith(";"):
+                                temp_lines[temp_index] = temp_line.replace(temp_line.split(";")[0], temp_line.split(";")[0] + str(" " * (29 - len(temp_line.split(";")[0]))),1)
+                        temp_lines = "\n".join(temp_lines)
+                        lines.insert(len(lines) - 2, temp_lines)
+                        data[num] = "\n".join(lines)
+                        break
+            except Exception as e:
+                Logger.log("w", "TimeLapse Error: " + repr(e))
+        # Take a final image if there was no camera shot at the end of the last layer.
+        if "TimeLapse Begin" not in data[len(data) - (3 if retract_enabled else 2)] and ensure_final_image:
+            data[len(data)-1] = "M400    ; Wait for all moves to finish\n" + trigger_command + "    ;Snap the final Image\n" + f"G4 P{pause_length} ;Wait for camera\n" + data[len(data)-1]
         return data

plugins/UFPWriter/UFPWriter.py

@@ -24,6 +24,7 @@ from UM.Settings.InstanceContainer import InstanceContainer
 from cura.CuraApplication import CuraApplication
 from cura.Settings.GlobalStack import GlobalStack
 from cura.Utils.Threading import call_on_qt_thread
+from cura.API import CuraAPI
 
 from UM.i18n import i18nCatalog
 
@@ -85,7 +86,8 @@ class UFPWriter(MeshWriter):
         try:
             archive.addContentType(extension="json", mime_type="application/json")
             setting_textio = StringIO()
-            json.dump(self._getSliceMetadata(), setting_textio, separators=(", ", ": "), indent=4)
+            api = CuraApplication.getInstance().getCuraAPI()
+            json.dump(api.interface.settings.getSliceMetadata(), setting_textio, separators=(", ", ": "), indent=4)
             steam = archive.getStream(SLICE_METADATA_PATH)
             steam.write(setting_textio.getvalue().encode("UTF-8"))
         except EnvironmentError as e:
@@ -210,57 +212,3 @@ class UFPWriter(MeshWriter):
         return [{"name": item.getName()}
                 for item in DepthFirstIterator(node)
                 if item.getMeshData() is not None and not item.callDecoration("isNonPrintingMesh")]
-
-    def _getSliceMetadata(self) -> Dict[str, Dict[str, Dict[str, str]]]:
-        """Get all changed settings and all settings. For each extruder and the global stack"""
-        print_information = CuraApplication.getInstance().getPrintInformation()
-        machine_manager = CuraApplication.getInstance().getMachineManager()
-        settings = {
-            "material": {
-                "length": print_information.materialLengths,
-                "weight": print_information.materialWeights,
-                "cost": print_information.materialCosts,
-            },
-            "global": {
-                "changes": {},
-                "all_settings": {},
-            },
-            "quality": asdict(machine_manager.activeQualityDisplayNameMap()),
-        }
-
-        def _retrieveValue(container: InstanceContainer, setting_: str):
-            value_ = container.getProperty(setting_, "value")
-            for _ in range(0, 1024):  # Prevent possibly endless loop by not using a limit.
-                if not isinstance(value_, SettingFunction):
-                    return value_  # Success!
-                value_ = value_(container)
-            return 0  # Fallback value after breaking possibly endless loop.
-
-        global_stack = cast(GlobalStack, Application.getInstance().getGlobalContainerStack())
-
-        # Add global user or quality changes
-        global_flattened_changes = InstanceContainer.createMergedInstanceContainer(global_stack.userChanges, global_stack.qualityChanges)
-        for setting in global_flattened_changes.getAllKeys():
-            settings["global"]["changes"][setting] = _retrieveValue(global_flattened_changes, setting)
-
-        # Get global all settings values without user or quality changes
-        for setting in global_stack.getAllKeys():
-            settings["global"]["all_settings"][setting] = _retrieveValue(global_stack, setting)
-
-        for i, extruder in enumerate(global_stack.extruderList):
-            # Add extruder fields to settings dictionary
-            settings[f"extruder_{i}"] = {
-                "changes": {},
-                "all_settings": {},
-            }
-
-            # Add extruder user or quality changes
-            extruder_flattened_changes = InstanceContainer.createMergedInstanceContainer(extruder.userChanges, extruder.qualityChanges)
-            for setting in extruder_flattened_changes.getAllKeys():
-                settings[f"extruder_{i}"]["changes"][setting] = _retrieveValue(extruder_flattened_changes, setting)
-
-            # Get extruder all settings values without user or quality changes
-            for setting in extruder.getAllKeys():
-                settings[f"extruder_{i}"]["all_settings"][setting] = _retrieveValue(extruder, setting)
-
-        return settings

plugins/UM3NetworkPrinting/src/Cloud/CloudApiClient.py

@@ -42,7 +42,7 @@ class CloudApiClient:
     CLUSTER_API_ROOT = f"{ROOT_PATH}/connect/v1"
     CURA_API_ROOT = f"{ROOT_PATH}/cura/v1"
 
-    DEFAULT_REQUEST_TIMEOUT = 10  # seconds
+    DEFAULT_REQUEST_TIMEOUT = 30  # seconds
 
     # In order to avoid garbage collection we keep the callbacks in this list.
     _anti_gc_callbacks = []  # type: List[Callable[[Any], None]]

plugins/VersionUpgrade/VersionUpgrade58to59/VersionUpgrade58to59.py

@@ -0,0 +1,103 @@
+# Copyright (c) 2024 UltiMaker
+# Cura is released under the terms of the LGPLv3 or higher.
+
+import configparser
+from typing import Dict, List, Tuple
+import io
+from UM.VersionUpgrade import VersionUpgrade
+
+# Just to be sure, since in my testing there were both 0.1.0 and 0.2.0 settings about.
+_PLUGIN_NAME = "_plugin__curaenginegradualflow"
+_FROM_PLUGINS_SETTINGS = {
+    "gradual_flow_enabled",
+    "max_flow_acceleration",
+    "layer_0_max_flow_acceleration",
+    "gradual_flow_discretisation_step_size",
+    "reset_flow_duration",
+}  # type: Set[str]
+
+_NEW_SETTING_VERSION = "24"
+
+
+class VersionUpgrade58to59(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"] = _NEW_SETTING_VERSION
+
+        # Fix renamed settings for visibility
+        if "visible_settings" in parser["general"]:
+            all_setting_keys = parser["general"]["visible_settings"].strip().split(";")
+            if all_setting_keys:
+                for idx, key in enumerate(all_setting_keys):
+                    if key.startswith(_PLUGIN_NAME):
+                        all_setting_keys[idx] = key.split("__")[-1]
+                parser["general"]["visible_settings"] = ";".join(all_setting_keys)
+
+        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"] = _NEW_SETTING_VERSION
+
+        # Rename settings.
+        if "values" in parser:
+            for key, value in parser["values"].items():
+                if key.startswith(_PLUGIN_NAME):
+                    parser["values"][key.split("__")[-1]] = parser["values"][key]
+                    del parser["values"][key]
+
+        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["metadata"]["setting_version"] = _NEW_SETTING_VERSION
+
+        result = io.StringIO()
+        parser.write(result)
+        return [filename], [result.getvalue()]

plugins/VersionUpgrade/VersionUpgrade58to59/__init__.py

@@ -0,0 +1,61 @@
+# Copyright (c) 2024 UltiMaker
+# Cura is released under the terms of the LGPLv3 or higher.
+
+from typing import Any, Dict, TYPE_CHECKING
+
+from . import VersionUpgrade58to59
+
+if TYPE_CHECKING:
+    from UM.Application import Application
+
+upgrade = VersionUpgrade58to59.VersionUpgrade58to59()
+
+
+def getMetaData() -> Dict[str, Any]:
+    return {
+        "version_upgrade": {
+            # From                           To                              Upgrade function
+            ("preferences", 7000023):        ("preferences", 7000024,        upgrade.upgradePreferences),
+            ("machine_stack", 6000023):      ("machine_stack", 6000024,      upgrade.upgradeStack),
+            ("extruder_train", 6000023):     ("extruder_train", 6000024,     upgrade.upgradeStack),
+            ("definition_changes", 4000023): ("definition_changes", 4000024, upgrade.upgradeInstanceContainer),
+            ("quality_changes", 4000023):    ("quality_changes", 4000024,    upgrade.upgradeInstanceContainer),
+            ("quality", 4000023):            ("quality", 4000024,            upgrade.upgradeInstanceContainer),
+            ("user", 4000023):               ("user", 4000024,               upgrade.upgradeInstanceContainer),
+            ("intent", 4000023):             ("intent", 4000024,             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/VersionUpgrade58to59/plugin.json

@@ -0,0 +1,8 @@
+{
+    "name": "Version Upgrade 5.8 to 5.9",
+    "author": "UltiMaker",
+    "version": "1.0.0",
+    "description": "Upgrades configurations from Cura 5.8 to Cura 5.9.",
+    "api": 8,
+    "i18n-catalog": "cura"
+}

plugins/XmlMaterialProfile/XmlMaterialProfile.py

@@ -11,12 +11,14 @@ import xml.etree.ElementTree as ET
 from UM.PluginRegistry import PluginRegistry
 from UM.Resources import Resources
 from UM.Logger import Logger
+from UM.Decorators import CachedMemberFunctions
 import UM.Dictionary
 from UM.Settings.InstanceContainer import InstanceContainer
 from UM.Settings.ContainerRegistry import ContainerRegistry
 from UM.ConfigurationErrorMessage import ConfigurationErrorMessage
 
 from cura.CuraApplication import CuraApplication
+from cura.PrinterOutput.FormatMaps import FormatMaps
 from cura.Machines.VariantType import VariantType
 
 try:
@@ -70,6 +72,8 @@ class XmlMaterialProfile(InstanceContainer):
             Logger.log("w", "Can't change metadata {key} of material {material_id} because it's read-only.".format(key = key, material_id = self.getId()))
             return
 
+        CachedMemberFunctions.clearInstanceCache(self)
+
         # Some metadata such as diameter should also be instantiated to be a setting. Go though all values for the
         # "properties" field and apply the new values to SettingInstances as well.
         new_setting_values_dict = {}
@@ -249,7 +253,7 @@ class XmlMaterialProfile(InstanceContainer):
             machine_variant_map[definition_id][variant_name] = variant_dict
 
         # Map machine human-readable names to IDs
-        product_id_map = self.getProductIdMap()
+        product_id_map = FormatMaps.getProductIdMap()
 
         for definition_id, container in machine_container_map.items():
             definition_id = container.getMetaDataEntry("definition")
@@ -479,6 +483,7 @@ class XmlMaterialProfile(InstanceContainer):
                     first.append(element)
 
     def clearData(self):
+        CachedMemberFunctions.clearInstanceCache(self)
         self._metadata = {
             "id": self.getId(),
             "name": ""
@@ -518,6 +523,8 @@ class XmlMaterialProfile(InstanceContainer):
     def deserialize(self, serialized, file_name = None):
         """Overridden from InstanceContainer"""
 
+        CachedMemberFunctions.clearInstanceCache(self)
+
         containers_to_add = []
         # update the serialized data first
         from UM.Settings.Interfaces import ContainerInterface
@@ -647,7 +654,7 @@ class XmlMaterialProfile(InstanceContainer):
         self._dirty = False
 
         # Map machine human-readable names to IDs
-        product_id_map = self.getProductIdMap()
+        product_id_map = FormatMaps.getProductIdMap()
 
         machines = data.iterfind("./um:settings/um:machine", self.__namespaces)
         for machine in machines:
@@ -911,9 +918,6 @@ class XmlMaterialProfile(InstanceContainer):
         base_metadata["properties"] = property_values
         base_metadata["definition"] = "fdmprinter"
 
-        # Certain materials are loaded but should not be visible / selectable to the user.
-        base_metadata["visible"] = not base_metadata.get("abstract_color", False)
-
         compatible_entries = data.iterfind("./um:settings/um:setting[@key='hardware compatible']", cls.__namespaces)
         try:
             common_compatibility = cls._parseCompatibleValue(next(compatible_entries).text) # type: ignore
@@ -923,7 +927,7 @@ class XmlMaterialProfile(InstanceContainer):
         result_metadata.append(base_metadata)
 
         # Map machine human-readable names to IDs
-        product_id_map = cls.getProductIdMap()
+        product_id_map = FormatMaps.getProductIdMap()
 
         for machine in data.iterfind("./um:settings/um:machine", cls.__namespaces):
             machine_compatibility = common_compatibility
@@ -1083,9 +1087,8 @@ class XmlMaterialProfile(InstanceContainer):
             # Skip material properties (eg diameter) or metadata (eg GUID)
             return
 
-        truth_map = { True: "yes", False: "no" }
-        if tag_name != "cura:setting" and instance.value in truth_map:
-            data = truth_map[instance.value]
+        if tag_name != "cura:setting" and isinstance(instance.value, bool):
+            data = "yes" if instance.value else "no"
         else:
             data = str(instance.value)
 
@@ -1128,29 +1131,6 @@ class XmlMaterialProfile(InstanceContainer):
         id_list = list(id_list)
         return id_list
 
-    __product_to_id_map: Optional[Dict[str, List[str]]] = None
-
-    @classmethod
-    def getProductIdMap(cls) -> Dict[str, List[str]]:
-        """Gets a mapping from product names in the XML files to their definition IDs.
-
-        This loads the mapping from a file.
-        """
-        if cls.__product_to_id_map is not None:
-            return cls.__product_to_id_map
-
-        plugin_path = cast(str, PluginRegistry.getInstance().getPluginPath("XmlMaterialProfile"))
-        product_to_id_file = os.path.join(plugin_path, "product_to_id.json")
-        with open(product_to_id_file, encoding = "utf-8") as f:
-            contents = ""
-            for line in f:
-                contents += line if "#" not in line else "".join([line.replace("#", str(n)) for n in range(1, 12)])
-            cls.__product_to_id_map = json.loads(contents)
-        cls.__product_to_id_map = {key: [value] for key, value in cls.__product_to_id_map.items()}
-        #This also loads "Ultimaker S5" -> "ultimaker_s5" even though that is not strictly necessary with the default to change spaces into underscores.
-        #However it is not always loaded with that default; this mapping is also used in serialize() without that default.
-        return cls.__product_to_id_map
-
     @staticmethod
     def _parseCompatibleValue(value: str):
         """Parse the value of the "material compatible" property."""

resources/bundled_packages/cura.json

@@ -1429,6 +1429,23 @@
             }
         }
     },
+    "BASFUltrafuse316L": {
+        "package_info": {
+            "package_id": "BASFUltrafuse316L",
+            "package_type": "material",
+            "display_name": "BASF Ultrafuse 316L",
+            "description": "An innovative filament to produce 316L grade stainless steel parts.",
+            "package_version": "1.0.1",
+            "sdk_version": "8.6.0",
+            "website": "https://forward-am.com/material-portfolio/ultrafuse-filaments-for-fused-filaments-fabrication-fff/metal-filaments/ultrafuse-316l/",
+            "author": {
+                "author_id": "BASF",
+                "display_name": "BASF",
+                "email": null,
+                "website": "https://forward-am.com/"
+            }
+        }
+    },
     "DagomaChromatikPLA": {
         "package_info": {
             "package_id": "DagomaChromatikPLA",
@@ -1582,6 +1599,23 @@
             }
         }
     },
+    "JabilTPE_SEBS1300_95a": {
+        "package_info": {
+            "package_id": "JabilTPE_SEBS1300_95a",
+            "package_type": "material",
+            "display_name": "Jabil TPE SEBS 1300 95a",
+            "description": "Soft material great for prototyping where rubber-like or elastomeric properties and durability are required.",
+            "package_version": "1.0.1",
+            "sdk_version": "8.6.0",
+            "website": "https://www.jabil.com/services/additive-manufacturing/additive-materials/compare-filaments/tpe-sebs-95a.html",
+            "author": {
+                "author_id": "Jabil",
+                "display_name": "Jabil",
+                "email": null,
+                "website": "https://www.jabil.com/"
+            }
+        }
+    },
     "OctofiberPLA": {
         "package_info": {
             "package_id": "OctofiberPLA",
@@ -1616,6 +1650,23 @@
             }
         }
     },
+    "PolyMaxPC": {
+        "package_info": {
+            "package_id": "PolyMaxPC",
+            "package_type": "material",
+            "display_name": "PolyMax™ PC",
+            "description": "PolyMax™ PC is an engineered PC filament combining excellent strength, toughness, heat resistance and printing quality. It is the ideal choice for a wide range of engineering applications.",
+            "package_version": "1.0.1",
+            "sdk_version": "8.6.0",
+            "website": "http://www.polymaker.com/shop/polymax/",
+            "author": {
+                "author_id": "Polymaker",
+                "display_name": "Polymaker L.L.C.",
+                "email": "inquiry@polymaker.com",
+                "website": "https://www.polymaker.com"
+            }
+        }
+    },
     "PolyMaxPLA": {
         "package_info": {
             "package_id": "PolyMaxPLA",
@@ -1933,11 +1984,201 @@
             }
         }
     },
+    "ULTIMAKERABSMETHOD": {
+        "package_info": {
+            "package_id": "ULTIMAKERABSMETHOD",
+            "package_type": "material",
+            "display_name": "ABS",
+            "description": "Example package for material and quality profiles for Ultimaker materials.",
+            "package_version": "2.0.0",
+            "sdk_version": "8.6.0",
+            "website": "https://ultimaker.com/materials/method-series-abs/",
+            "author": {
+                "author_id": "UltimakerPackages",
+                "display_name": "UltiMaker",
+                "email": "materials@ultimaker.com",
+                "website": "https://ultimaker.com",
+                "description": "Professional 3D printing made accessible.",
+                "support_website": "https://ultimaker.com/materials/method-materials/"
+            }
+        }
+    },
+    "ULTIMAKERNYLONMETHOD": {
+        "package_info": {
+            "package_id": "ULTIMAKERNYLONMETHOD",
+            "package_type": "material",
+            "display_name": "Nylon",
+            "description": "Example package for material and quality profiles for Ultimaker materials.",
+            "package_version": "2.0.0",
+            "sdk_version": "8.6.0",
+            "website": "https://ultimaker.com/materials/method-series-nylon/",
+            "author": {
+                "author_id": "UltimakerPackages",
+                "display_name": "UltiMaker",
+                "email": "materials@ultimaker.com",
+                "website": "https://ultimaker.com",
+                "description": "Professional 3D printing made accessible.",
+                "support_website": "https://ultimaker.com/materials/method-materials/"
+            }
+        }
+    },
+    "ULTIMAKERNYLONCFMETHOD": {
+        "package_info": {
+            "package_id": "ULTIMAKERNYLONCFMETHOD",
+            "package_type": "material",
+            "display_name": "Nylon Carbon Fiber",
+            "description": "Example package for material and quality profiles for Ultimaker materials.",
+            "package_version": "2.0.0",
+            "sdk_version": "8.6.0",
+            "website": "https://ultimaker.com/materials/method-series-nylon-carbon-fiber/",
+            "author": {
+                "author_id": "UltimakerPackages",
+                "display_name": "UltiMaker",
+                "email": "materials@ultimaker.com",
+                "website": "https://ultimaker.com",
+                "description": "Professional 3D printing made accessible.",
+                "support_website": "https://ultimaker.com/materials/method-materials/"
+            }
+        }
+    },
+    "ULTIMAKERPLAMETHOD": {
+        "package_info": {
+            "package_id": "ULTIMAKERPLAMETHOD",
+            "package_type": "material",
+            "display_name": "PLA",
+            "description": "Example package for material and quality profiles for Ultimaker materials.",
+            "package_version": "2.0.0",
+            "sdk_version": "8.6.0",
+            "website": "https://ultimaker.com/materials/method-series-pla/",
+            "author": {
+                "author_id": "UltimakerPackages",
+                "display_name": "UltiMaker",
+                "email": "materials@ultimaker.com",
+                "website": "https://ultimaker.com",
+                "description": "Professional 3D printing made accessible.",
+                "support_website": "https://ultimaker.com/materials/method-materials/"
+            }
+        }
+    },
+    "ULTIMAKERPVAMETHOD": {
+        "package_info": {
+            "package_id": "ULTIMAKERPVAMETHOD",
+            "package_type": "material",
+            "display_name": "PVA",
+            "description": "Example package for material and quality profiles for Ultimaker materials.",
+            "package_version": "2.0.0",
+            "sdk_version": "8.6.0",
+            "website": "https://ultimaker.com/materials/method-series-pva/",
+            "author": {
+                "author_id": "UltimakerPackages",
+                "display_name": "UltiMaker",
+                "email": "materials@ultimaker.com",
+                "website": "https://ultimaker.com",
+                "description": "Professional 3D printing made accessible.",
+                "support_website": "https://ultimaker.com/materials/method-materials/"
+            }
+        }
+    },
+    "ULTIMAKERPETGMETHOD": {
+        "package_info": {
+            "package_id": "ULTIMAKERPETGMETHOD",
+            "package_type": "material",
+            "display_name": "PETG",
+            "description": "Example package for material and quality profiles for Ultimaker materials.",
+            "package_version": "2.0.0",
+            "sdk_version": "8.6.0",
+            "website": "https://ultimaker.com/materials/method-series-petg/",
+            "author": {
+                "author_id": "UltimakerPackages",
+                "display_name": "UltiMaker",
+                "email": "materials@ultimaker.com",
+                "website": "https://ultimaker.com",
+                "description": "Professional 3D printing made accessible.",
+                "support_website": "https://ultimaker.com/materials/method-materials/"
+            }
+        }
+    },
+    "ULTIMAKERTOUGHMETHOD": {
+        "package_info": {
+            "package_id": "ULTIMAKERTOUGHMETHOD",
+            "package_type": "material",
+            "display_name": "Tough PLA",
+            "description": "Example package for material and quality profiles for Ultimaker materials.",
+            "package_version": "2.0.0",
+            "sdk_version": "8.6.0",
+            "website": "https://ultimaker.com/materials/method-series-tough/",
+            "author": {
+                "author_id": "UltimakerPackages",
+                "display_name": "UltiMaker",
+                "email": "materials@ultimaker.com",
+                "website": "https://ultimaker.com",
+                "description": "Professional 3D printing made accessible.",
+                "support_website": "https://ultimaker.com/materials/method-materials/"
+            }
+        }
+    },
+    "BASFMETALMETHOD": {
+        "package_info": {
+            "package_id": "BASFMETALMETHOD",
+            "package_type": "material",
+            "display_name": "BASF Ultrafuse 316L",
+            "description": "Example package for material and quality profiles for Ultimaker materials.",
+            "package_version": "2.0.0",
+            "sdk_version": "8.6.0",
+            "website": "https://ultimaker.com/materials/method-materials/#metal",
+            "author": {
+                "author_id": "UltimakerPackages",
+                "display_name": "UltiMaker",
+                "email": "materials@ultimaker.com",
+                "website": "https://ultimaker.com",
+                "description": "Professional 3D printing made accessible.",
+                "support_website": "https://ultimaker.com/materials/method-materials/"
+            }
+        }
+    },
+    "JABILSEBSMETHOD": {
+        "package_info": {
+            "package_id": "JABILSEBSMETHOD",
+            "package_type": "material",
+            "display_name": "Jabil TPE SEBS 95A",
+            "description": "Example package for material and quality profiles for Ultimaker materials.",
+            "package_version": "2.0.0",
+            "sdk_version": "8.6.0",
+            "website": "https://ultimaker.com/materials/method-materials/",
+            "author": {
+                "author_id": "UltimakerPackages",
+                "display_name": "UltiMaker",
+                "email": "materials@ultimaker.com",
+                "website": "https://ultimaker.com",
+                "description": "Professional 3D printing made accessible.",
+                "support_website": "https://ultimaker.com/materials/method-materials/"
+            }
+        }
+    },
+    "POLYMAKERPCMETHOD": {
+        "package_info": {
+            "package_id": "POLYMAKERPCMETHOD",
+            "package_type": "material",
+            "display_name": "Polymaker PolyMax PC",
+            "description": "Example package for material and quality profiles for Ultimaker materials.",
+            "package_version": "2.0.0",
+            "sdk_version": "8.6.0",
+            "website": "https://ultimaker.com/materials/method-materials/",
+            "author": {
+                "author_id": "UltimakerPackages",
+                "display_name": "UltiMaker",
+                "email": "materials@ultimaker.com",
+                "website": "https://ultimaker.com",
+                "description": "Professional 3D printing made accessible.",
+                "support_website": "https://ultimaker.com/materials/method-materials/"
+            }
+        }
+    },
     "ULTIMAKERBASCFMETHOD": {
         "package_info": {
             "package_id": "ULTIMAKERBASCFMETHOD",
             "package_type": "material",
-            "display_name": "Ultimaker ABS-CF",
+            "display_name": "ABS-CF",
             "description": "Example package for material and quality profiles for Ultimaker materials.",
             "package_version": "2.0.0",
             "sdk_version": "8.6.0",
@@ -1956,7 +2197,7 @@
         "package_info": {
             "package_id": "ULTIMAKERABSRMETHOD",
             "package_type": "material",
-            "display_name": "Ultimaker ABS-R",
+            "display_name": "ABS-R",
             "description": "Example package for material and quality profiles for Ultimaker materials.",
             "package_version": "2.0.0",
             "sdk_version": "8.6.0",
@@ -1975,7 +2216,7 @@
         "package_info": {
             "package_id": "ULTIMAKERASAMETHOD",
             "package_type": "material",
-            "display_name": "Ultimaker ASA",
+            "display_name": "ASA",
             "description": "Example package for material and quality profiles for Ultimaker materials.",
             "package_version": "2.0.0",
             "sdk_version": "8.6.0",
@@ -1994,7 +2235,7 @@
         "package_info": {
             "package_id": "ULTIMAKERNYLON12CFMETHOD",
             "package_type": "material",
-            "display_name": "Ultimaker Nylon12 Carbon Fiber",
+            "display_name": "Nylon12 Carbon Fiber",
             "description": "Example package for material and quality profiles for Ultimaker materials.",
             "package_version": "2.0.0",
             "sdk_version": "8.6.0",
@@ -2013,7 +2254,7 @@
         "package_info": {
             "package_id": "ULTIMAKERRAPIDRINSEMETHOD",
             "package_type": "material",
-            "display_name": "Ultimaker RapidRinse",
+            "display_name": "RapidRinse",
             "description": "Example package for material and quality profiles for Ultimaker materials.",
             "package_version": "2.0.0",
             "sdk_version": "8.6.0",
@@ -2032,7 +2273,7 @@
         "package_info": {
             "package_id": "ULTIMAKERSR30METHOD",
             "package_type": "material",
-            "display_name": "Ultimaker SR-30",
+            "display_name": "SR-30",
             "description": "Example package for material and quality profiles for Ultimaker materials.",
             "package_version": "2.0.0",
             "sdk_version": "8.6.0",

resources/conandata.yml

@@ -1 +1 @@
-version: "5.8.0-beta.1"
+version: "5.9.0-alpha.0"

resources/definitions/Mark2_for_Ultimaker2.def.json

@@ -130,7 +130,6 @@
         "machine_min_cool_heat_time_window": { "default_value": 15.0 },
         "machine_name": { "default_value": "Mark2_for_Ultimaker2" },
         "machine_nozzle_cool_down_speed": { "default_value": 1.5 },
-        "machine_nozzle_head_distance": { "default_value": 5 },
         "machine_nozzle_heat_up_speed": { "default_value": 3.5 },
         "machine_nozzle_size": { "default_value": 0.4 },
         "machine_show_variants": { "default_value": true },

resources/definitions/atom3.def.json

@@ -65,7 +65,6 @@
         "machine_heated_bed": { "default_value": true },
         "machine_height": { "default_value": 340 },
         "machine_name": { "default_value": "Atom 3" },
-        "machine_nozzle_head_distance": { "default_value": 6 },
         "machine_shape": { "default_value": "elliptic" },
         "machine_show_variants": { "default_value": true },
         "machine_start_gcode": { "default_value": ";MACHINE START CODE\nG21 ;metric values\nG90 ;absolute positioning\nG28 ;home\nG1 Z5 F9000\n;MACHINE START CODE" },

resources/definitions/creality_crm4.def.json

@@ -0,0 +1,18 @@
+{
+    "version": 2,
+    "name": "Creality CR-M4",
+    "inherits": "creality_base",
+    "metadata":
+    {
+        "visible": true,
+        "quality_definition": "creality_base"
+    },
+    "overrides":
+    {
+        "gantry_height": { "value": 35 },
+        "machine_depth": { "default_value": 450 },
+        "machine_height": { "default_value": 470 },
+        "machine_name": { "default_value": "Creality CR-M4" },
+        "machine_width": { "default_value": 450 }
+    }
+}

resources/definitions/creality_ender3v3se.def.json

@@ -36,9 +36,9 @@
         },
         "machine_heated_bed": { "default_value": true },
         "machine_height": { "default_value": 250 },
-        "machine_max_acceleration_e": { "value": 5000 },
-        "machine_max_acceleration_x": { "value": 5000.0 },
-        "machine_max_acceleration_y": { "value": 5000.0 },
+        "machine_max_acceleration_e": { "value": 2500 },
+        "machine_max_acceleration_x": { "value": 2500.0 },
+        "machine_max_acceleration_y": { "value": 2500.0 },
         "machine_max_acceleration_z": { "value": 500.0 },
         "machine_max_feedrate_e": { "value": 100 },
         "machine_max_feedrate_x": { "value": 500 },

resources/definitions/diy220.def.json

@@ -35,7 +35,6 @@
         "machine_max_feedrate_y": { "default_value": 300 },
         "machine_max_feedrate_z": { "default_value": 40 },
         "machine_name": { "default_value": "Diytech 220" },
-        "machine_nozzle_head_distance": { "default_value": 3 },
         "machine_nozzle_tip_outer_diameter": { "default_value": 1 },
         "machine_start_gcode": { "default_value": "G21\nG90\nM82\nM107\nG28\nG1 Z15 F200\nT0\nG92 E0\nG1 E16 F250\nG92 E0\n" },
         "machine_use_extruder_offset_to_offset_coords": { "default_value": true },

resources/definitions/dxu.def.json

@@ -122,7 +122,6 @@
         "machine_name": { "default_value": "dxu" },
         "machine_nozzle_cool_down_speed": { "default_value": 1.5 },
         "machine_nozzle_expansion_angle": { "default_value": 45 },
-        "machine_nozzle_head_distance": { "default_value": 5 },
         "machine_nozzle_heat_up_speed": { "default_value": 3.5 },
         "machine_nozzle_size": { "default_value": 0.4 },
         "machine_show_variants": { "default_value": true },

resources/definitions/eazao_m500.def.json

@@ -0,0 +1,74 @@
+{
+    "version": 2,
+    "name": "Eazao M500",
+    "inherits": "fdmprinter",
+    "metadata":
+    {
+        "visible": true,
+        "author": "Eazao",
+        "manufacturer": "Eazao",
+        "file_formats": "text/x-gcode",
+        "has_machine_quality": false,
+        "has_materials": false,
+        "machine_extruder_trains": { "0": "eazao_m500_extruder_0" },
+        "preferred_quality_type": "normal"
+    },
+    "overrides":
+    {
+        "acceleration_print": { "value": 300 },
+        "acceleration_travel": { "value": 300 },
+        "adhesion_type": { "default_value": "'none'" },
+        "bottom_layers": { "value": 2 },
+        "cool_fan_enabled": { "value": false },
+        "infill_sparse_density": { "value": 0 },
+        "initial_bottom_layers": { "value": 2 },
+        "jerk_print": { "value": 10 },
+        "jerk_travel": { "value": "jerk_print" },
+        "jerk_travel_layer_0": { "value": "jerk_travel" },
+        "layer_height": { "value": 1.0 },
+        "layer_height_0": { "value": 1.0 },
+        "line_width": { "value": 3.0 },
+        "machine_acceleration": { "value": 300 },
+        "machine_center_is_zero": { "default_value": false },
+        "machine_depth": { "default_value": 320 },
+        "machine_end_gcode": { "default_value": "G92 Z0\nG1 F1500 Z10\nG28 X0 Y300 ;move X Y to min endstops\nM82\nM84 ;steppers off\n" },
+        "machine_gcode_flavor": { "default_value": "RepRap (Marlin/Sprinter)" },
+        "machine_heated_bed": { "default_value": false },
+        "machine_height": { "default_value": 520 },
+        "machine_max_acceleration_e": { "value": 500 },
+        "machine_max_acceleration_x": { "value": 500 },
+        "machine_max_acceleration_y": { "value": 500 },
+        "machine_max_acceleration_z": { "value": 50 },
+        "machine_max_feedrate_e": { "value": 25 },
+        "machine_max_feedrate_x": { "value": 100 },
+        "machine_max_feedrate_y": { "value": 100 },
+        "machine_max_feedrate_z": { "value": 5 },
+        "machine_max_jerk_e": { "value": 5 },
+        "machine_max_jerk_xy": { "value": 10 },
+        "machine_max_jerk_z": { "value": 0.3 },
+        "machine_name": { "default_value": "Eazao M500" },
+        "machine_start_gcode": { "default_value": "G21 ;set units to millimeters\nG90 ;absolute positioning\nM82 ;set extruder to absolute mode\nG28 ;Home\nG1 Z25.0 F1500 ;move the platform down 15mm\nG92 E0 ;extruder reset\nG1 F300 E5\nG92 E0 ;The extruder is forced to zero again\nM302\nM163 S0 P0.85; Set Mix Factor\nM163 S1 P0.15; Set Mix Factor\nM164 S0" },
+        "machine_width": { "default_value": 320 },
+        "magic_spiralize": { "value": true },
+        "material_final_print_temperature": { "value": "0" },
+        "material_initial_print_temperature": { "value": "0" },
+        "material_print_temperature": { "value": "0" },
+        "material_print_temperature_layer_0": { "value": "0" },
+        "optimize_wall_printing_order": { "value": "True" },
+        "retraction_amount": { "value": 7 },
+        "retraction_combing": { "value": "'noskin'" },
+        "retraction_count_max": { "value": 100 },
+        "retraction_enable": { "value": false },
+        "retraction_extrusion_window": { "value": 10 },
+        "retraction_hop": { "value": 0.2 },
+        "speed_print": { "value": 20.0 },
+        "speed_travel": { "value": 20.0 },
+        "speed_wall": { "value": 20.0 },
+        "speed_wall_0": { "value": 20.0 },
+        "speed_wall_x": { "value": 20.0 },
+        "speed_z_hop": { "value": "machine_max_feedrate_z" },
+        "top_bottom_pattern": { "value": "concentric" },
+        "top_bottom_thickness": { "value": 3 },
+        "wall_thickness": { "value": 5.0 }
+    }
+}

resources/definitions/eazao_m600.def.json

@@ -0,0 +1,74 @@
+{
+    "version": 2,
+    "name": "Eazao M600",
+    "inherits": "fdmprinter",
+    "metadata":
+    {
+        "visible": true,
+        "author": "Eazao",
+        "manufacturer": "Eazao",
+        "file_formats": "text/x-gcode",
+        "has_machine_quality": false,
+        "has_materials": false,
+        "machine_extruder_trains": { "0": "eazao_m600_extruder_0" },
+        "preferred_quality_type": "normal"
+    },
+    "overrides":
+    {
+        "acceleration_print": { "value": 300 },
+        "acceleration_travel": { "value": 300 },
+        "adhesion_type": { "default_value": "'none'" },
+        "bottom_layers": { "value": 2 },
+        "cool_fan_enabled": { "value": false },
+        "infill_sparse_density": { "value": 0 },
+        "initial_bottom_layers": { "value": 2 },
+        "jerk_print": { "value": 10 },
+        "jerk_travel": { "value": "jerk_print" },
+        "jerk_travel_layer_0": { "value": "jerk_travel" },
+        "layer_height": { "value": 1.0 },
+        "layer_height_0": { "value": 1.0 },
+        "line_width": { "value": 3.0 },
+        "machine_acceleration": { "value": 300 },
+        "machine_center_is_zero": { "default_value": false },
+        "machine_depth": { "default_value": 420 },
+        "machine_end_gcode": { "default_value": "G92 Z0\nG1 F1500 Z10\nG28 X0 Y400 ;move X Y to min endstops\nM82\nM84 ;steppers off\n" },
+        "machine_gcode_flavor": { "default_value": "RepRap (Marlin/Sprinter)" },
+        "machine_heated_bed": { "default_value": false },
+        "machine_height": { "default_value": 620 },
+        "machine_max_acceleration_e": { "value": 500 },
+        "machine_max_acceleration_x": { "value": 500 },
+        "machine_max_acceleration_y": { "value": 500 },
+        "machine_max_acceleration_z": { "value": 50 },
+        "machine_max_feedrate_e": { "value": 25 },
+        "machine_max_feedrate_x": { "value": 100 },
+        "machine_max_feedrate_y": { "value": 100 },
+        "machine_max_feedrate_z": { "value": 5 },
+        "machine_max_jerk_e": { "value": 5 },
+        "machine_max_jerk_xy": { "value": 10 },
+        "machine_max_jerk_z": { "value": 0.3 },
+        "machine_name": { "default_value": "Eazao M600" },
+        "machine_start_gcode": { "default_value": "G21 ;set units to millimeters\nG90 ;absolute positioning\nM82 ;set extruder to absolute mode\nG28 ;Home\nG1 Z25.0 F1500 ;move the platform down 15mm\nG92 E0 ;extruder reset\nG1 F300 E5\nG92 E0 ;The extruder is forced to zero again\nM302\nM163 S0 P0.87; Set Mix Factor\nM163 S1 P0.13; Set Mix Factor\nM164 S0" },
+        "machine_width": { "default_value": 420 },
+        "magic_spiralize": { "value": true },
+        "material_final_print_temperature": { "value": "0" },
+        "material_initial_print_temperature": { "value": "0" },
+        "material_print_temperature": { "value": "0" },
+        "material_print_temperature_layer_0": { "value": "0" },
+        "optimize_wall_printing_order": { "value": "True" },
+        "retraction_amount": { "value": 7 },
+        "retraction_combing": { "value": "'noskin'" },
+        "retraction_count_max": { "value": 100 },
+        "retraction_enable": { "value": false },
+        "retraction_extrusion_window": { "value": 10 },
+        "retraction_hop": { "value": 0.2 },
+        "speed_print": { "value": 20.0 },
+        "speed_travel": { "value": 20.0 },
+        "speed_wall": { "value": 20.0 },
+        "speed_wall_0": { "value": 20.0 },
+        "speed_wall_x": { "value": 20.0 },
+        "speed_z_hop": { "value": "machine_max_feedrate_z" },
+        "top_bottom_pattern": { "value": "concentric" },
+        "top_bottom_thickness": { "value": 3 },
+        "wall_thickness": { "value": 5.0 }
+    }
+}

resources/definitions/eazao_m700.def.json

@@ -0,0 +1,74 @@
+{
+    "version": 2,
+    "name": "Eazao M700",
+    "inherits": "fdmprinter",
+    "metadata":
+    {
+        "visible": true,
+        "author": "Eazao",
+        "manufacturer": "Eazao",
+        "file_formats": "text/x-gcode",
+        "has_machine_quality": false,
+        "has_materials": false,
+        "machine_extruder_trains": { "0": "eazao_m700_extruder_0" },
+        "preferred_quality_type": "normal"
+    },
+    "overrides":
+    {
+        "acceleration_print": { "value": 300 },
+        "acceleration_travel": { "value": 300 },
+        "adhesion_type": { "default_value": "none" },
+        "bottom_layers": { "value": 2 },
+        "cool_fan_enabled": { "value": false },
+        "infill_sparse_density": { "value": 0 },
+        "initial_bottom_layers": { "value": 2 },
+        "jerk_print": { "value": 10 },
+        "jerk_travel": { "value": "jerk_print" },
+        "jerk_travel_layer_0": { "value": "jerk_travel" },
+        "layer_height": { "value": 1.0 },
+        "layer_height_0": { "value": 1.0 },
+        "line_width": { "value": 3.0 },
+        "machine_acceleration": { "value": 300 },
+        "machine_center_is_zero": { "default_value": false },
+        "machine_depth": { "default_value": 520 },
+        "machine_end_gcode": { "default_value": "G92 Z0\nG1 F1500 Z10\nG28 X0 Y500 ;move X Y to min endstops\nM82\nM84 ;steppers off\n" },
+        "machine_gcode_flavor": { "default_value": "RepRap (Marlin/Sprinter)" },
+        "machine_heated_bed": { "default_value": false },
+        "machine_height": { "default_value": 720 },
+        "machine_max_acceleration_e": { "value": 500 },
+        "machine_max_acceleration_x": { "value": 500 },
+        "machine_max_acceleration_y": { "value": 500 },
+        "machine_max_acceleration_z": { "value": 50 },
+        "machine_max_feedrate_e": { "value": 25 },
+        "machine_max_feedrate_x": { "value": 100 },
+        "machine_max_feedrate_y": { "value": 100 },
+        "machine_max_feedrate_z": { "value": 5 },
+        "machine_max_jerk_e": { "value": 5 },
+        "machine_max_jerk_xy": { "value": 10 },
+        "machine_max_jerk_z": { "value": 0.3 },
+        "machine_name": { "default_value": "Eazao M700" },
+        "machine_start_gcode": { "default_value": "G21 ;set units to millimeters\nG90 ;absolute positioning\nM82 ;set extruder to absolute mode\nG28 ;Home\nG1 Z25.0 F1500 ;move the platform down 15mm\nG92 E0 ;extruder reset\nG1 F300 E5\nG92 E0 ;The extruder is forced to zero again\nM302\nM163 S0 P0.87; Set Mix Factor\nM163 S1 P0.13; Set Mix Factor\nM164 S0" },
+        "machine_width": { "default_value": 520 },
+        "magic_spiralize": { "value": true },
+        "material_final_print_temperature": { "value": "0" },
+        "material_initial_print_temperature": { "value": "0" },
+        "material_print_temperature": { "value": "0" },
+        "material_print_temperature_layer_0": { "value": "0" },
+        "optimize_wall_printing_order": { "value": "True" },
+        "retraction_amount": { "value": 7 },
+        "retraction_combing": { "value": "'noskin'" },
+        "retraction_count_max": { "value": 100 },
+        "retraction_enable": { "value": false },
+        "retraction_extrusion_window": { "value": 10 },
+        "retraction_hop": { "value": 0.2 },
+        "speed_print": { "value": 20.0 },
+        "speed_travel": { "value": 20.0 },
+        "speed_wall": { "value": 20.0 },
+        "speed_wall_0": { "value": 20.0 },
+        "speed_wall_x": { "value": 20.0 },
+        "speed_z_hop": { "value": "machine_max_feedrate_z" },
+        "top_bottom_pattern": { "value": "concentric" },
+        "top_bottom_thickness": { "value": 3 },
+        "wall_thickness": { "value": 5.0 }
+    }
+}

resources/definitions/eazao_potter.def.json

@@ -0,0 +1,74 @@
+{
+    "version": 2,
+    "name": "Eazao Potter",
+    "inherits": "fdmprinter",
+    "metadata":
+    {
+        "visible": true,
+        "author": "Eazao",
+        "manufacturer": "Eazao",
+        "file_formats": "text/x-gcode",
+        "has_machine_quality": false,
+        "has_materials": false,
+        "machine_extruder_trains": { "0": "eazao_potter_extruder_0" },
+        "preferred_quality_type": "normal"
+    },
+    "overrides":
+    {
+        "acceleration_print": { "value": 300 },
+        "acceleration_travel": { "value": 300 },
+        "adhesion_type": { "default_value": "'none'" },
+        "bottom_layers": { "value": 3 },
+        "cool_fan_enabled": { "value": false },
+        "infill_sparse_density": { "value": 0 },
+        "initial_bottom_layers": { "value": 3 },
+        "jerk_print": { "value": 10 },
+        "jerk_travel": { "value": "jerk_print" },
+        "jerk_travel_layer_0": { "value": "jerk_travel" },
+        "layer_height": { "value": 1.0 },
+        "layer_height_0": { "value": 1.0 },
+        "line_width": { "value": 3.0 },
+        "machine_acceleration": { "value": 300 },
+        "machine_center_is_zero": { "default_value": false },
+        "machine_depth": { "default_value": 167 },
+        "machine_end_gcode": { "default_value": "G92 Z0 E0\nG1 F1500 Z10 E-2\nM82\nM84 ;steppers off\n" },
+        "machine_gcode_flavor": { "default_value": "RepRap (Marlin/Sprinter)" },
+        "machine_heated_bed": { "default_value": false },
+        "machine_height": { "default_value": 280 },
+        "machine_max_acceleration_e": { "value": 500 },
+        "machine_max_acceleration_x": { "value": 500 },
+        "machine_max_acceleration_y": { "value": 500 },
+        "machine_max_acceleration_z": { "value": 50 },
+        "machine_max_feedrate_e": { "value": 25 },
+        "machine_max_feedrate_x": { "value": 100 },
+        "machine_max_feedrate_y": { "value": 100 },
+        "machine_max_feedrate_z": { "value": 5 },
+        "machine_max_jerk_e": { "value": 5 },
+        "machine_max_jerk_xy": { "value": 10 },
+        "machine_max_jerk_z": { "value": 0.3 },
+        "machine_name": { "default_value": "Eazao Potter" },
+        "machine_start_gcode": { "default_value": "G21 ;set units to millimeters\nG90 ;absolute positioning\nM82 ;set extruder to absolute mode\nG28 ;Home\nG1 Z25.0 F1500 ;move the platform down 25mm\nG92 E0 ;extruder reset\nG1 F1500 E2\nG92 E0 ;The extruder is forced to zero again\nM302\nM163 S0 P0.85; Set Mix Factor\nM163 S1 P0.15; Set Mix Factor\nM164 S0" },
+        "machine_width": { "default_value": 167 },
+        "magic_spiralize": { "value": true },
+        "material_final_print_temperature": { "value": "0" },
+        "material_initial_print_temperature": { "value": "0" },
+        "material_print_temperature": { "value": "0" },
+        "material_print_temperature_layer_0": { "value": "0" },
+        "optimize_wall_printing_order": { "value": "True" },
+        "retraction_amount": { "value": 7 },
+        "retraction_combing": { "value": "'noskin'" },
+        "retraction_count_max": { "value": 100 },
+        "retraction_enable": { "value": false },
+        "retraction_extrusion_window": { "value": 10 },
+        "retraction_hop": { "value": 0.2 },
+        "speed_print": { "value": 25.0 },
+        "speed_travel": { "value": 25.0 },
+        "speed_wall": { "value": 25.0 },
+        "speed_wall_0": { "value": 25.0 },
+        "speed_wall_x": { "value": 25.0 },
+        "speed_z_hop": { "value": "machine_max_feedrate_z" },
+        "top_bottom_pattern": { "value": "concentric" },
+        "top_bottom_thickness": { "value": 3 },
+        "wall_thickness": { "value": 3.0 }
+    }
+}

resources/definitions/eazao_zero.def.json

@@ -9,9 +9,8 @@
         "manufacturer": "Eazao",
         "file_formats": "text/x-gcode",
         "has_machine_quality": false,
-        "has_materials": true,
+        "has_materials": false,
         "machine_extruder_trains": { "0": "eazao_zero_extruder_0" },
-        "preferred_material": "generic_pla",
         "preferred_quality_type": "normal"
     },
     "overrides":
@@ -20,11 +19,10 @@
         "acceleration_print": { "value": 300 },
         "acceleration_travel": { "value": 300 },
         "adhesion_type": { "default_value": "none" },
-        "bottom_layers": { "value": 2 },
+        "bottom_layers": { "value": 3 },
         "cool_fan_enabled": { "value": false },
         "infill_sparse_density": { "value": 0 },
-        "initial_bottom_layers": { "value": 2 },
-        "jerk_enabled": { "value": false },
+        "initial_bottom_layers": { "value": 3 },
         "jerk_print": { "value": 10 },
         "jerk_travel": { "value": "jerk_print" },
         "jerk_travel_layer_0": { "value": "jerk_travel" },
@@ -34,7 +32,7 @@
         "machine_acceleration": { "value": 300 },
         "machine_center_is_zero": { "default_value": false },
         "machine_depth": { "default_value": 150 },
-        "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_end_gcode": { "default_value": "G92 Z0 E0\nG1 F1500 E-2\nG1 F1500 Z10\nG28 X0;move X Y to min endstops\nM82\nM84 ;steppers off\n" },
         "machine_gcode_flavor": { "default_value": "RepRap (Marlin/Sprinter)" },
         "machine_heated_bed": { "default_value": false },
         "machine_height": { "default_value": 240 },
@@ -49,9 +47,10 @@
         "machine_max_jerk_e": { "value": 5 },
         "machine_max_jerk_xy": { "value": 10 },
         "machine_max_jerk_z": { "value": 0.3 },
-        "machine_name": { "default_value": "EAZAO Zero" },
-        "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_name": { "default_value": "Eazao Zero" },
+        "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 F1500 E2\nG92 E0\nM302\nM163 S0 P0.8; Set Mix Factor\nM163 S1 P0.2; Set Mix Factor\nM164 S0\n" },
         "machine_width": { "default_value": 150 },
+        "magic_spiralize": { "value": true },
         "material_final_print_temperature": { "value": "0" },
         "material_initial_print_temperature": { "value": "0" },
         "material_print_temperature": { "value": "0" },
@@ -64,18 +63,10 @@
         "retraction_enable": { "value": false },
         "retraction_extrusion_window": { "value": 10 },
         "retraction_hop": { "value": 0.2 },
-        "retraction_hop_enabled": { "value": false },
-        "retraction_speed": { "value": 25 },
-        "speed_print": { "value": 20.0 },
-        "speed_travel": { "value": 20.0 },
-        "speed_wall": { "value": 20.0 },
-        "speed_wall_0": { "value": 20.0 },
-        "speed_wall_x": { "value": 20.0 },
+        "speed_print": { "value": 25.0 },
         "speed_z_hop": { "value": "machine_max_feedrate_z" },
-        "top_bottom_thickness": { "value": 0 },
-        "travel_avoid_other_parts": { "value": true },
-        "travel_avoid_supports": { "value": false },
-        "travel_retract_before_outer_wall": { "value": false },
+        "top_bottom_pattern": { "value": "concentric" },
+        "top_bottom_thickness": { "value": 3 },
         "wall_thickness": { "value": 3.0 }
     }
 }

resources/definitions/erzay3d.def.json

@@ -44,7 +44,6 @@
         "machine_max_jerk_xy": { "default_value": 10 },
         "machine_max_jerk_z": { "default_value": 10 },
         "machine_name": { "default_value": "Erzay3D" },
-        "machine_nozzle_head_distance": { "default_value": 2.5 },
         "machine_nozzle_size": { "default_value": 0.4 },
         "machine_shape": { "default_value": "elliptic" },
         "machine_start_gcode": { "default_value": "G28\nG1 Z15.0 F6000\nG92 E0" },

resources/definitions/fdmextruder.def.json

@@ -167,6 +167,17 @@
                     "type": "float",
                     "unit": "mm"
                 },
+                "machine_nozzle_head_distance":
+                {
+                    "default_value": 3,
+                    "description": "The height difference between the tip of the nozzle and the lowest part of the print head.",
+                    "label": "Nozzle Length",
+                    "settable_per_extruder": true,
+                    "settable_per_mesh": false,
+                    "settable_per_meshgroup": false,
+                    "type": "float",
+                    "unit": "mm"
+                },
                 "machine_nozzle_id":
                 {
                     "default_value": "unknown",

resources/definitions/fdmprinter.def.json

@@ -16,7 +16,8 @@
         "preferred_quality_type": "normal",
         "machine_extruder_trains": { "0": "fdmextruder" },
         "supports_usb_connection": true,
-        "supports_network_connection": false
+        "supports_network_connection": false,
+        "supports_abstract_color": false
     },
     "settings":
     {
@@ -28,6 +29,18 @@
             "icon": "Printer",
             "children":
             {
+                "build_volume_fan_nr":
+                {
+                    "label": "Build volume fan number",
+                    "description": "The number of the fan that cools the build volume. If this is set to 0, it's means that there is no build volume fan",
+                    "default_value": 0,
+                    "minimum_value": "0",
+                    "maximum_value": "999999",
+                    "type": "int",
+                    "settable_per_mesh": false,
+                    "settable_per_extruder": false,
+                    "settable_per_meshgroup": false
+                },
                 "machine_name":
                 {
                     "label": "Machine Type",
@@ -289,17 +302,6 @@
                     "settable_per_meshgroup": false,
                     "settable_globally": false
                 },
-                "machine_nozzle_head_distance":
-                {
-                    "label": "Nozzle Length",
-                    "description": "The height difference between the tip of the nozzle and the lowest part of the print head.",
-                    "unit": "mm",
-                    "default_value": 3,
-                    "type": "float",
-                    "settable_per_mesh": false,
-                    "settable_per_extruder": true,
-                    "settable_per_meshgroup": false
-                },
                 "machine_nozzle_expansion_angle":
                 {
                     "label": "Nozzle Angle",
@@ -764,6 +766,15 @@
                     "settable_per_mesh": false,
                     "settable_per_extruder": false,
                     "settable_per_meshgroup": false
+                },
+                "reset_flow_duration":
+                {
+                    "enabled": "gradual_flow_enabled",
+                    "value": 2.0,
+                    "label": "Reset flow duration",
+                    "description": "For any travel move longer than this value, the material flow is reset to the paths target flow",
+                    "unit": "s",
+                    "type": "float"
                 }
             }
         },
@@ -2326,7 +2337,7 @@
                     "label": "Skin Edge Support Thickness",
                     "description": "The thickness of the extra infill that supports skin edges.",
                     "unit": "mm",
-                    "default_value": 0.8,
+                    "default_value": 0,
                     "minimum_value": "0",
                     "maximum_value": "machine_height",
                     "maximum_value_warning": "resolveOrValue('infill_sparse_thickness') * 10",
@@ -2341,7 +2352,7 @@
                         {
                             "label": "Skin Edge Support Layers",
                             "description": "The number of infill layers that supports skin edges.",
-                            "default_value": 4,
+                            "default_value": 0,
                             "minimum_value": "0",
                             "maximum_value_warning": "10",
                             "type": "int",
@@ -2353,6 +2364,21 @@
                         }
                     }
                 },
+                "extra_infill_lines_to_support_skins":
+                {
+                    "label": "Extra Infill Lines To Support Skins",
+                    "description": "Add extra lines into the infill pattern to support skins above.   This option prevents holes or plastic blobs that sometime show in complex shaped skins due to the infill below not correctly supporting the skin layer being printed above.  'Walls' supports just the outlines of the skin, whereas 'Walls and Lines' also supports the ends of the lines that make up the skin.",
+                    "type": "enum",
+                    "options":
+                    {
+                        "walls_and_lines": "Walls and Lines",
+                        "walls": "Walls Only",
+                        "none": "None"
+                    },
+                    "default_value": "walls_and_lines",
+                    "value": "'none' if infill_sparse_density > 50 else 'walls' if skin_edge_support_thickness > 0 else 'walls_and_lines'",
+                    "enabled": "infill_sparse_density > 0 and infill_pattern not in ('lightning', 'concentric', 'cross','cross_3d') and wall_line_count > 0 and top_layers > 0"
+                },
                 "lightning_infill_support_angle":
                 {
                     "label": "Lightning Infill Support Angle",
@@ -3139,6 +3165,60 @@
                     "enabled": false,
                     "settable_per_mesh": false,
                     "settable_per_extruder": true
+                },
+                "gradual_flow_enabled":
+                {
+                    "label": "Gradual flow enabled",
+                    "description": "Enable gradual flow changes. When enabled, the flow is gradually increased/decreased to the target flow. This is useful for printers with a bowden tube where the flow is not immediately changed when the extruder motor starts/stops.",
+                    "type": "bool",
+                    "default_value": false,
+                    "settable_per_mesh": false,
+                    "settable_per_extruder": true
+                },
+                "max_flow_acceleration":
+                {
+                    "enabled": "gradual_flow_enabled",
+                    "label": "Gradual flow max acceleration",
+                    "description": "Maximum acceleration for gradual flow changes",
+                    "type": "float",
+                    "unit": "mm\u00b3/s\u00b2",
+                    "default_value": 1,
+                    "minimum_value_warning": 0.1,
+                    "maximum_value_warning": 99999,
+                    "minimum_value": 0.01,
+                    "settable_per_mesh": false,
+                    "settable_per_extruder": true,
+                    "comments": "when enabled, each second the flow will at max be increased/decreased by this value"
+                },
+                "layer_0_max_flow_acceleration":
+                {
+                    "enabled": "gradual_flow_enabled",
+                    "value": "max_flow_acceleration",
+                    "label": "Initial layer max flow acceleration",
+                    "description": "Minimum speed for gradual flow changes for the first layer",
+                    "type": "float",
+                    "unit": "mm\u00b3/s\u00b2",
+                    "default_value": 1,
+                    "minimum_value_warning": 0.1,
+                    "maximum_value_warning": 99999,
+                    "minimum_value": 0.01,
+                    "settable_per_mesh": false,
+                    "settable_per_extruder": true
+                },
+                "gradual_flow_discretisation_step_size":
+                {
+                    "enabled": "gradual_flow_enabled",
+                    "label": "Gradual flow discretisation step size",
+                    "description": "Duration of each step in the gradual flow change",
+                    "type": "float",
+                    "unit": "s",
+                    "default_value": 0.2,
+                    "maximum_value_warning": 1.0,
+                    "maximum_value": 5.0,
+                    "minimum_value_warning": 0.1,
+                    "minimum_value": 0.01,
+                    "settable_per_mesh": false,
+                    "settable_per_extruder": true
                 }
             }
         },
@@ -4467,6 +4547,37 @@
                     "settable_per_mesh": false,
                     "settable_per_extruder": true
                 },
+                "build_fan_full_at_height":
+                {
+                    "label": "Build Fan Speed at Height",
+                    "description": "The height at which the fans spin on regular fan speed. At the layers below the fan speed gradually increases from Initial Fan Speed to Regular Fan Speed.",
+                    "unit": "mm",
+                    "type": "float",
+                    "default_value": 0,
+                    "minimum_value": "0",
+                    "enabled": "build_volume_fan_nr != 0",
+                    "maximum_value_warning": "10.0",
+                    "settable_per_mesh": false,
+                    "settable_per_extruder": false,
+                    "settable_per_meshgroup": false,
+                    "children":
+                    {
+                        "build_fan_full_layer":
+                        {
+                            "label": "Build Fan Speed at Layer",
+                            "description": "The layer at which the build fans spin on full fan speed. This value is calculated and rounded to a whole number.",
+                            "type": "int",
+                            "default_value": 0,
+                            "minimum_value": "0",
+                            "enabled": "build_volume_fan_nr != 0",
+                            "maximum_value_warning": "10 / resolveOrValue('layer_height')",
+                            "value": "max(1, int(math.floor((build_fan_full_at_height - resolveOrValue('layer_height_0')) / resolveOrValue('layer_height')) + 2))",
+                            "settable_per_mesh": false,
+                            "settable_per_extruder": false,
+                            "settable_per_meshgroup": false
+                        }
+                    }
+                },
                 "cool_fan_speed":
                 {
                     "label": "Fan Speed",
@@ -8813,6 +8924,111 @@
                     "type": "bool",
                     "default_value": true,
                     "settable_per_mesh": true
+                },
+                "scarf_joint_seam_length":
+                {
+                    "label": "Scarf Seam Length",
+                    "description": "When greater than 0, a scarf joint will be created on the Z seam to make it less visible.",
+                    "type": "float",
+                    "default_value": 0,
+                    "minimum_value": "0",
+                    "unit": "mm",
+                    "limit_to_extruder": "wall_0_extruder_nr",
+                    "settable_per_extruder": true,
+                    "settable_per_mesh": true
+                },
+                "scarf_joint_seam_start_height_ratio":
+                {
+                    "label": "Scarf Seam Start Height",
+                    "description": "This is the ratio over the total layer height where the scarf joint seam will start.",
+                    "type": "float",
+                    "default_value": 0,
+                    "minimum_value": 0,
+                    "maximum_value": 100.0,
+                    "unit": "%",
+                    "limit_to_extruder": "wall_0_extruder_nr",
+                    "settable_per_extruder": true,
+                    "settable_per_mesh": true
+                },
+                "scarf_split_distance":
+                {
+                    "label": "Scarf Seam Split Distance",
+                    "description": "This is the maximum length of an extrusion path when splitting a longer path to apply the scarf seam. A smaller distance will create a more precise but also more verbose G-Code.",
+                    "type": "float",
+                    "default_value": 1.0,
+                    "minimum_value": 0.1,
+                    "maximum_value": 100.0,
+                    "unit": "mm",
+                    "limit_to_extruder": "wall_0_extruder_nr",
+                    "settable_per_extruder": true,
+                    "settable_per_mesh": true
+                },
+                "wall_0_start_speed_ratio":
+                {
+                    "label": "Outer Wall Start Speed Ratio",
+                    "description": "This is the ratio of the top speed to start with when printing an outer wall.",
+                    "type": "float",
+                    "default_value": 100.0,
+                    "minimum_value": 0.0,
+                    "maximum_value": 100.0,
+                    "unit": "%",
+                    "limit_to_extruder": "wall_0_extruder_nr",
+                    "settable_per_extruder": true,
+                    "settable_per_mesh": true
+                },
+                "wall_0_acceleration":
+                {
+                    "label": "Outer Wall Acceleration",
+                    "description": "This is the acceleration with which to reach the top speed when printing an outer wall.",
+                    "enabled": "wall_0_start_speed_ratio < 100.0",
+                    "type": "float",
+                    "default_value": 20.0,
+                    "minimum_value": 1.0,
+                    "maximum_value": 1000.0,
+                    "unit": "mm/s\u00b2",
+                    "limit_to_extruder": "wall_0_extruder_nr",
+                    "settable_per_extruder": true,
+                    "settable_per_mesh": true
+                },
+                "wall_0_end_speed_ratio":
+                {
+                    "label": "Outer Wall End Speed Ratio",
+                    "description": "This is the ratio of the top speed to end with when printing an outer wall.",
+                    "type": "float",
+                    "default_value": 100.0,
+                    "minimum_value": 0.0,
+                    "maximum_value": 100.0,
+                    "unit": "%",
+                    "limit_to_extruder": "wall_0_extruder_nr",
+                    "settable_per_extruder": true,
+                    "settable_per_mesh": true
+                },
+                "wall_0_deceleration":
+                {
+                    "label": "Outer Wall Deceleration",
+                    "description": "This is the deceleration with which to end printing an outer wall.",
+                    "enabled": "wall_0_end_speed_ratio < 100.0",
+                    "type": "float",
+                    "default_value": 20.0,
+                    "minimum_value": 1.0,
+                    "maximum_value": 1000.0,
+                    "unit": "mm/s\u00b2",
+                    "limit_to_extruder": "wall_0_extruder_nr",
+                    "settable_per_extruder": true,
+                    "settable_per_mesh": true
+                },
+                "wall_0_speed_split_distance":
+                {
+                    "label": "Outer Wall Speed Split Distance",
+                    "description": "This is the maximum length of an extrusion path when splitting a longer path to apply the outer wall acceleration/deceleration. A smaller distance will create a more precise but also more verbose G-Code.",
+                    "type": "float",
+                    "default_value": 1.0,
+                    "minimum_value": 0.1,
+                    "maximum_value": 100.0,
+                    "unit": "mm",
+                    "limit_to_extruder": "wall_0_extruder_nr",
+                    "settable_per_extruder": true,
+                    "settable_per_mesh": true
                 }
             }
         },

resources/definitions/maker_starter.def.json

@@ -27,7 +27,6 @@
         "machine_heated_bed": { "default_value": false },
         "machine_height": { "default_value": 200 },
         "machine_name": { "default_value": "3DMaker Starter" },
-        "machine_nozzle_head_distance": { "default_value": 3 },
         "machine_nozzle_tip_outer_diameter": { "default_value": 1 },
         "machine_width": { "default_value": 210 },
         "raft_airgap": { "default_value": 0.2 },

resources/definitions/mendel90.def.json

@@ -37,7 +37,6 @@
         "machine_heated_bed": { "default_value": true },
         "machine_height": { "default_value": 200 },
         "machine_name": { "default_value": "Mendel90" },
-        "machine_nozzle_head_distance": { "default_value": 5 },
         "machine_nozzle_tip_outer_diameter": { "default_value": 1 },
         "machine_start_gcode": { "default_value": "G21 ;metric values\nG90 ;absolute positioning\nM82 ;absolute extrusion\nM107 ;start with the fan off\nG28 ;home\nG92 E0 ;zero the extruded length\nM140 S{material_bed_temperature_layer_0} ; set the bed temperature and continue on\nG1 X-50 Y98 F9000 ;go to the left of the top\nG1 Z0.05 ; close to the bed\nM104 S{material_print_temperature_layer_0}; pre-heat the extruder continue on\nM190 S{material_bed_temperature_layer_0} ;set the bed temp & wait\nM109 S{material_print_temperature_layer_0};set the extruder temp for layer 0 & wait\nG92 E0 ;zero the extruded length\nG1 X50 E10 F300 ; make a thick line to prime extruder\nG92 E0 ; reset extruder\nG1 E-4 F1800\nG1 Z0.3 ;lift Z\n" },
         "machine_width": { "default_value": 200 },

resources/definitions/structur3d_discov3ry1_complete_um2plus.def.json

@@ -78,7 +78,6 @@
         "machine_heat_zone_length": { "default_value": 20 },
         "machine_height": { "default_value": 205 },
         "machine_name": { "default_value": "Discov3ry Complete (Ultimaker 2+)" },
-        "machine_nozzle_head_distance": { "default_value": 5 },
         "machine_show_variants": { "default_value": true },
         "machine_start_gcode": { "default_value": "\n;Updated Firmware (.hex and Marlin .ino) for \n;Ultimaker 2+ with Discov3ry Extruder available at: \n;https://github.com/Structur3d/UM2.1Discov3ry-Firmware-beta \n;**Learn more at https://www.structur3d.io** \n \nM104 S{material_print_temperature} ;Start heating extruder  \nM140 S{material_bed_temperature} ;Start heating bed \nG21 ;metric values \nG90 ;absolute positioning \nM82 ;set extruder to absolute mode \nM107 ;start with the fan off \nM302 ;allow cold extrusion \nM92 E2589 ;set extruder EEPROM steps/mm for paste \nG28 Z0 ;move Z to bottom endstops \nG28 X0 Y0 ;move X/Y to endstops \nG1 X15 Y0 F4000 ;move X/Y to front of printer \nG1 Z15.0 F9000 ;move the platform to 15mm \nG92 E0 ;zero the extruded length \nG1 F200 E10 ;extrude 10 mm of feed stock \nG92 E0 ;zero the extruded length again \nG1 F9000 \n;Put printing message on LCD screen \nM117 Printing..." },
         "machine_width": { "default_value": 205 },

resources/definitions/tam.def.json

@@ -44,7 +44,6 @@
         "machine_max_acceleration_y": { "default_value": 6000 },
         "machine_max_acceleration_z": { "default_value": 12000 },
         "machine_name": { "default_value": "TypeAMachines" },
-        "machine_nozzle_head_distance": { "default_value": 3 },
         "machine_nozzle_tip_outer_diameter": { "default_value": 1 },
         "machine_start_gcode": { "default_value": ";-- START GCODE --\n;Sliced for Type A Machines Series 1\n;Sliced at: {day} {date} {time}\n;Basic settings:\n;Layer height: {layer_height}\n;Walls: {wall_thickness}\n;Fill: {fill_distance}\n;Print Speed: {print_speed}\n;Support: {support}\n;Retraction Speed: {retraction_speed}\n;Retraction Distance: {retraction_amount}\n;Print time: {print_time}\n;Filament used: {filament_amount}m {filament_weight}g\n;Settings based on: {material_profile}\nG21 ;metric values\nG90 ;absolute positioning\nG28 ;move to endstops\nG29 ;allows for auto-levelling\nG1 Z15.0 F12000 ;move the platform down 15mm\nG1 X150 Y5 F9000 ;center\nM140 S{material_bed_temperature} ;Prep Heat Bed\nM109 S{default_material_print_temperature} ;Heat To temp\nM190 S{material_bed_temperature} ;Heat Bed to temp\nG1 X150 Y5 Z0.3 ;move the platform to purge extrusion\nG92 E0 ;zero the extruded length\nG1 F200 X250 E30 ;extrude 30mm of feed stock\nG92 E0 ;zero the extruded length again\nG1 X150 Y150  Z25 F12000 ;recenter and begin\nG1 F9000" },
         "machine_use_extruder_offset_to_offset_coords": { "default_value": true },

resources/definitions/ultimaker.def.json

@@ -70,14 +70,12 @@
         "machine_max_feedrate_e": { "default_value": 45 },
         "material_bed_temperature":
         {
-            "maximum_value": "140",
-            "maximum_value_warning": "120",
+            "maximum_value": "120",
             "minimum_value": "0"
         },
         "material_bed_temperature_layer_0":
         {
-            "maximum_value": "140",
-            "maximum_value_warning": "120",
+            "maximum_value": "120",
             "minimum_value": "0"
         },
         "material_print_temp_wait": { "value": false },
@@ -111,7 +109,6 @@
         "roofing_layer_count": { "value": "1" },
         "roofing_material_flow": { "value": "material_flow" },
         "skin_angles": { "value": "[] if infill_pattern not in ['cross', 'cross_3d'] else [20, 110]" },
-        "skin_edge_support_thickness": { "value": "4 * layer_height if infill_sparse_density < 30 else 0" },
         "skin_material_flow": { "value": "0.95 * material_flow" },
         "skin_material_flow_layer_0": { "value": "95" },
         "skin_monotonic": { "value": "roofing_layer_count == 0" },

resources/definitions/ultimaker2.def.json

@@ -95,7 +95,6 @@
         "machine_max_feedrate_y": { "default_value": 300 },
         "machine_max_feedrate_z": { "default_value": 40 },
         "machine_name": { "default_value": "Ultimaker 2" },
-        "machine_nozzle_head_distance": { "default_value": 3 },
         "machine_nozzle_tip_outer_diameter": { "default_value": 1 },
         "machine_start_gcode": { "value": "\"G0 F3000 Y50 ;avoid prime blob\"  if machine_gcode_flavor == \"UltiGCode\" else \"G21 ;metric values\\nG90 ;absolute positioning\\nM82 ;set extruder to absolute mode\\nM107 ;start with the fan off\\nG28 Z0 ;move Z to bottom endstops\\nG28 X0 Y0 ;move X/Y to endstops\\nG1 X15 Y0 F4000 ;move X/Y to front of printer\\nG1 Z15.0 F9000 ;move the platform to 15mm\\nG92 E0 ;zero the extruded length\\nG1 F200 E10 ;extrude 10 mm of feed stock\\nG92 E0 ;zero the extruded length again\\nG1 Y50 F9000\\n;Put printing message on LCD screen\\nM117 Printing...\"" },
         "machine_use_extruder_offset_to_offset_coords": { "default_value": true },

resources/definitions/ultimaker2_plus.def.json

@@ -83,7 +83,6 @@
         "machine_heat_zone_length": { "default_value": 20 },
         "machine_height": { "default_value": 205 },
         "machine_name": { "default_value": "Ultimaker 2+" },
-        "machine_nozzle_head_distance": { "default_value": 5 },
         "machine_show_variants": { "default_value": true },
         "speed_infill": { "value": "speed_print" },
         "speed_support": { "value": "speed_wall_0" },

resources/definitions/ultimaker2_plus_connect.def.json

@@ -92,7 +92,6 @@
         "machine_heat_zone_length": { "default_value": 20 },
         "machine_height": { "default_value": 205 },
         "machine_name": { "default_value": "Ultimaker 2+ Connect" },
-        "machine_nozzle_head_distance": { "default_value": 5 },
         "machine_show_variants": { "default_value": true },
         "machine_start_gcode": { "value": "''" },
         "machine_width": { "default_value": 223 },

resources/definitions/ultimaker_factor4.def.json

@@ -39,6 +39,7 @@
         "preferred_quality_type": "draft",
         "preferred_variant_name": "AA 0.4",
         "supported_actions": [ "DiscoverUM3Action" ],
+        "supports_abstract_color": true,
         "supports_material_export": true,
         "supports_network_connection": true,
         "supports_usb_connection": false,
@@ -112,10 +113,10 @@
         "machine_head_with_fans_polygon":
         {
             "default_value": [
-                [-30, -80],
-                [-30, 20],
-                [50, 20],
-                [50, -80]
+                [-35, -80],
+                [-35, 30],
+                [55, 30],
+                [55, -80]
             ]
         },
         "machine_heated_bed": { "default_value": true },

resources/definitions/ultimaker_method.def.json

@@ -23,19 +23,7 @@
             "fabtotum_",
             "fdplast_",
             "filo3d_",
-            "generic_asa_175",
-            "generic_abs_175",
-            "generic_bvoh_175",
-            "generic_petg_175",
-            "generic_pla_175",
-            "generic_tough_pla_175",
-            "generic_pva_175",
-            "generic_cffpa_175",
-            "generic_cpe_175",
-            "generic_nylon_175",
-            "generic_hips_175",
-            "generic_pc_175",
-            "generic_tpu_175",
+            "generic_",
             "goofoo_",
             "ideagen3D_",
             "imade3d_",
@@ -44,6 +32,7 @@
             "leapfrog_",
             "polyflex_pla",
             "polymax_pla",
+            "polymaker_polymax_pc_175",
             "polyplus_pla",
             "polywood_pla",
             "redd_",
@@ -53,23 +42,22 @@
             "ultimaker_absr_175",
             "ultimaker_abscf_175",
             "ultimaker_bvoh_175",
-            "ultimaker_petg_175",
             "ultimaker_cffpa_175",
             "ultimaker_cpe_175",
-            "ultimaker_nylon_175",
             "ultimaker_hips_175",
             "ultimaker_pc_175",
             "ultimaker_tpu_175",
-            "ultimaker_tough_pla_175",
             "ultimaker_rapidrinse_175",
             "ultimaker_sr30",
+            "ultimaker_metallic_pla_175",
             "verbatim_",
             "Vertex_",
             "volumic_",
             "xyzprinting_",
             "zyyx_pro_",
             "octofiber_",
-            "fiberlogy_"
+            "fiberlogy_",
+            "ultimaker_metallic_pla_175"
         ],
         "has_machine_materials": true,
         "has_machine_quality": true,
@@ -98,39 +86,7 @@
     "overrides":
     {
         "build_volume_temperature": { "maximum_value": "67" },
-        "machine_depth": { "default_value": 236.48 },
-        "machine_disallowed_areas":
-        {
-            "default_value": [
-                [
-                    [-141.65, -118.11],
-                    [141.65, -118.11],
-                    [141.65, -94],
-                    [-141.65, -94]
-                ],
-                [
-                    [-141.65, 118.37],
-                    [141.65, 118.37],
-                    [141.65, 94],
-                    [-141.65, 94]
-                ],
-                [
-                    [-141.65, -118.11],
-                    [-75, -118.11],
-                    [-75, 118.37],
-                    [-141.65, 118.37]
-                ],
-                [
-                    [75, -118.11],
-                    [141.65, -118.11],
-                    [141.65, 118.37],
-                    [75, 118.37]
-                ]
-            ]
-        },
-        "machine_height": { "default_value": 196 },
         "machine_name": { "default_value": "UltiMaker Method" },
-        "machine_width": { "default_value": 283.3 },
         "prime_tower_position_x": { "value": "(150 / 2 + resolveOrValue('prime_tower_size') / 2) if resolveOrValue('machine_shape') == 'elliptic' else (150 - (resolveOrValue('prime_tower_base_size') if (resolveOrValue('adhesion_type') == 'raft' or resolveOrValue('prime_tower_brim_enable')) else 0) - max(max(extruderValues('travel_avoid_distance')) + max(extruderValues('support_offset')) + (extruderValue(skirt_brim_extruder_nr, 'skirt_brim_line_width') * extruderValue(skirt_brim_extruder_nr, 'skirt_line_count') * extruderValue(skirt_brim_extruder_nr, 'initial_layer_line_width_factor') / 100 + extruderValue(skirt_brim_extruder_nr, 'skirt_gap') if resolveOrValue('adhesion_type') == 'skirt' else 0) + (resolveOrValue('draft_shield_dist') if resolveOrValue('draft_shield_enabled') else 0), max(map(abs, extruderValues('machine_nozzle_offset_x'))), 1)) - (150 / 2 if resolveOrValue('machine_center_is_zero') else 0)" },
         "prime_tower_position_y": { "value": "190 - prime_tower_size - (resolveOrValue('prime_tower_base_size') if (resolveOrValue('adhesion_type') == 'raft' or resolveOrValue('prime_tower_brim_enable')) else 0) - max(max(extruderValues('travel_avoid_distance')) + max(extruderValues('support_offset')) + (extruderValue(skirt_brim_extruder_nr, 'skirt_brim_line_width') * extruderValue(skirt_brim_extruder_nr, 'skirt_line_count') * extruderValue(skirt_brim_extruder_nr, 'initial_layer_line_width_factor') / 100 + extruderValue(skirt_brim_extruder_nr, 'skirt_gap') if resolveOrValue('adhesion_type') == 'skirt' else 0) + (resolveOrValue('draft_shield_dist') if resolveOrValue('draft_shield_enabled') else 0), max(map(abs, extruderValues('machine_nozzle_offset_y'))), 1) - (190 / 2 if resolveOrValue('machine_center_is_zero') else 0)" }
     }

resources/definitions/ultimaker_method_base.def.json

@@ -9,42 +9,7 @@
         "manufacturer": "Ultimaker B.V.",
         "file_formats": "application/x-makerbot",
         "platform": "ultimaker_method_platform.stl",
-        "exclude_materials": [
-            "dsm_",
-            "Essentium_",
-            "imade3d_",
-            "chromatik_",
-            "3D-Fuel_",
-            "bestfilament_",
-            "emotiontech_",
-            "eryone_",
-            "eSUN_",
-            "Extrudr_",
-            "fabtotum_",
-            "fdplast_",
-            "filo3d_",
-            "generic_",
-            "ultimaker_rapidrinse_175",
-            "goofoo_",
-            "ideagen3D_",
-            "imade3d_",
-            "innofill_",
-            "layer_one_",
-            "leapfrog_",
-            "polyflex_pla",
-            "polymax_pla",
-            "polyplus_pla",
-            "polywood_pla",
-            "redd_",
-            "tizyx_",
-            "verbatim_",
-            "Vertex_",
-            "volumic_",
-            "xyzprinting_",
-            "zyyx_pro_",
-            "octofiber_",
-            "fiberlogy_"
-        ],
+        "exclude_materials": [],
         "has_machine_materials": true,
         "has_machine_quality": true,
         "has_materials": true,
@@ -170,13 +135,15 @@
             "enabled": false,
             "value": "acceleration_print"
         },
-        "adhesion_extruder_nr": { "value": 0 },
+        "adhesion_extruder_nr":
+        {
+            "enabled": false,
+            "value": "min(extruderValues('extruder_nr'))"
+        },
         "adhesion_type": { "value": "'raft'" },
+        "bottom_thickness": { "value": "top_bottom_thickness" },
         "bridge_enable_more_layers": { "value": true },
-        "bridge_fan_speed": { "value": "cool_fan_speed_max" },
         "bridge_fan_speed_2": { "value": "(cool_fan_speed_max + cool_fan_speed_min) / 2" },
-        "bridge_fan_speed_3": { "value": "cool_fan_speed_min" },
-        "bridge_settings_enabled": { "value": true },
         "bridge_skin_density": { "value": 100 },
         "bridge_skin_density_2": { "value": 100 },
         "bridge_skin_density_3": { "value": 100 },
@@ -195,14 +162,38 @@
         {
             "force_depends_on_settings": [ "support_extruder_nr" ]
         },
+        "cool_fan_full_at_height": { "value": "1 if resolveOrValue('adhesion_type') == 'raft' else layer_height + layer_height_0" },
+        "cool_fan_full_layer": { "value": "1 if resolveOrValue('adhesion_type') == 'raft' else 3" },
         "default_material_bed_temperature": { "resolve": "min(extruderValues('default_material_bed_temperature'))" },
         "extruder_prime_pos_abs": { "default_value": true },
         "gradual_support_infill_steps": { "value": 0 },
+        "group_outer_walls": { "value": false },
+        "infill_angles":
+        {
+            "value": [
+                45,
+                45,
+                45,
+                45,
+                45,
+                135,
+                135,
+                135,
+                135,
+                135
+            ]
+        },
         "infill_before_walls": { "value": false },
         "infill_material_flow": { "value": "material_flow" },
         "infill_overlap": { "value": 0 },
-        "infill_pattern": { "value": "'grid' if infill_sparse_density < 80 else 'lines'" },
+        "infill_pattern": { "value": "'zigzag'" },
         "infill_wipe_dist": { "value": 0 },
+        "initial_layer_line_width_factor":
+        {
+            "maximum_value": 350,
+            "maximum_value_warning": 320,
+            "value": "100 if resolveOrValue('adhesion_type') == 'raft' else 200"
+        },
         "inset_direction": { "value": "'inside_out'" },
         "jerk_enabled":
         {
@@ -309,22 +300,37 @@
             "enabled": false,
             "value": "jerk_print"
         },
+        "layer_height_0": { "value": "layer_height if resolveOrValue('adhesion_type') == 'raft' else layer_height * 1.25" },
         "machine_acceleration": { "default_value": 3000 },
         "machine_center_is_zero": { "value": true },
+        "machine_depth": { "default_value": 236.48 },
+        "machine_disallowed_areas": { "value": "[ [ [-141.65, -118.11], [141.65, -118.11], [141.65, -95.205], [-141.65, -95.205] ], [ [-141.65, 118.37], [141.65, 118.37], [141.65, 95.205], [-141.65, 95.205] ], [ [-141.65, -118.11], [-114.249, -118.11], [-114.249, 118.37], [-141.65, 118.37] ], [ [76.149, -118.11], [141.65, -118.11], [141.65, 118.37], [76.149, 118.37] ] ] if max(extruderValues('extruder_nr')) == 0 else [ [ [-141.65, -118.11], [141.65, -118.11], [141.65, -95.205], [-141.65, -95.205] ], [ [-141.65, 118.37], [141.65, 118.37], [141.65, 95.205], [-141.65, 95.205] ], [ [-141.65, -118.11], [-76.149, -118.11], [-76.149, 118.37], [-141.65, 118.37] ], [ [76.149, -118.11], [141.65, -118.11], [141.65, 118.37], [76.149, 118.37] ] ]" },
         "machine_end_gcode": { "default_value": "" },
         "machine_extruder_count": { "default_value": 2 },
         "machine_gcode_flavor": { "default_value": "Griffin" },
         "machine_heated_bed": { "default_value": false },
         "machine_heated_build_volume": { "default_value": true },
+        "machine_height": { "default_value": 196.749 },
         "machine_min_cool_heat_time_window": { "value": 15 },
         "machine_name": { "default_value": "UltiMaker Method" },
         "machine_nozzle_cool_down_speed": { "value": 0.8 },
         "machine_nozzle_heat_up_speed": { "value": 3.5 },
         "machine_scale_fan_speed_zero_to_one": { "value": true },
         "machine_start_gcode": { "default_value": "G0 Z20" },
+        "machine_width": { "default_value": 283.3 },
         "material_bed_temperature": { "enabled": "machine_heated_bed" },
+        "material_final_print_temperature":
+        {
+            "maximum_value": "material_print_temperature",
+            "minimum_value": "material_standby_temperature"
+        },
         "material_flow": { "value": 100 },
-        "material_initial_print_temperature": { "value": "material_print_temperature-10" },
+        "material_initial_print_temperature":
+        {
+            "maximum_value": "material_print_temperature",
+            "minimum_value": "material_standby_temperature",
+            "value": "material_print_temperature-5"
+        },
         "material_print_temperature":
         {
             "force_depends_on_settings": [ "support_extruder_nr" ]
@@ -336,20 +342,34 @@
         "multiple_mesh_overlap": { "value": 0 },
         "optimize_wall_printing_order": { "value": true },
         "prime_blob_enable": { "enabled": false },
-        "prime_tower_base_curve_magnitude": { "value": 2 },
-        "prime_tower_base_height": { "value": 6 },
-        "prime_tower_base_size": { "value": 10 },
-        "prime_tower_enable": { "value": false },
         "prime_tower_flow": { "value": "material_flow" },
-        "prime_tower_line_width": { "value": 1 },
+        "prime_tower_line_width":
+        {
+            "maximum_value": 2,
+            "maximum_value_warning": 1.5,
+            "value": 1
+        },
+        "prime_tower_mode":
+        {
+            "resolve": "'normal'",
+            "value": "'normal'"
+        },
         "prime_tower_raft_base_line_spacing": { "value": "raft_base_line_width" },
         "prime_tower_wipe_enabled": { "value": true },
         "print_sequence": { "enabled": false },
+        "raft_acceleration": { "enabled": false },
         "raft_airgap":
         {
             "force_depends_on_settings": [ "support_extruder_nr" ]
         },
+        "raft_base_acceleration": { "enabled": false },
+        "raft_base_extruder_nr":
+        {
+            "enabled": false,
+            "value": "min(extruderValues('extruder_nr'))"
+        },
         "raft_base_fan_speed": { "value": 0 },
+        "raft_base_jerk": { "enabled": false },
         "raft_base_line_spacing":
         {
             "force_depends_on_settings": [ "raft_interface_extruder_nr" ],
@@ -358,9 +378,10 @@
         "raft_base_line_width":
         {
             "force_depends_on_settings": [ "raft_interface_extruder_nr" ],
+            "maximum_value": 2.5,
+            "maximum_value_warning": 1.8,
             "value": 1.4
         },
-        "raft_base_speed": { "value": 10 },
         "raft_base_thickness":
         {
             "force_depends_on_settings": [
@@ -369,24 +390,24 @@
             ],
             "value": 0.8
         },
-        "raft_base_wall_count":
-        {
-            "force_depends_on_settings": [ "support_extruder_nr" ],
-            "value": "raft_wall_count"
-        },
-        "raft_interface_extruder_nr": { "value": "raft_surface_extruder_nr" },
+        "raft_base_wall_count": { "value": "raft_wall_count" },
+        "raft_interface_acceleration": { "enabled": false },
+        "raft_interface_extruder_nr": { "value": "max(extruderValues('extruder_nr'))" },
         "raft_interface_fan_speed": { "value": 0 },
         "raft_interface_infill_overlap":
         {
             "force_depends_on_settings": [ "raft_interface_extruder_nr" ]
         },
+        "raft_interface_infill_overlap_mm": { "maximum_value_warning": "2 * machine_nozzle_size" },
+        "raft_interface_jerk": { "enabled": false },
         "raft_interface_layers": { "value": 2 },
         "raft_interface_line_spacing":
         {
             "force_depends_on_settings": [
                 "raft_base_thickness",
                 "raft_interface_extruder_nr"
-            ]
+            ],
+            "minimum_value_warning": "raft_interface_line_width * 0.8"
         },
         "raft_interface_line_width":
         {
@@ -396,7 +417,11 @@
             ],
             "value": 0.7
         },
-        "raft_interface_speed": { "value": 90 },
+        "raft_interface_speed":
+        {
+            "force_depends_on_settings": [ "support_extruder_nr" ],
+            "value": "raft_speed * 5"
+        },
         "raft_interface_thickness": { "value": 0.3 },
         "raft_interface_wall_count": { "value": "raft_wall_count" },
         "raft_interface_z_offset":
@@ -406,14 +431,18 @@
                 "raft_interface_extruder_nr"
             ]
         },
+        "raft_jerk": { "enabled": false },
         "raft_margin": { "value": 1.2 },
         "raft_smoothing": { "value": 9.5 },
-        "raft_surface_extruder_nr": { "value": "int(anyExtruderWithMaterial('material_is_support_material')) if support_enable and extruderValue(support_extruder_nr,'material_is_support_material') else raft_base_extruder_nr" },
+        "raft_speed": { "value": 10 },
+        "raft_surface_acceleration": { "enabled": false },
+        "raft_surface_extruder_nr": { "value": "max(extruderValues('extruder_nr'))" },
         "raft_surface_fan_speed": { "value": 0 },
         "raft_surface_flow":
         {
             "force_depends_on_settings": [ "support_extruder_nr" ]
         },
+        "raft_surface_jerk": { "enabled": false },
         "raft_surface_speed":
         {
             "force_depends_on_settings": [ "support_extruder_nr" ]
@@ -430,27 +459,55 @@
         "raft_wall_count": { "value": 2 },
         "retract_at_layer_change": { "value": true },
         "retraction_amount": { "value": 0.75 },
-        "retraction_combing": { "value": "'off'" },
+        "retraction_combing":
+        {
+            "enabled": false,
+            "value": "'off'"
+        },
         "retraction_combing_max_distance": { "value": "speed_travel / 10" },
         "retraction_count_max": { "value": 100 },
         "retraction_extrusion_window": { "value": 0 },
         "retraction_hop": { "value": 0.4 },
         "retraction_hop_enabled": { "value": true },
         "retraction_hop_only_when_collides": { "value": false },
-        "retraction_min_travel": { "value": "0.6" },
+        "retraction_min_travel":
+        {
+            "minimum_value_warning": "line_width * 1.25",
+            "value": 0.6
+        },
         "retraction_prime_speed": { "value": "retraction_speed" },
         "retraction_speed": { "value": 5 },
-        "roofing_layer_count": { "value": 2 },
-        "roofing_material_flow": { "value": "material_flow" },
-        "roofing_monotonic": { "value": true },
+        "roofing_angles":
+        {
+            "value": [45, 135]
+        },
+        "roofing_layer_count":
+        {
+            "maximum_value_warning": 10,
+            "minimum_value": 0,
+            "minimum_value_warning": 1,
+            "value": 2
+        },
+        "skin_angles":
+        {
+            "value": [0, 90]
+        },
         "skin_material_flow": { "value": "material_flow" },
         "skin_material_flow_layer_0": { "value": "material_flow" },
         "skin_monotonic": { "value": true },
         "skin_outline_count": { "value": 0 },
         "skin_overlap": { "value": 0 },
         "skin_preshrink": { "value": 0 },
+        "skirt_brim_extruder_nr":
+        {
+            "enabled": false,
+            "value": "min(extruderValues('extruder_nr'))"
+        },
+        "skirt_brim_line_width": { "value": 1 },
         "skirt_brim_material_flow": { "value": "material_flow" },
         "skirt_brim_minimal_length": { "value": 500 },
+        "skirt_gap": { "value": 2 },
+        "skirt_height": { "value": 3 },
         "small_skin_width": { "value": 4 },
         "speed_equalize_flow_width_factor": { "value": 0 },
         "speed_prime_tower": { "value": "speed_topbottom" },
@@ -465,34 +522,58 @@
         "speed_wall_x": { "value": "speed_wall" },
         "support_angle": { "value": 40 },
         "support_bottom_height": { "value": "2*support_infill_sparse_thickness" },
+        "support_bottom_line_width":
+        {
+            "maximum_value": 3,
+            "maximum_value_warning": 1.8
+        },
         "support_bottom_material_flow": { "value": "material_flow" },
-        "support_bottom_wall_count": { "value": "0" },
+        "support_bottom_wall_count":
+        {
+            "maximum_value": 8,
+            "maximum_value_warning": 6,
+            "value": 0
+        },
         "support_brim_enable": { "value": false },
         "support_conical_min_width": { "value": 10 },
         "support_enable": { "value": true },
         "support_extruder_nr": { "value": "int(anyExtruderWithMaterial('material_is_support_material'))" },
         "support_fan_enable": { "value": "True" },
+        "support_infill_angles":
+        {
+            "value": [
+                45
+            ]
+        },
         "support_infill_rate": { "value": 20.0 },
         "support_infill_sparse_thickness": { "value": "layer_height" },
         "support_interface_enable": { "value": true },
         "support_interface_height": { "value": "4*support_infill_sparse_thickness" },
         "support_interface_material_flow": { "value": "material_flow" },
         "support_interface_offset": { "value": "1" },
-        "support_interface_pattern": { "value": "'lines'" },
+        "support_interface_pattern": { "value": "'zigzag' if support_wall_count > 1 else 'lines'" },
         "support_interface_wall_count": { "value": "1" },
+        "support_join_distance": { "value": "4.5 if support_wall_count > 1 else 2" },
         "support_material_flow": { "value": "material_flow" },
-        "support_offset": { "value": "1.8" },
-        "support_pattern": { "value": "'lines'" },
+        "support_offset": { "value": "2.4 if support_wall_count > 1 else 1.8" },
+        "support_pattern": { "value": "'zigzag' if support_wall_count > 1 else 'lines'" },
         "support_roof_height": { "value": "4*layer_height" },
         "support_roof_material_flow": { "value": "material_flow" },
         "support_supported_skin_fan_speed": { "value": "cool_fan_speed_max" },
-        "support_use_towers": { "value": "False" },
+        "support_use_towers": { "value": false },
         "support_wall_count": { "value": "2 if support_conical_enabled or support_structure == 'tree' else 0" },
         "support_xy_distance": { "value": 0.2 },
         "support_xy_distance_overhang": { "value": "support_xy_distance" },
         "switch_extruder_retraction_amount": { "value": 0.5 },
         "switch_extruder_retraction_speeds": { "value": "retraction_speed" },
-        "top_bottom_thickness": { "value": "5*layer_height" },
+        "top_bottom_pattern": { "value": "'zigzag'" },
+        "top_bottom_pattern_0": { "value": "'zigzag'" },
+        "top_bottom_thickness":
+        {
+            "minimum_value_warning": 0.3,
+            "value": "4*layer_height"
+        },
+        "top_thickness": { "value": "top_bottom_thickness * 1.5" },
         "travel_avoid_distance": { "value": "3 if extruders_enabled_count > 1 else machine_nozzle_tip_outer_diameter / 2 * 1.5" },
         "travel_avoid_other_parts": { "value": false },
         "wall_0_inset": { "value": 0 },

resources/definitions/ultimaker_methodx.def.json

@@ -36,14 +36,15 @@
             "polywood_pla",
             "redd_",
             "tizyx_",
-            "ultimaker_tough_pla_175",
             "verbatim_",
             "Vertex_",
             "volumic_",
             "xyzprinting_",
             "zyyx_pro_",
             "octofiber_",
-            "fiberlogy_"
+            "fiberlogy_",
+            "ultimaker_nylon_175",
+            "ultimaker_metallic_pla_175"
         ],
         "has_machine_materials": true,
         "has_machine_quality": true,
@@ -72,39 +73,7 @@
     "overrides":
     {
         "build_volume_temperature": { "maximum_value": "107" },
-        "machine_depth": { "default_value": 236.48 },
-        "machine_disallowed_areas":
-        {
-            "default_value": [
-                [
-                    [-141.65, -118.11],
-                    [141.65, -118.11],
-                    [141.65, -94],
-                    [-141.65, -94]
-                ],
-                [
-                    [-141.65, 118.37],
-                    [141.65, 118.37],
-                    [141.65, 94],
-                    [-141.65, 94]
-                ],
-                [
-                    [-141.65, -118.11],
-                    [-75, -118.11],
-                    [-75, 118.37],
-                    [-141.65, 118.37]
-                ],
-                [
-                    [75, -118.11],
-                    [141.65, -118.11],
-                    [141.65, 118.37],
-                    [75, 118.37]
-                ]
-            ]
-        },
-        "machine_height": { "default_value": 196 },
         "machine_name": { "default_value": "UltiMaker Method X" },
-        "machine_width": { "default_value": 283.3 },
         "prime_tower_position_x": { "value": "(150 / 2 + resolveOrValue('prime_tower_size') / 2) if resolveOrValue('machine_shape') == 'elliptic' else (150 - (resolveOrValue('prime_tower_base_size') if (resolveOrValue('adhesion_type') == 'raft' or resolveOrValue('prime_tower_brim_enable')) else 0) - max(max(extruderValues('travel_avoid_distance')) + max(extruderValues('support_offset')) + (extruderValue(skirt_brim_extruder_nr, 'skirt_brim_line_width') * extruderValue(skirt_brim_extruder_nr, 'skirt_line_count') * extruderValue(skirt_brim_extruder_nr, 'initial_layer_line_width_factor') / 100 + extruderValue(skirt_brim_extruder_nr, 'skirt_gap') if resolveOrValue('adhesion_type') == 'skirt' else 0) + (resolveOrValue('draft_shield_dist') if resolveOrValue('draft_shield_enabled') else 0), max(map(abs, extruderValues('machine_nozzle_offset_x'))), 1)) - (150 / 2 if resolveOrValue('machine_center_is_zero') else 0)" },
         "prime_tower_position_y": { "value": "190 - prime_tower_size - (resolveOrValue('prime_tower_base_size') if (resolveOrValue('adhesion_type') == 'raft' or resolveOrValue('prime_tower_brim_enable')) else 0) - max(max(extruderValues('travel_avoid_distance')) + max(extruderValues('support_offset')) + (extruderValue(skirt_brim_extruder_nr, 'skirt_brim_line_width') * extruderValue(skirt_brim_extruder_nr, 'skirt_line_count') * extruderValue(skirt_brim_extruder_nr, 'initial_layer_line_width_factor') / 100 + extruderValue(skirt_brim_extruder_nr, 'skirt_gap') if resolveOrValue('adhesion_type') == 'skirt' else 0) + (resolveOrValue('draft_shield_dist') if resolveOrValue('draft_shield_enabled') else 0), max(map(abs, extruderValues('machine_nozzle_offset_y'))), 1) - (190 / 2 if resolveOrValue('machine_center_is_zero') else 0)" }
     }

resources/definitions/ultimaker_methodxl.def.json

@@ -9,6 +9,44 @@
         "manufacturer": "Ultimaker B.V.",
         "file_formats": "application/x-makerbot",
         "platform": "ultimaker_method_xl_platform.stl",
+        "exclude_materials": [
+            "dsm_",
+            "Essentium_",
+            "imade3d_",
+            "chromatik_",
+            "3D-Fuel_",
+            "bestfilament_",
+            "emotiontech_",
+            "eryone_",
+            "eSUN_",
+            "Extrudr_",
+            "fabtotum_",
+            "fdplast_",
+            "filo3d_",
+            "generic_",
+            "goofoo_",
+            "ideagen3D_",
+            "imade3d_",
+            "innofill_",
+            "layer_one_",
+            "leapfrog_",
+            "polyflex_pla",
+            "polymax_pla",
+            "polyplus_pla",
+            "polywood_pla",
+            "redd_",
+            "tizyx_",
+            "verbatim_",
+            "Vertex_",
+            "volumic_",
+            "xyzprinting_",
+            "zyyx_pro_",
+            "octofiber_",
+            "fiberlogy_",
+            "basf_ultrafuse_316l_175",
+            "ultimaker_nylon_175",
+            "ultimaker_metallic_pla_175"
+        ],
         "has_machine_materials": true,
         "has_machine_quality": true,
         "has_materials": true,
@@ -18,6 +56,11 @@
             "0": "ultimaker_methodxl_extruder_left",
             "1": "ultimaker_methodxl_extruder_right"
         },
+        "platform_offset": [
+            0,
+            0,
+            0
+        ],
         "preferred_quality_type": "draft",
         "reference_machine_id": "magma_10",
         "supports_network_connection": true,
@@ -29,41 +72,24 @@
     {
         "build_volume_temperature": { "maximum_value": "100" },
         "machine_depth": { "default_value": 320 },
-        "machine_disallowed_areas":
-        {
-            "default_value": [
-                [
-                    [-204, -160],
-                    [204, -160],
-                    [204, -154.5],
-                    [-204, -154.5]
-                ],
-                [
-                    [-204, 160],
-                    [204, 160],
-                    [204, 154.5],
-                    [-204, 154.5]
-                ],
-                [
-                    [-205, -160],
-                    [-154.5, -160],
-                    [-154.5, 160],
-                    [-205, 160]
-                ],
-                [
-                    [154.5, -160],
-                    [205, -160],
-                    [205, 160],
-                    [154.5, 160]
-                ]
-            ]
-        },
+        "machine_disallowed_areas": { "value": "[ [ [-204, -160], [204, -160], [204, -154.5], [-204, -154.5] ], [ [-204, 160], [204, 160], [204, 154.5], [-204, 154.5] ], [ [-205, -160], [-191.5, -160], [-191.5, 160], [-205, 160] ], [ [154.5, -160], [205, -160], [205, 160], [154.5, 160] ] ] if max(extruderValues('extruder_nr')) == 0 else [ [ [-204, -160], [204, -160], [204, -154.5], [-204, -154.5] ], [ [-204, 160], [204, 160], [204, 154.5], [-204, 154.5] ], [ [-205, -160], [-154.5, -160], [-154.5, 160], [-205, 160] ], [ [154.5, -160], [205, -160], [205, 160], [154.5, 160] ] ]" },
         "machine_heated_bed": { "default_value": true },
-        "machine_height": { "default_value": 320 },
+        "machine_height": { "default_value": 319.9 },
         "machine_name": { "default_value": "UltiMaker Method XL" },
         "machine_width": { "default_value": 410 },
         "prime_tower_position_x": { "value": "(305 - (resolveOrValue('prime_tower_base_size') if (resolveOrValue('adhesion_type') == 'raft' or resolveOrValue('prime_tower_brim_enable')) else 0) - max(max(extruderValues('travel_avoid_distance')) + max(extruderValues('support_offset')) + (extruderValue(skirt_brim_extruder_nr, 'skirt_brim_line_width') * extruderValue(skirt_brim_extruder_nr, 'skirt_line_count') * extruderValue(skirt_brim_extruder_nr, 'initial_layer_line_width_factor') / 100 + extruderValue(skirt_brim_extruder_nr, 'skirt_gap') if resolveOrValue('adhesion_type') == 'skirt' else 0) + (resolveOrValue('draft_shield_dist') if resolveOrValue('draft_shield_enabled') else 0), max(map(abs, extruderValues('machine_nozzle_offset_x'))), 1)) - (305 / 2)" },
         "prime_tower_position_y": { "value": "305 - prime_tower_size - (resolveOrValue('prime_tower_base_size') if (resolveOrValue('adhesion_type') == 'raft' or resolveOrValue('prime_tower_brim_enable')) else 0) - max(max(extruderValues('travel_avoid_distance')) + max(extruderValues('support_offset')) + (extruderValue(skirt_brim_extruder_nr, 'skirt_brim_line_width') * extruderValue(skirt_brim_extruder_nr, 'skirt_line_count') * extruderValue(skirt_brim_extruder_nr, 'initial_layer_line_width_factor') / 100 + extruderValue(skirt_brim_extruder_nr, 'skirt_gap') if resolveOrValue('adhesion_type') == 'skirt' else 0) + (resolveOrValue('draft_shield_dist') if resolveOrValue('draft_shield_enabled') else 0), max(map(abs, extruderValues('machine_nozzle_offset_y'))), 1) - (305 / 2)" },
-        "speed_travel": { "value": 500 }
+        "speed_travel":
+        {
+            "maximum_value": 500,
+            "maximum_value_warning": 450,
+            "value": 400
+        },
+        "speed_travel_layer_0":
+        {
+            "maximum_value": 500,
+            "maximum_value_warning": 450,
+            "value": 250
+        }
     }
 }

resources/definitions/ultimaker_s5.def.json

@@ -48,6 +48,7 @@
         "preferred_variant_buildplate_name": "Glass",
         "preferred_variant_name": "AA 0.4",
         "supported_actions": [ "DiscoverUM3Action" ],
+        "supports_abstract_color": true,
         "supports_material_export": true,
         "supports_network_connection": true,
         "supports_usb_connection": false,

resources/definitions/ultimaker_s7.def.json

@@ -36,6 +36,7 @@
         "preferred_variant_name": "AA 0.4",
         "quality_definition": "ultimaker_s5",
         "supported_actions": [ "DiscoverUM3Action" ],
+        "supports_abstract_color": true,
         "supports_material_export": true,
         "supports_network_connection": true,
         "supports_usb_connection": false,

resources/definitions/ultimaker_sketch.def.json

@@ -0,0 +1,194 @@
+{
+    "version": 2,
+    "name": "MakerBot Sketch",
+    "inherits": "ultimaker",
+    "metadata":
+    {
+        "visible": true,
+        "author": "Ultimaker",
+        "manufacturer": "Ultimaker B.V.",
+        "file_formats": "application/x-makerbot-sketch",
+        "platform": "ultimaker_sketch_platform.obj",
+        "exclude_materials": [
+            "dsm_",
+            "Essentium_",
+            "imade3d_",
+            "chromatik_",
+            "3D-Fuel_",
+            "bestfilament_",
+            "emotiontech_",
+            "eryone_",
+            "eSUN_",
+            "Extrudr_",
+            "fabtotum_",
+            "fdplast_",
+            "filo3d_",
+            "ultimaker_rapidrinse_175",
+            "goofoo_",
+            "ideagen3D_",
+            "imade3d_",
+            "innofill_",
+            "layer_one_",
+            "leapfrog_",
+            "polyflex_pla",
+            "polymax_pla",
+            "polyplus_pla",
+            "polywood_pla",
+            "redd_",
+            "tizyx_",
+            "verbatim_",
+            "Vertex_",
+            "volumic_",
+            "xyzprinting_",
+            "zyyx_pro_",
+            "octofiber_",
+            "fiberlogy_",
+            "generic_",
+            "ultimaker_asa",
+            "ultimaker_abs",
+            "ultimaker_nylon",
+            "ultimaker_pva",
+            "ultimaker_rapidrinse",
+            "ultimaker_sr30",
+            "ultimaker_petg",
+            "ultimaker_metallic_pla",
+            "basf_",
+            "jabil_",
+            "polymaker_",
+            "ultimaker_rapidrinse",
+            "ultimaker_sr30",
+            "ultimaker_petg",
+            "ultimaker_pva",
+            "ultimaker_metallic_pla"
+        ],
+        "has_machine_quality": true,
+        "has_materials": true,
+        "has_variants": true,
+        "machine_extruder_trains": { "0": "ultimaker_sketch_extruder" },
+        "preferred_quality_type": "draft",
+        "preferred_variant_name": "0.4mm",
+        "reference_machine_id": "sketch",
+        "supports_network_connection": true,
+        "supports_usb_connection": false,
+        "variants_name": "Extruder",
+        "weight": -1
+    },
+    "overrides":
+    {
+        "acceleration_enabled":
+        {
+            "enabled": false,
+            "value": false
+        },
+        "adhesion_type": { "value": "'skirt'" },
+        "brim_width": { "value": "3" },
+        "cool_during_extruder_switch":
+        {
+            "enabled": false,
+            "value": false
+        },
+        "cool_fan_full_at_height": { "value": "layer_height + layer_height_0" },
+        "cool_fan_speed": { "value": 100 },
+        "cool_fan_speed_0": { "value": 0 },
+        "cool_min_layer_time": { "value": 8 },
+        "extruder_prime_pos_abs": { "default_value": true },
+        "fill_outline_gaps": { "value": false },
+        "gantry_height": { "value": "60" },
+        "infill_angles": { "value": "[45,45,45,45,45,135,135,135,135,135]" },
+        "infill_before_walls": { "value": false },
+        "infill_overlap": { "value": 0 },
+        "infill_pattern": { "value": "'zigzag'" },
+        "infill_sparse_density": { "value": 20 },
+        "infill_wipe_dist": { "value": 0 },
+        "initial_layer_line_width_factor": { "value": 125 },
+        "inset_direction": { "value": "'inside_out'" },
+        "jerk_enabled":
+        {
+            "enabled": false,
+            "value": false
+        },
+        "layer_height_0": { "value": "layer_height * 1.25" },
+        "layer_start_x": { "value": "sum(extruderValues('machine_extruder_start_pos_x')) / len(extruderValues('machine_extruder_start_pos_x'))" },
+        "layer_start_y": { "value": "sum(extruderValues('machine_extruder_start_pos_y')) / len(extruderValues('machine_extruder_start_pos_y'))" },
+        "machine_center_is_zero": { "default_value": true },
+        "machine_depth": { "default_value": 150 },
+        "machine_end_gcode": { "default_value": "M107; Disable Fan; \n; End of print; \n; End GCode\nM104 S0 T0; Set Toolhead Temp to 0\nM140 S0 T0; Set Platform Temp to 0\nG162 Z F1800; Move to max axes position\nG28 X Y; Home\nM652; Turn off back fan\nM132 X Y Z A B; Set Home Position\nG91; Use Relative Positioning\nM18; Disable Axes\n\n" },
+        "machine_extruder_count": { "default_value": 1 },
+        "machine_gcode_flavor": { "default_value": "Griffin" },
+        "machine_heated_bed": { "default_value": true },
+        "machine_height": { "default_value": 150 },
+        "machine_max_feedrate_x": { "default_value": 300 },
+        "machine_max_feedrate_y": { "default_value": 300 },
+        "machine_max_feedrate_z": { "default_value": 40 },
+        "machine_min_cool_heat_time_window": { "value": "15" },
+        "machine_name": { "default_value": "MakerBot Sketch" },
+        "machine_nozzle_cool_down_speed": { "default_value": 0.8 },
+        "machine_nozzle_heat_up_speed": { "default_value": 1.4 },
+        "machine_start_gcode": { "default_value": "M140 S50 T0; Set Platform Temp\nM104 S220 T0; Set Extruder Temp\nG90; Use Absolute Positioning\nG28; Home\nM132 X Y Z A B; Set Current Position to Home\nG161 X Y F3300; Move to min axes positions\nM7 T0; Wait For Platform to Heat\nM6 T0; Wait For Extruders to Heat\nM651; Turn on back fan\nM907 X100 Y100 Z40 A80 B20; Set Stepper Currents\nM106; Enable Cooling Fan\n; Purge Line\nG92 E0; Reset Extruder Axis Position\nG1 X-26.18 Y-75.90 Z0.200 F420\nG1 X26.18 Y-75.90 E10\nG92 E0; Reset Extruder Axis Position\n; Start GCode\n" },
+        "machine_width": { "default_value": 150 },
+        "material_diameter": { "default_value": 1.75 },
+        "material_flow": { "default_value": 100 },
+        "min_bead_width":
+        {
+            "minimum_value": "line_width * 0.5",
+            "minimum_value_warning": "line_width * 0.75",
+            "value": "line_width"
+        },
+        "min_wall_line_width":
+        {
+            "minimum_value": "line_width * 0.5",
+            "minimum_value_warning": "line_width * 0.75",
+            "value": "line_width"
+        },
+        "multiple_mesh_overlap": { "value": "0" },
+        "optimize_wall_printing_order": { "value": "True" },
+        "prime_blob_enable":
+        {
+            "default_value": true,
+            "enabled": true,
+            "value": "resolveOrValue('print_sequence') != 'one_at_a_time'"
+        },
+        "raft_margin": { "value": "5" },
+        "retract_at_layer_change": { "value": true },
+        "retraction_amount":
+        {
+            "maximum_value": 6,
+            "maximum_value_warning": 5.75,
+            "value": 5.5
+        },
+        "retraction_combing": { "value": "'no_outer_surfaces'" },
+        "retraction_min_travel": { "value": "2 * line_width" },
+        "retraction_prime_speed": { "value": "15" },
+        "retraction_speed": { "value": "25" },
+        "roofing_material_flow": { "value": 100 },
+        "skin_material_flow": { "value": 95 },
+        "skin_material_flow_layer_0": { "value": 100 },
+        "skirt_brim_line_width": { "value": 1 },
+        "skirt_brim_speed": { "value": 15 },
+        "skirt_height": { "value": 3 },
+        "speed_print": { "value": 50 },
+        "speed_roofing": { "value": "0.8 * speed_print" },
+        "speed_support": { "value": "0.7 * speed_print" },
+        "speed_support_interface": { "value": "speed_topbottom" },
+        "speed_topbottom": { "value": "speed_roofing" },
+        "speed_travel": { "value": 80 },
+        "speed_wall": { "value": "0.5 * speed_print" },
+        "speed_wall_0": { "value": "1 * speed_wall" },
+        "speed_wall_x": { "value": "1 * speed_wall" },
+        "speed_z_hop": { "value": 10 },
+        "support_angle": { "value": "45" },
+        "support_structure": { "value": "'tree'" },
+        "top_bottom_thickness": { "value": "4 * layer_height" },
+        "travel_avoid_distance": { "value": "machine_nozzle_tip_outer_diameter / 2 * 1.5" },
+        "travel_avoid_supports": { "value": true },
+        "wall_0_inset": { "value": "0" },
+        "wall_0_material_flow_layer_0": { "value": "1 * material_flow" },
+        "wall_thickness": { "value": "2 * machine_nozzle_size" },
+        "wall_x_material_flow": { "value": "0.95 * material_flow" },
+        "wall_x_material_flow_layer_0": { "value": "1 * material_flow" },
+        "xy_offset": { "value": 0 },
+        "xy_offset_layer_0": { "value": 0 },
+        "z_seam_corner": { "value": "'z_seam_corner_any'" },
+        "zig_zaggify_infill": { "value": "gradual_infill_steps == 0" }
+    }
+}

resources/definitions/ultimaker_sketch_large.def.json

@@ -0,0 +1,40 @@
+{
+    "version": 2,
+    "name": "MakerBot Sketch Large",
+    "inherits": "ultimaker_sketch",
+    "metadata":
+    {
+        "visible": true,
+        "author": "Ultimaker",
+        "manufacturer": "Ultimaker B.V.",
+        "file_formats": "application/x-makerbot-sketch",
+        "platform": "ultimaker_sketch_large_platform.obj",
+        "has_machine_quality": true,
+        "has_materials": true,
+        "has_variants": true,
+        "machine_extruder_trains": { "0": "ultimaker_sketch_large_extruder" },
+        "preferred_material": "ultimaker_pla_175",
+        "preferred_quality_type": "draft",
+        "preferred_variant_name": "0.4mm",
+        "reference_machine_id": "sketch_large",
+        "supports_network_connection": true,
+        "supports_usb_connection": false,
+        "variants_name": "Extruder",
+        "weight": -1
+    },
+    "overrides":
+    {
+        "machine_depth": { "default_value": 200 },
+        "machine_height": { "default_value": 250 },
+        "machine_name": { "default_value": "MakerBot Sketch Large" },
+        "machine_width": { "default_value": 220 },
+        "retraction_amount":
+        {
+            "maximum_value": 6.5,
+            "maximum_value_warning": 6.25,
+            "value": 6
+        },
+        "retraction_prime_speed": { "value": "retraction_speed * 0.8" },
+        "speed_travel": { "value": 150 }
+    }
+}

resources/definitions/ultimaker_sketch_sprint.def.json

@@ -0,0 +1,392 @@
+{
+    "version": 2,
+    "name": "MakerBot Sketch Sprint",
+    "inherits": "ultimaker",
+    "metadata":
+    {
+        "visible": true,
+        "author": "Ultimaker",
+        "manufacturer": "Ultimaker B.V.",
+        "file_formats": "application/x-makerbot-sketch",
+        "platform": "ultimaker_sketch_sprint_platform.obj",
+        "exclude_materials": [
+            "dsm_",
+            "Essentium_",
+            "imade3d_",
+            "chromatik_",
+            "3D-Fuel_",
+            "bestfilament_",
+            "emotiontech_",
+            "eryone_",
+            "eSUN_",
+            "Extrudr_",
+            "fabtotum_",
+            "fdplast_",
+            "filo3d_",
+            "goofoo_",
+            "ideagen3D_",
+            "imade3d_",
+            "innofill_",
+            "layer_one_",
+            "leapfrog_",
+            "polyflex_pla",
+            "polymax_pla",
+            "polyplus_pla",
+            "polywood_pla",
+            "redd_",
+            "tizyx_",
+            "verbatim_",
+            "Vertex_",
+            "volumic_",
+            "xyzprinting_",
+            "zyyx_pro_",
+            "octofiber_",
+            "fiberlogy_",
+            "generic_",
+            "ultimaker_asa",
+            "ultimaker_abs",
+            "ultimaker_nylon",
+            "ultimaker_pva",
+            "ultimaker_rapidrinse",
+            "ultimaker_sr30",
+            "ultimaker_petg",
+            "ultimaker_metallic_pla"
+        ],
+        "has_machine_quality": true,
+        "has_materials": true,
+        "has_variants": true,
+        "machine_extruder_trains": { "0": "ultimaker_sketch_sprint_extruder" },
+        "platform_offset": [
+            0,
+            0,
+            0
+        ],
+        "platform_texture": "MakerbotSketchSprint.png",
+        "preferred_material": "ultimaker_pla_175",
+        "preferred_quality_type": "draft",
+        "preferred_variant_name": "0.4mm",
+        "reference_machine_id": "sketch_sprint",
+        "supports_network_connection": true,
+        "supports_usb_connection": false,
+        "variants_name": "Extruder",
+        "weight": -1
+    },
+    "overrides":
+    {
+        "acceleration_enabled": { "value": true },
+        "acceleration_layer_0": { "value": "acceleration_print * 0.05" },
+        "acceleration_print": { "value": 10000 },
+        "acceleration_print_layer_0": { "value": "acceleration_layer_0" },
+        "acceleration_roofing": { "value": "acceleration_print * 0.2" },
+        "acceleration_skirt_brim": { "value": "acceleration_layer_0" },
+        "acceleration_topbottom": { "value": "acceleration_print * 0.2" },
+        "acceleration_travel": { "value": "acceleration_print" },
+        "acceleration_travel_enabled": { "value": true },
+        "acceleration_travel_layer_0": { "value": "acceleration_travel * 0.2" },
+        "acceleration_wall": { "value": "acceleration_print * 0.5" },
+        "acceleration_wall_0_roofing": { "value": "acceleration_wall * 2/5" },
+        "acceleration_wall_x_roofing": { "value": "acceleration_wall * 2/5" },
+        "adhesion_type": { "value": "'none'" },
+        "bottom_layers": { "value": 3 },
+        "bridge_skin_density": { "value": 100 },
+        "bridge_skin_density_2": { "value": 75 },
+        "bridge_skin_density_3": { "value": 80 },
+        "bridge_skin_material_flow_3": { "value": 110 },
+        "bridge_skin_speed": { "value": 50 },
+        "bridge_skin_speed_2": { "value": 50 },
+        "bridge_skin_speed_3": { "value": 50 },
+        "bridge_sparse_infill_max_density": { "value": 15 },
+        "bridge_wall_min_length": { "value": 2.4 },
+        "bridge_wall_speed": { "value": 20 },
+        "brim_gap": { "value": 0.32 },
+        "brim_inside_margin": { "value": 1.6 },
+        "brim_line_count": { "value": 3 },
+        "brim_width": { "value": 2.4 },
+        "build_volume_fan_nr": { "value": 101 },
+        "cool_fan_full_layer": { "value": "1 if adhesion_type == 'raft' else 3" },
+        "cool_fan_speed_0": { "value": 0 },
+        "cool_min_layer_time": { "value": 3 },
+        "cool_min_layer_time_fan_speed_max": { "value": 10 },
+        "cool_min_speed": { "value": 20 },
+        "default_material_print_temperature":
+        {
+            "maximum_value": 280,
+            "maximum_value_warning": 240
+        },
+        "gantry_height": { "value": 27.5 },
+        "gradual_infill_steps": { "value": 0 },
+        "gradual_support_infill_steps": { "value": 0 },
+        "group_outer_walls": { "value": false },
+        "infill_angles":
+        {
+            "value": [
+                135
+            ]
+        },
+        "infill_before_walls": { "value": false },
+        "infill_line_width": { "value": 0.45 },
+        "infill_overlap": { "value": 10 },
+        "infill_pattern": { "value": "'lines'" },
+        "infill_sparse_density": { "value": 15 },
+        "infill_wipe_dist": { "value": 0 },
+        "initial_layer_line_width_factor": { "value": 150 },
+        "inset_direction": { "value": "'inside_out'" },
+        "jerk_enabled":
+        {
+            "enabled": false,
+            "value": false
+        },
+        "jerk_travel_enabled": { "enabled": false },
+        "layer_height_0": { "value": "layer_height if adhesion_type == 'raft' else layer_height * 1.25" },
+        "line_width": { "value": 0.42 },
+        "machine_center_is_zero": { "default_value": true },
+        "machine_depth": { "default_value": 221.5 },
+        "machine_end_gcode": { "default_value": "M104 S0 T0\nM140 S0 T0\nG162 Z F1800\nG28 X Y\nM132 X Y A B\nM652\nG91" },
+        "machine_extruder_count": { "default_value": 1 },
+        "machine_gcode_flavor": { "default_value": "RepRap (Marlin/Sprinter)" },
+        "machine_heated_bed": { "default_value": true },
+        "machine_height": { "default_value": 220.4 },
+        "machine_max_feedrate_x": { "default_value": 600 },
+        "machine_max_feedrate_y": { "default_value": 600 },
+        "machine_max_feedrate_z": { "default_value": 40 },
+        "machine_min_cool_heat_time_window": { "value": "15" },
+        "machine_name": { "default_value": "MakerBot Sketch Sprint" },
+        "machine_start_gcode": { "default_value": "G28\nM132 X Y Z A B\nG1 Z50.000 F420\nG161 X Y F3300\nM7 T0\nM6 T0\nM651 S255\nG1 Z0.25 F6000\nG1 E-1.5 F800\nG1 E2 F800\nG1 X111 Y111 Z0.25 F4800\nG1 X111 Y-111 E25 F1200" },
+        "machine_width": { "default_value": 221.5 },
+        "material_bed_temp_wait": { "value": "False" },
+        "material_bed_temperature":
+        {
+            "maximum_value": 100,
+            "maximum_value_warning": 70
+        },
+        "material_bed_temperature_layer_0":
+        {
+            "maximum_value": 100,
+            "maximum_value_warning": 70
+        },
+        "material_diameter": { "default_value": 1.75 },
+        "material_flow": { "default_value": 100 },
+        "material_print_temperature":
+        {
+            "maximum_value": 280,
+            "maximum_value_warning": 240
+        },
+        "min_bead_width": { "value": 0.3 },
+        "multiple_mesh_overlap": { "value": "0" },
+        "raft_airgap": { "value": 0.35 },
+        "raft_base_acceleration": { "value": "acceleration_layer_0" },
+        "raft_base_speed":
+        {
+            "maximum_value": "raft_speed",
+            "maximum_value_warning": "raft_speed * 1/2",
+            "value": "raft_speed * 1/4"
+        },
+        "raft_interface_acceleration": { "value": "acceleration_print * 0.2" },
+        "raft_interface_line_width": { "value": 0.7 },
+        "raft_interface_speed":
+        {
+            "maximum_value": 300,
+            "maximum_value_warning": 275,
+            "value": "raft_speed * 3/4"
+        },
+        "raft_interface_wall_count": { "value": "raft_wall_count" },
+        "raft_margin": { "value": "1.5" },
+        "raft_smoothing": { "value": "9.5" },
+        "raft_speed": { "value": 200 },
+        "raft_surface_acceleration": { "value": "acceleration_print * 0.5" },
+        "raft_surface_line_width": { "value": 0.4 },
+        "raft_surface_speed":
+        {
+            "maximum_value": 300,
+            "maximum_value_warning": 275
+        },
+        "raft_surface_wall_count": { "value": "raft_wall_count" },
+        "raft_wall_count": { "value": 2 },
+        "retract_at_layer_change": { "value": true },
+        "retraction_amount": { "value": "1.0" },
+        "retraction_combing": { "value": "'all'" },
+        "retraction_combing_max_distance": { "value": 10 },
+        "retraction_count_max": { "value": 90 },
+        "retraction_extrusion_window": { "value": 1.2 },
+        "retraction_hop": { "value": 0.4 },
+        "retraction_hop_enabled": { "value": true },
+        "retraction_hop_only_when_collides": { "value": true },
+        "retraction_min_travel": { "value": 0.8 },
+        "retraction_prime_speed": { "value": "35" },
+        "retraction_speed": { "value": "35" },
+        "seam_overhang_angle": { "value": 30 },
+        "skin_edge_support_thickness": { "value": 0 },
+        "skin_material_flow": { "value": "material_flow" },
+        "skin_material_flow_layer_0": { "value": "material_flow * 0.95" },
+        "skin_monotonic": { "value": true },
+        "skin_outline_count": { "value": 0 },
+        "skin_overlap": { "value": 10 },
+        "skirt_brim_minimal_length": { "value": 250 },
+        "skirt_gap": { "value": 1.2 },
+        "skirt_height": { "value": 1 },
+        "small_feature_speed_factor": { "value": 10 },
+        "small_hole_max_size": { "value": 0 },
+        "speed_equalize_flow_width_factor": { "value": 100 },
+        "speed_infill":
+        {
+            "maximum_value": 300,
+            "maximum_value_warning": 275,
+            "value": "speed_print if infill_sparse_density < 70 else speed_print * 0.8"
+        },
+        "speed_layer_0":
+        {
+            "maximum_value": 200,
+            "maximum_value_warning": 175,
+            "value": "round(8/35 * speed_print)"
+        },
+        "speed_print":
+        {
+            "maximum_value": 300,
+            "maximum_value_warning": 275,
+            "value": 250
+        },
+        "speed_roofing":
+        {
+            "maximum_value": 300,
+            "maximum_value_warning": 275,
+            "value": "round(9/14 * speed_print)"
+        },
+        "speed_slowdown_layers": { "value": 2 },
+        "speed_support":
+        {
+            "maximum_value": 300,
+            "maximum_value_warning": 275,
+            "value": "1 * speed_print"
+        },
+        "speed_support_bottom":
+        {
+            "maximum_value": 300,
+            "maximum_value_warning": 275,
+            "value": "round(3/7 * speed_support)"
+        },
+        "speed_support_infill":
+        {
+            "maximum_value": 300,
+            "maximum_value_warning": 275
+        },
+        "speed_support_interface":
+        {
+            "maximum_value": 300,
+            "maximum_value_warning": 275,
+            "value": "round(23/35 * speed_support)"
+        },
+        "speed_support_roof":
+        {
+            "maximum_value": 300,
+            "maximum_value_warning": 275
+        },
+        "speed_topbottom":
+        {
+            "maximum_value": 300,
+            "maximum_value_warning": 275,
+            "value": "round(9/14 * speed_print)"
+        },
+        "speed_travel":
+        {
+            "maximum_value": 600,
+            "maximum_value_warning": 550,
+            "value": 500
+        },
+        "speed_travel_layer_0":
+        {
+            "maximum_value": 550,
+            "maximum_value_warning": 500,
+            "value": 250
+        },
+        "speed_wall":
+        {
+            "maximum_value": 300,
+            "maximum_value_warning": 275,
+            "value": "2/5 * speed_print"
+        },
+        "speed_wall_0":
+        {
+            "maximum_value": 300,
+            "maximum_value_warning": 275,
+            "value": "1 * speed_wall"
+        },
+        "speed_wall_0_roofing":
+        {
+            "maximum_value": 300,
+            "maximum_value_warning": 275,
+            "value": "speed_wall_0"
+        },
+        "speed_wall_x":
+        {
+            "maximum_value": 300,
+            "maximum_value_warning": 275,
+            "value": "round(1.428575 * speed_wall,0)"
+        },
+        "speed_wall_x_roofing":
+        {
+            "maximum_value": 300,
+            "maximum_value_warning": 275
+        },
+        "speed_z_hop":
+        {
+            "maximum_value": 24,
+            "maximum_value_warning": 22,
+            "value": 20
+        },
+        "support_angle": { "value": "60" },
+        "support_bottom_density": { "value": "support_infill_rate" },
+        "support_bottom_distance": { "value": "layer_height" },
+        "support_bottom_enable": { "value": true },
+        "support_bottom_height": { "value": "layer_height * 2" },
+        "support_brim_line_count": { "value": 5 },
+        "support_infill_angles":
+        {
+            "value": [
+                45
+            ]
+        },
+        "support_infill_rate": { "value": 15 },
+        "support_interface_density": { "value": 80 },
+        "support_interface_enable": { "value": true },
+        "support_interface_height": { "value": "layer_height * 3" },
+        "support_interface_material_flow": { "value": "material_flow" },
+        "support_interface_offset": { "value": 1 },
+        "support_interface_pattern": { "value": "'lines'" },
+        "support_interface_wall_count": { "value": 0 },
+        "support_line_width": { "value": 0.32 },
+        "support_material_flow": { "value": "material_flow * 0.9" },
+        "support_offset": { "value": 1.6 },
+        "support_pattern": { "value": "'lines'" },
+        "support_roof_height": { "value": "support_interface_height" },
+        "support_roof_wall_count": { "value": "support_interface_wall_count" },
+        "support_top_distance": { "value": "support_z_distance" },
+        "support_use_towers": { "value": false },
+        "support_xy_distance": { "value": 0.3 },
+        "support_xy_overrides_z": { "value": "'xy_overrides_z'" },
+        "support_z_distance": { "value": "layer_height if support_structure == 'tree' else 0.25" },
+        "top_bottom_thickness": { "value": "5 * layer_height" },
+        "top_layers": { "value": 5 },
+        "travel_avoid_distance": { "value": 0.625 },
+        "travel_avoid_supports": { "value": true },
+        "wall_0_inset": { "value": "0" },
+        "wall_0_material_flow_layer_0": { "value": "material_flow * 0.95" },
+        "wall_0_wipe_dist": { "value": 0.2 },
+        "wall_line_width_x": { "value": 0.58 },
+        "wall_overhang_angle": { "value": 35 },
+        "wall_overhang_speed_factor":
+        {
+            "minimum_value_warning": 15,
+            "value": 17.5
+        },
+        "wall_thickness": { "value": 1 },
+        "wall_x_material_flow_layer_0": { "value": "material_flow" },
+        "xy_offset": { "value": 0 },
+        "xy_offset_layer_0": { "value": -0.1 },
+        "z_seam_corner": { "value": "'z_seam_corner_inner'" },
+        "z_seam_position": { "value": "'backleft'" },
+        "z_seam_type": { "value": "'sharpest_corner'" },
+        "z_seam_x": { "value": 150 },
+        "z_seam_y": { "value": 180 },
+        "zig_zaggify_infill": { "value": true }
+    }
+}

resources/extruders/Mark2_extruder1.def.json

@@ -14,6 +14,7 @@
             "default_value": 0,
             "maximum_value": "1"
         },
+        "machine_nozzle_head_distance": { "default_value": 5 },
         "machine_nozzle_offset_x": { "default_value": 0.0 },
         "machine_nozzle_offset_y": { "default_value": 0.0 }
     }

resources/extruders/Mark2_extruder2.def.json

@@ -14,6 +14,7 @@
             "default_value": 1,
             "maximum_value": "1"
         },
+        "machine_nozzle_head_distance": { "default_value": 5 },
         "machine_nozzle_offset_x": { "default_value": 0.0 },
         "machine_nozzle_offset_y": { "default_value": 0.0 }
     }

resources/extruders/atom3_extruder_0.def.json

@@ -10,6 +10,7 @@
     "overrides":
     {
         "extruder_nr": { "default_value": 0 },
+        "machine_nozzle_head_distance": { "default_value": 6 },
         "machine_nozzle_size": { "default_value": 0.4 },
         "material_diameter": { "default_value": 1.75 }
     }

resources/extruders/diy220_extruder_0.def.json

@@ -10,6 +10,7 @@
     "overrides":
     {
         "extruder_nr": { "default_value": 0 },
+        "machine_nozzle_head_distance": { "default_value": 3 },
         "machine_nozzle_size": { "default_value": 0.4 },
         "material_diameter": { "default_value": 1.75 }
     }

resources/extruders/dxu_extruder1.def.json

@@ -14,6 +14,7 @@
             "default_value": 0,
             "maximum_value": "1"
         },
+        "machine_nozzle_head_distance": { "default_value": 5 },
         "machine_nozzle_offset_x": { "default_value": 0.0 },
         "machine_nozzle_offset_y": { "default_value": 0.0 },
         "machine_nozzle_size": { "default_value": 0.4 },

resources/extruders/dxu_extruder2.def.json

@@ -14,6 +14,7 @@
             "default_value": 1,
             "maximum_value": "1"
         },
+        "machine_nozzle_head_distance": { "default_value": 5 },
         "machine_nozzle_offset_x": { "default_value": 19.0 },
         "machine_nozzle_offset_y": { "default_value": 0.0 },
         "machine_nozzle_size": { "default_value": 0.4 },

resources/extruders/eazao_m500_extruder_0.def.json

@@ -0,0 +1,16 @@
+{
+    "version": 2,
+    "name": "Extruder 1",
+    "inherits": "fdmextruder",
+    "metadata":
+    {
+        "machine": "eazao_m500",
+        "position": "0"
+    },
+    "overrides":
+    {
+        "extruder_nr": { "default_value": 0 },
+        "machine_nozzle_size": { "default_value": 2.3 },
+        "material_diameter": { "default_value": 1.75 }
+    }
+}

resources/extruders/eazao_m600_extruder_0.def.json

@@ -0,0 +1,16 @@
+{
+    "version": 2,
+    "name": "Extruder 1",
+    "inherits": "fdmextruder",
+    "metadata":
+    {
+        "machine": "eazao_m600",
+        "position": "0"
+    },
+    "overrides":
+    {
+        "extruder_nr": { "default_value": 0 },
+        "machine_nozzle_size": { "default_value": 2.3 },
+        "material_diameter": { "default_value": 1.75 }
+    }
+}

resources/extruders/eazao_m700_extruder_0.def.json

@@ -0,0 +1,16 @@
+{
+    "version": 2,
+    "name": "Extruder 1",
+    "inherits": "fdmextruder",
+    "metadata":
+    {
+        "machine": "eazao_m700",
+        "position": "0"
+    },
+    "overrides":
+    {
+        "extruder_nr": { "default_value": 0 },
+        "machine_nozzle_size": { "default_value": 2.3 },
+        "material_diameter": { "default_value": 1.75 }
+    }
+}

resources/extruders/eazao_potter_extruder_0.def.json

@@ -0,0 +1,16 @@
+{
+    "version": 2,
+    "name": "Extruder 1",
+    "inherits": "fdmextruder",
+    "metadata":
+    {
+        "machine": "eazao_potter",
+        "position": "0"
+    },
+    "overrides":
+    {
+        "extruder_nr": { "default_value": 0 },
+        "machine_nozzle_size": { "default_value": 1.6 },
+        "material_diameter": { "default_value": 1.75 }
+    }
+}

resources/extruders/eazao_zero_extruder_0.def.json

@@ -10,7 +10,7 @@
     "overrides":
     {
         "extruder_nr": { "default_value": 0 },
-        "machine_nozzle_size": { "default_value": 1.5 },
+        "machine_nozzle_size": { "default_value": 1.6 },
         "material_diameter": { "default_value": 1.75 }
     }
 }

resources/extruders/erzay3d_extruder_0.def.json

@@ -10,6 +10,7 @@
     "overrides":
     {
         "extruder_nr": { "default_value": 0 },
+        "machine_nozzle_head_distance": { "default_value": 2.5 },
         "machine_nozzle_size": { "default_value": 0.4 },
         "material_diameter": { "default_value": 1.75 }
     }

resources/extruders/maker_starter_extruder_0.def.json

@@ -10,6 +10,7 @@
     "overrides":
     {
         "extruder_nr": { "default_value": 0 },
+        "machine_nozzle_head_distance": { "default_value": 3 },
         "machine_nozzle_size": { "default_value": 0.4 },
         "material_diameter": { "default_value": 1.75 }
     }

resources/extruders/mendel90_extruder_0.def.json

@@ -10,6 +10,7 @@
     "overrides":
     {
         "extruder_nr": { "default_value": 0 },
+        "machine_nozzle_head_distance": { "default_value": 5 },
         "machine_nozzle_size": { "default_value": 0.4 },
         "material_diameter": { "default_value": 1.75 }
     }

resources/extruders/structur3d_discov3ry1_complete_um2plus_extruder_0.def.json

@@ -10,6 +10,7 @@
     "overrides":
     {
         "extruder_nr": { "default_value": 0 },
+        "machine_nozzle_head_distance": { "default_value": 5 },
         "machine_nozzle_size": { "default_value": 0.84 },
         "material_diameter": { "default_value": 3.175 }
     }

resources/extruders/tam_extruder_0.def.json

@@ -10,6 +10,7 @@
     "overrides":
     {
         "extruder_nr": { "default_value": 0 },
+        "machine_nozzle_head_distance": { "default_value": 3 },
         "machine_nozzle_size": { "default_value": 0.4 },
         "material_diameter": { "default_value": 1.75 }
     }

resources/extruders/ultimaker2_extruder_0.def.json

@@ -10,6 +10,7 @@
     "overrides":
     {
         "extruder_nr": { "default_value": 0 },
+        "machine_nozzle_head_distance": { "default_value": 3 },
         "machine_nozzle_size": { "default_value": 0.4 },
         "material_diameter": { "default_value": 2.85 }
     }

resources/extruders/ultimaker2_plus_connect_extruder_0.def.json

@@ -10,6 +10,7 @@
     "overrides":
     {
         "extruder_nr": { "default_value": 0 },
+        "machine_nozzle_head_distance": { "default_value": 5 },
         "machine_nozzle_size": { "default_value": 0.4 },
         "material_diameter": { "default_value": 2.85 }
     }

resources/extruders/ultimaker2_plus_extruder_0.def.json

@@ -10,6 +10,7 @@
     "overrides":
     {
         "extruder_nr": { "default_value": 0 },
+        "machine_nozzle_head_distance": { "default_value": 5 },
         "machine_nozzle_size": { "default_value": 0.4 },
         "material_diameter": { "default_value": 2.85 }
     }

resources/extruders/ultimaker_method_extruder_left.def.json

@@ -16,7 +16,7 @@
         },
         "machine_extruder_cooling_fan_number": { "default_value": 0 },
         "machine_extruder_end_code": { "default_value": "M106 P{extruder_nr} S1.0\nG91\nG0 Z0.4 F600\nG90\nG0 X{prime_tower_position_x - prime_tower_size/2} Y{prime_tower_position_y + prime_tower_size/2} F6000" },
-        "machine_extruder_start_code": { "default_value": "G0 X{prime_tower_position_x - prime_tower_size/2} Y{prime_tower_position_y + prime_tower_size/2} F6000\nM104 S{material_print_temperature}\nG4 S5\nG91\nG0 Z-0.4 F600\nG90\nM107 P{(extruder_nr+1)%2}\nM106 P{extruder_nr} S{cool_fan_speed_0/100}" },
+        "machine_extruder_start_code": { "default_value": "G0 X{prime_tower_position_x - prime_tower_size/2} Y{prime_tower_position_y + prime_tower_size/2} F6000\nM104 S{material_print_temperature}\nG4 S5\nG91\nG0 Z-0.4 F600\nG90\nM107 P{(extruder_nr+1)%2}\nM106 P{extruder_nr} S{(layer_z > 1 ? cool_fan_speed/100 : cool_fan_speed_0/100)}" },
         "machine_extruder_start_code_duration": { "default_value": 8 },
         "machine_nozzle_offset_x": { "default_value": 0 },
         "machine_nozzle_offset_y": { "default_value": 0 },

resources/extruders/ultimaker_method_extruder_right.def.json

@@ -16,7 +16,7 @@
         },
         "machine_extruder_cooling_fan_number": { "default_value": 1 },
         "machine_extruder_end_code": { "default_value": "M106 P{extruder_nr} S1.0\nG91\nG0 Z0.4 F600\nG90\nG0 X{prime_tower_position_x - prime_tower_size/2} Y{prime_tower_position_y + prime_tower_size/2} F6000" },
-        "machine_extruder_start_code": { "default_value": "G0 X{prime_tower_position_x - prime_tower_size/2} Y{prime_tower_position_y + prime_tower_size/2} F6000\nM104 S{material_print_temperature}\nG4 S5\nG91\nG0 Z-0.4 F600\nG90\nM107 P{(extruder_nr+1)%2}\nM106 P{extruder_nr} S{cool_fan_speed_0/100}" },
+        "machine_extruder_start_code": { "default_value": "G0 X{prime_tower_position_x - prime_tower_size/2} Y{prime_tower_position_y + prime_tower_size/2} F6000\nM104 S{material_print_temperature}\nG4 S5\nG91\nG0 Z-0.4 F600\nG90\nM107 P{(extruder_nr+1)%2}\nM106 P{extruder_nr} S{(layer_z > 1 ? cool_fan_speed/100 : cool_fan_speed_0/100)}" },
         "machine_extruder_start_code_duration": { "default_value": 8 },
         "machine_nozzle_offset_x": { "default_value": 0 },
         "machine_nozzle_offset_y": { "default_value": 0 },

resources/extruders/ultimaker_methodx_extruder_left.def.json

@@ -16,7 +16,7 @@
         },
         "machine_extruder_cooling_fan_number": { "default_value": 0 },
         "machine_extruder_end_code": { "default_value": "M106 P{extruder_nr} S1.0\nG91\nG0 Z0.4 F600\nG90\nG0 X{prime_tower_position_x - prime_tower_size/2} Y{prime_tower_position_y + prime_tower_size/2} F6000" },
-        "machine_extruder_start_code": { "default_value": "G0 X{prime_tower_position_x - prime_tower_size/2} Y{prime_tower_position_y + prime_tower_size/2} F6000\nM104 S{material_print_temperature}\nG4 S5\nG91\nG0 Z-0.4 F600\nG90\nM107 P{(extruder_nr+1)%2}\nM106 P{extruder_nr} S{cool_fan_speed_0/100}" },
+        "machine_extruder_start_code": { "default_value": "G0 X{prime_tower_position_x - prime_tower_size/2} Y{prime_tower_position_y + prime_tower_size/2} F6000\nM104 S{material_print_temperature}\nG4 S5\nG91\nG0 Z-0.4 F600\nG90\nM107 P{(extruder_nr+1)%2}\nM106 P{extruder_nr} S{(layer_z > 1 ? cool_fan_speed/100 : cool_fan_speed_0/100)}" },
         "machine_extruder_start_code_duration": { "default_value": 8 },
         "machine_nozzle_offset_x": { "default_value": 0 },
         "machine_nozzle_offset_y": { "default_value": 0 },

resources/extruders/ultimaker_methodx_extruder_right.def.json

@@ -16,7 +16,7 @@
         },
         "machine_extruder_cooling_fan_number": { "default_value": 1 },
         "machine_extruder_end_code": { "default_value": "M106 P{extruder_nr} S1.0\nG91\nG0 Z0.4 F600\nG90\nG0 X{prime_tower_position_x - prime_tower_size/2} Y{prime_tower_position_y + prime_tower_size/2} F6000" },
-        "machine_extruder_start_code": { "default_value": "G0 X{prime_tower_position_x - prime_tower_size/2} Y{prime_tower_position_y + prime_tower_size/2} F6000\nM104 S{material_print_temperature}\nG4 S5\nG91\nG0 Z-0.4 F600\nG90\nM107 P{(extruder_nr+1)%2}\nM106 P{extruder_nr} S{cool_fan_speed_0/100}" },
+        "machine_extruder_start_code": { "default_value": "G0 X{prime_tower_position_x - prime_tower_size/2} Y{prime_tower_position_y + prime_tower_size/2} F6000\nM104 S{material_print_temperature}\nG4 S5\nG91\nG0 Z-0.4 F600\nG90\nM107 P{(extruder_nr+1)%2}\nM106 P{extruder_nr} S{(layer_z > 1 ? cool_fan_speed/100 : cool_fan_speed_0/100)}" },
         "machine_extruder_start_code_duration": { "default_value": 8 },
         "machine_nozzle_offset_x": { "default_value": 0 },
         "machine_nozzle_offset_y": { "default_value": 0 },

resources/extruders/ultimaker_methodxl_extruder_left.def.json

@@ -16,7 +16,7 @@
         },
         "machine_extruder_cooling_fan_number": { "default_value": 0 },
         "machine_extruder_end_code": { "default_value": "M106 P{extruder_nr} S1.0\nG91\nG0 Z0.4 F600\nG90\nG0 X{prime_tower_position_x - prime_tower_size/2} Y{prime_tower_position_y + prime_tower_size/2} F6000" },
-        "machine_extruder_start_code": { "default_value": "G0 X{prime_tower_position_x - prime_tower_size/2} Y{prime_tower_position_y + prime_tower_size/2} F6000\nM104 S{material_print_temperature}\nG4 S5\nG91\nG0 Z-0.4 F600\nG90\nM107 P{(extruder_nr+1)%2}\nM106 P{extruder_nr} S{cool_fan_speed_0/100}" },
+        "machine_extruder_start_code": { "default_value": "G0 X{prime_tower_position_x - prime_tower_size/2} Y{prime_tower_position_y + prime_tower_size/2} F6000\nM104 S{material_print_temperature}\nG4 S5\nG91\nG0 Z-0.4 F600\nG90\nM107 P{(extruder_nr+1)%2}\nM106 P{extruder_nr} S{(layer_z > 1 ? cool_fan_speed/100 : cool_fan_speed_0/100)}" },
         "machine_extruder_start_code_duration": { "default_value": 10 },
         "machine_nozzle_offset_x": { "default_value": 0 },
         "machine_nozzle_offset_y": { "default_value": 0 },

resources/extruders/ultimaker_methodxl_extruder_right.def.json

@@ -16,7 +16,7 @@
         },
         "machine_extruder_cooling_fan_number": { "default_value": 1 },
         "machine_extruder_end_code": { "default_value": "M106 P{extruder_nr} S1.0\nG91\nG0 Z0.4 F600\nG90\nG0 X{prime_tower_position_x - prime_tower_size/2} Y{prime_tower_position_y + prime_tower_size/2} F6000" },
-        "machine_extruder_start_code": { "default_value": "G0 X{prime_tower_position_x - prime_tower_size/2} Y{prime_tower_position_y + prime_tower_size/2} F6000\nM104 S{material_print_temperature}\nG4 S5\nG91\nG0 Z-0.4 F600\nG90\nM107 P{(extruder_nr+1)%2}\nM106 P{extruder_nr} S{cool_fan_speed_0/100}" },
+        "machine_extruder_start_code": { "default_value": "G0 X{prime_tower_position_x - prime_tower_size/2} Y{prime_tower_position_y + prime_tower_size/2} F6000\nM104 S{material_print_temperature}\nG4 S5\nG91\nG0 Z-0.4 F600\nG90\nM107 P{(extruder_nr+1)%2}\nM106 P{extruder_nr} S{(layer_z > 1 ? cool_fan_speed/100 : cool_fan_speed_0/100)}" },
         "machine_extruder_start_code_duration": { "default_value": 10 },
         "machine_nozzle_offset_x": { "default_value": 0 },
         "machine_nozzle_offset_y": { "default_value": 0 },

resources/extruders/ultimaker_sketch_extruder.def.json

@@ -0,0 +1,22 @@
+{
+    "version": 2,
+    "name": "Extruder",
+    "inherits": "fdmextruder",
+    "metadata":
+    {
+        "machine": "ultimaker_sketch",
+        "position": "0"
+    },
+    "overrides":
+    {
+        "extruder_nr":
+        {
+            "default_value": 0,
+            "maximum_value": "1"
+        },
+        "machine_nozzle_offset_x": { "default_value": 0 },
+        "machine_nozzle_offset_y": { "default_value": 0 },
+        "machine_nozzle_size": { "default_value": 0.4 },
+        "material_diameter": { "default_value": 1.75 }
+    }
+}

resources/extruders/ultimaker_sketch_large_extruder.def.json

@@ -0,0 +1,22 @@
+{
+    "version": 2,
+    "name": "Extruder",
+    "inherits": "fdmextruder",
+    "metadata":
+    {
+        "machine": "ultimaker_sketch_large",
+        "position": "0"
+    },
+    "overrides":
+    {
+        "extruder_nr":
+        {
+            "default_value": 0,
+            "maximum_value": "1"
+        },
+        "machine_nozzle_offset_x": { "default_value": 0 },
+        "machine_nozzle_offset_y": { "default_value": 0 },
+        "machine_nozzle_size": { "default_value": 0.4 },
+        "material_diameter": { "default_value": 1.75 }
+    }
+}

resources/extruders/ultimaker_sketch_sprint_extruder.def.json

@@ -0,0 +1,22 @@
+{
+    "version": 2,
+    "name": "Extruder",
+    "inherits": "fdmextruder",
+    "metadata":
+    {
+        "machine": "ultimaker_sketch_sprint",
+        "position": "0"
+    },
+    "overrides":
+    {
+        "extruder_nr":
+        {
+            "default_value": 0,
+            "maximum_value": "1"
+        },
+        "machine_nozzle_offset_x": { "default_value": 0 },
+        "machine_nozzle_offset_y": { "default_value": 0 },
+        "machine_nozzle_size": { "default_value": 0.4 },
+        "material_diameter": { "default_value": 1.75 }
+    }
+}

resources/i18n/cs_CZ/fdmprinter.def.json.po

@@ -5893,53 +5893,53 @@ msgstr "cestování"
 #~ msgid "Brim Only on Outside"
 #~ msgstr "Límec pouze venku"
 
-#~ msgctxt "gradual_flow_discretisation_step_size description"
-#~ msgid "Duration of each step in the gradual flow change"
-#~ msgstr "Doba trvání každého kroku v postupné změně průtoku"
+msgctxt "gradual_flow_discretisation_step_size description"
+msgid "Duration of each step in the gradual flow change"
+msgstr "Doba trvání každého kroku v postupné změně průtoku"
 
-#~ msgctxt "gradual_flow_enabled description"
-#~ msgid "Enable gradual flow changes. When enabled, the flow is gradually increased/decreased to the target flow. This is useful for printers with a bowden tube where the flow is not immediately changed when the extruder motor starts/stops."
-#~ msgstr "Povolit postupné změny průtoku. Když je povoleno, průtok se postupně zvyšuje / snižuje na cílový průtok. Toto je užitečné pro tiskárny s Bowdenovou trubicí, kde se průtok okamžitě nezmění, když se spustí / zastaví extrudér."
+msgctxt "gradual_flow_enabled description"
+msgid "Enable gradual flow changes. When enabled, the flow is gradually increased/decreased to the target flow. This is useful for printers with a bowden tube where the flow is not immediately changed when the extruder motor starts/stops."
+msgstr "Povolit postupné změny průtoku. Když je povoleno, průtok se postupně zvyšuje / snižuje na cílový průtok. Toto je užitečné pro tiskárny s Bowdenovou trubicí, kde se průtok okamžitě nezmění, když se spustí / zastaví extrudér."
 
-#~ msgctxt "reset_flow_duration description"
-#~ msgid "For any travel move longer than this value, the material flow is reset to the paths target flow"
-#~ msgstr "Pro jakýkoli pohyb delší než tato hodnota se materiálový průtok resetuje na cílový průtok dráhy"
+msgctxt "reset_flow_duration description"
+msgid "For any travel move longer than this value, the material flow is reset to the paths target flow"
+msgstr "Pro jakýkoli pohyb delší než tato hodnota se materiálový průtok resetuje na cílový průtok dráhy"
 
-#~ msgctxt "gradual_flow_discretisation_step_size label"
-#~ msgid "Gradual flow discretisation step size"
-#~ msgstr "Velikost kroku diskretizace postupné změny průtoku"
+msgctxt "gradual_flow_discretisation_step_size label"
+msgid "Gradual flow discretisation step size"
+msgstr "Velikost kroku diskretizace postupné změny průtoku"
 
-#~ msgctxt "gradual_flow_enabled label"
-#~ msgid "Gradual flow enabled"
-#~ msgstr "Postupné změny průtoku povoleny"
+msgctxt "gradual_flow_enabled label"
+msgid "Gradual flow enabled"
+msgstr "Postupné změny průtoku povoleny"
 
-#~ msgctxt "max_flow_acceleration label"
-#~ msgid "Gradual flow max acceleration"
-#~ msgstr "Maximální zrychlení postupných změn průtoku"
+msgctxt "max_flow_acceleration label"
+msgid "Gradual flow max acceleration"
+msgstr "Maximální zrychlení postupných změn průtoku"
 
-#~ msgctxt "layer_0_max_flow_acceleration label"
-#~ msgid "Initial layer max flow acceleration"
-#~ msgstr "Maximální zrychlení průtoku pro první vrstvu"
+msgctxt "layer_0_max_flow_acceleration label"
+msgid "Initial layer max flow acceleration"
+msgstr "Maximální zrychlení průtoku pro první vrstvu"
 
 #~ msgctxt "layer_0_z_overlap description"
 #~ msgid "Make the first and second layer of the model overlap in the Z direction to compensate for the filament lost in the airgap. All models above the first model layer will be shifted down by this amount."
 #~ msgstr "První a druhá vrstva modelu se překrývají ve směru Z, aby se kompenzovalo vlákno ztracené ve vzduchové mezeře. Všechny modely nad první vrstvou modelu budou o tuto částku posunuty dolů."
 
-#~ msgctxt "max_flow_acceleration description"
-#~ msgid "Maximum acceleration for gradual flow changes"
-#~ msgstr "Maximální zrychlení pro postupné změny průtoku"
+msgctxt "max_flow_acceleration description"
+msgid "Maximum acceleration for gradual flow changes"
+msgstr "Maximální zrychlení pro postupné změny průtoku"
 
-#~ msgctxt "layer_0_max_flow_acceleration description"
-#~ msgid "Minimum speed for gradual flow changes for the first layer"
-#~ msgstr "Minimální rychlost pro postupné změny průtoku pro první vrstvu"
+msgctxt "layer_0_max_flow_acceleration description"
+msgid "Minimum speed for gradual flow changes for the first layer"
+msgstr "Minimální rychlost pro postupné změny průtoku pro první vrstvu"
 
 #~ msgctxt "brim_outside_only description"
 #~ msgid "Only print the brim on the outside of the model. This reduces the amount of brim you need to remove afterwards, while it doesn't reduce the bed adhesion that much."
 #~ msgstr "Límec tiskněte pouze na vnější stranu modelu. Tím se snižuje množství límce, který je třeba následně odstranit, zatímco to tolik nesnižuje přilnavost k podložce."
 
-#~ msgctxt "reset_flow_duration label"
-#~ msgid "Reset flow duration"
-#~ msgstr "Doba trvání resetování průtoku"
+msgctxt "reset_flow_duration label"
+msgid "Reset flow duration"
+msgstr "Doba trvání resetování průtoku"
 
 #~ msgctxt "support_interface_skip_height label"
 #~ msgid "Support Interface Resolution"

resources/i18n/cs_CZ/gradual_flow_settings.def.json.po

@@ -1,54 +0,0 @@
-#
-msgid ""
-msgstr ""
-"Project-Id-Version: Uranium json setting files\n"
-"Report-Msgid-Bugs-To: plugins@ultimaker.com\n"
-"POT-Creation-Date: 2024-03-11 11:28+0000\n"
-"PO-Revision-Date: 2024-03-11 11:28+0000\n"
-"Last-Translator: Automatically generated\n"
-"Language-Team: none\n"
-"Language: en\n"
-"MIME-Version: 1.0\n"
-"Content-Type: text/plain; charset=UTF-8\n"
-"Content-Transfer-Encoding: 8bit\n"
-"Plural-Forms: nplurals=2; plural=(n != 1);\n"
-
-msgctxt "gradual_flow_discretisation_step_size description"
-msgid "Duration of each step in the gradual flow change"
-msgstr ""
-
-msgctxt "gradual_flow_enabled description"
-msgid "Enable gradual flow changes. When enabled, the flow is gradually increased/decreased to the target flow. This is useful for printers with a bowden tube where the flow is not immediately changed when the extruder motor starts/stops."
-msgstr ""
-
-msgctxt "reset_flow_duration description"
-msgid "For any travel move longer than this value, the material flow is reset to the paths target flow"
-msgstr ""
-
-msgctxt "gradual_flow_discretisation_step_size label"
-msgid "Gradual flow discretisation step size"
-msgstr ""
-
-msgctxt "gradual_flow_enabled label"
-msgid "Gradual flow enabled"
-msgstr ""
-
-msgctxt "max_flow_acceleration label"
-msgid "Gradual flow max acceleration"
-msgstr ""
-
-msgctxt "layer_0_max_flow_acceleration label"
-msgid "Initial layer max flow acceleration"
-msgstr ""
-
-msgctxt "max_flow_acceleration description"
-msgid "Maximum acceleration for gradual flow changes"
-msgstr ""
-
-msgctxt "layer_0_max_flow_acceleration description"
-msgid "Minimum speed for gradual flow changes for the first layer"
-msgstr ""
-
-msgctxt "reset_flow_duration label"
-msgid "Reset flow duration"
-msgstr ""

resources/i18n/cura.pot

@@ -215,14 +215,14 @@ msgstr ""
 
 msgctxt "@label crash message"
 msgid ""
-"<p><b>A fatal error has occurred in Cura. Please send us this Crash Report to fix the problem</p></b>\n"
+"<p><b>A fatal error has occurred in Cura. Please send us this Crash Report to fix the problem</b></p>\n"
 "            <p>Please use the \"Send report\" button to post a bug report automatically to our servers</p>\n"
 "        "
 msgstr ""
 
 msgctxt "@label crash message"
 msgid ""
-"<p><b>Oops, UltiMaker Cura has encountered something that doesn't seem right.</p></b>\n"
+"<p><b>Oops, UltiMaker Cura has encountered something that doesn't seem right.</b></p>\n"
 "                    <p>We encountered an unrecoverable error during start up. It was possibly caused by some incorrect configuration files. We suggest to backup and reset your configuration.</p>\n"
 "                    <p>Backups can be found in the configuration folder.</p>\n"
 "                    <p>Please send us this Crash Report to fix the problem.</p>\n"

resources/i18n/de_DE/fdmprinter.def.json.po

@@ -5860,3 +5860,43 @@ msgstr "Beim Drucken der ersten Schicht der Raft-Oberfläche verschieben Sie um
 msgctxt "z_seam_on_vertex label"
 msgid "Z Seam On Vertex"
 msgstr "Z-Naht auf Scheitelpunkt"
+
+msgctxt "gradual_flow_discretisation_step_size description"
+msgid "Duration of each step in the gradual flow change"
+msgstr "Dauer jedes Schritts bei der sukzessiven Durchflusssänderung"
+
+msgctxt "gradual_flow_enabled description"
+msgid "Enable gradual flow changes. When enabled, the flow is gradually increased/decreased to the target flow. This is useful for printers with a bowden tube where the flow is not immediately changed when the extruder motor starts/stops."
+msgstr "Aktivieren Sie sukzessive Durchflussänderungen. Wenn diese Option aktiviert ist, wird der Durchfluss sukzessiv auf den angestrebten Durchfluss erhöht/verringert. Dies ist nützlich für Drucker mit einem Bowdenschlauch, bei denen der Durchfluss nicht sofort geändert wird, wenn der Extrudermotor startet/stoppt."
+
+msgctxt "reset_flow_duration description"
+msgid "For any travel move longer than this value, the material flow is reset to the paths target flow"
+msgstr "Für jede Verfahrbewegung, die länger als dieser Wert ist, wird der Materialfluss auf den Sollwegfluss zurückgesetzt."
+
+msgctxt "gradual_flow_discretisation_step_size label"
+msgid "Gradual flow discretisation step size"
+msgstr "Umfang des Diskretisierungsvorgangs bei sukzessivem Durchfluss"
+
+msgctxt "gradual_flow_enabled label"
+msgid "Gradual flow enabled"
+msgstr "Sukzessiver Durchfluss aktiviert"
+
+msgctxt "max_flow_acceleration label"
+msgid "Gradual flow max acceleration"
+msgstr "Maximale Beschleunigung bei sukzessivem Durchfluss"
+
+msgctxt "layer_0_max_flow_acceleration label"
+msgid "Initial layer max flow acceleration"
+msgstr "Maximale Durchflussbeschleunigung bei der Anfangsschicht"
+
+msgctxt "max_flow_acceleration description"
+msgid "Maximum acceleration for gradual flow changes"
+msgstr "Maximale Beschleunigung für sukzessive Durchflussänderungen"
+
+msgctxt "layer_0_max_flow_acceleration description"
+msgid "Minimum speed for gradual flow changes for the first layer"
+msgstr "Mindestgeschwindigkeit für sukzessive Durchflussänderungen bei der Anfangsschicht"
+
+msgctxt "reset_flow_duration label"
+msgid "Reset flow duration"
+msgstr "Durchflussdauer zurücksetzen"

resources/i18n/de_DE/gradual_flow_settings.def.json.po

@@ -1,53 +0,0 @@
-msgid ""
-msgstr ""
-"Project-Id-Version: PACKAGE VERSION\n"
-"Report-Msgid-Bugs-To: plugins@ultimaker.com\n"
-"POT-Creation-Date: 2024-03-11 11:28+0000\n"
-"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
-"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
-"Language-Team: LANGUAGE <LL@li.org>\n"
-"Language: de_DE\n"
-"MIME-Version: 1.0\n"
-"Content-Type: text/plain; charset=UTF-8\n"
-"Content-Transfer-Encoding: 8bit\n"
-"Plural-Forms: nplurals=2; plural=n != 1;\n"
-
-msgctxt "gradual_flow_discretisation_step_size description"
-msgid "Duration of each step in the gradual flow change"
-msgstr "Dauer jedes Schritts bei der sukzessiven Durchflusssänderung"
-
-msgctxt "gradual_flow_enabled description"
-msgid "Enable gradual flow changes. When enabled, the flow is gradually increased/decreased to the target flow. This is useful for printers with a bowden tube where the flow is not immediately changed when the extruder motor starts/stops."
-msgstr "Aktivieren Sie sukzessive Durchflussänderungen. Wenn diese Option aktiviert ist, wird der Durchfluss sukzessiv auf den angestrebten Durchfluss erhöht/verringert. Dies ist nützlich für Drucker mit einem Bowdenschlauch, bei denen der Durchfluss nicht sofort geändert wird, wenn der Extrudermotor startet/stoppt."
-
-msgctxt "reset_flow_duration description"
-msgid "For any travel move longer than this value, the material flow is reset to the paths target flow"
-msgstr "Für jede Verfahrbewegung, die länger als dieser Wert ist, wird der Materialfluss auf den Sollwegfluss zurückgesetzt."
-
-msgctxt "gradual_flow_discretisation_step_size label"
-msgid "Gradual flow discretisation step size"
-msgstr "Umfang des Diskretisierungsvorgangs bei sukzessivem Durchfluss"
-
-msgctxt "gradual_flow_enabled label"
-msgid "Gradual flow enabled"
-msgstr "Sukzessiver Durchfluss aktiviert"
-
-msgctxt "max_flow_acceleration label"
-msgid "Gradual flow max acceleration"
-msgstr "Maximale Beschleunigung bei sukzessivem Durchfluss"
-
-msgctxt "layer_0_max_flow_acceleration label"
-msgid "Initial layer max flow acceleration"
-msgstr "Maximale Durchflussbeschleunigung bei der Anfangsschicht"
-
-msgctxt "max_flow_acceleration description"
-msgid "Maximum acceleration for gradual flow changes"
-msgstr "Maximale Beschleunigung für sukzessive Durchflussänderungen"
-
-msgctxt "layer_0_max_flow_acceleration description"
-msgid "Minimum speed for gradual flow changes for the first layer"
-msgstr "Mindestgeschwindigkeit für sukzessive Durchflussänderungen bei der Anfangsschicht"
-
-msgctxt "reset_flow_duration label"
-msgid "Reset flow duration"
-msgstr "Durchflussdauer zurücksetzen"